add CompletionHandlerForAtomicService

Signed-off-by: wangbing <wangbing175@huawei-partners.com>

frameworks/js/napi/BUILD.gn

@@ -56,6 +56,7 @@ group("napi_packages") {
     "${ability_runtime_napi_path}/application_context_constant:contextconstant_napi",
     "${ability_runtime_napi_path}/callee:callee_napi",
     "${ability_runtime_napi_path}/caller:caller_napi",
+    "${ability_runtime_napi_path}/completion_handler_for_atomic_service:completionhandlerforatomicservice",
     "${ability_runtime_napi_path}/configuration_constant:configurationconstant",
     "${ability_runtime_napi_path}/configuration_constant:configurationconstant_napi",
     "${ability_runtime_napi_path}/dataUriUtils:datauriutils_napi",

frameworks/js/napi/completion_handler_for_atomic_service/BUILD.gn

@@ -0,0 +1,42 @@
+# Copyright (c) 2025 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build/ohos.gni")
+import("//foundation/ability/ability_runtime/ability_runtime.gni")
+
+ohos_shared_library("completionhandlerforatomicservice") {
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+  include_dirs = [
+    "${ability_runtime_services_path}/common/include",
+    "${ability_runtime_path}/interfaces/inner_api/ability_manager/include",
+  ]
+
+  sources = [ "completion_handler_for_atomic_service_module.cpp" ]
+
+  deps = []
+
+  external_deps = [
+    "bundle_framework:appexecfwk_base",
+    "c_utils:utils",
+    "hilog:libhilog",
+    "napi:ace_napi",
+  ]
+
+  relative_install_dir = "module/app/ability"
+  subsystem_name = "ability"
+  part_name = "ability_runtime"
+}

frameworks/js/napi/completion_handler_for_atomic_service/completion_handler_for_atomic_service_module.cpp

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "hilog_tag_wrapper.h"
+#include "native_engine/native_engine.h"
+#include "start_options.h"
+
+namespace OHOS {
+namespace AbilityRuntime {
+
+static napi_status SetEnumItem(napi_env env, napi_value object, const char* name, int32_t value)
+{
+    napi_status status;
+    napi_value itemName;
+    napi_value itemValue;
+
+    NAPI_CALL_BASE(env, status = napi_create_string_utf8(env, name, NAPI_AUTO_LENGTH, &itemName), status);
+    NAPI_CALL_BASE(env, status = napi_create_int32(env, value, &itemValue), status);
+
+    NAPI_CALL_BASE(env, status = napi_set_property(env, object, itemName, itemValue), status);
+    NAPI_CALL_BASE(env, status = napi_set_property(env, object, itemValue, itemName), status);
+
+    return napi_ok;
+}
+
+static napi_value InitFailureCodeObject(napi_env env)
+{
+    napi_value object;
+    NAPI_CALL(env, napi_create_object(env, &object));
+    NAPI_CALL(env, SetEnumItem(env, object, "FAILURE_CODE_SYSTEM_MALFUNCTION",
+        static_cast<int32_t>(FailureCode::FAILURE_CODE_SYSTEM_MALFUNCTION)));
+    NAPI_CALL(env, SetEnumItem(env, object, "FAILURE_CODE_USER_CANCEL",
+        static_cast<int32_t>(FailureCode::FAILURE_CODE_USER_CANCEL)));
+    NAPI_CALL(env, SetEnumItem(env, object, "FAILURE_CODE_USER_REFUSE",
+        static_cast<int32_t>(FailureCode::FAILURE_CODE_USER_REFUSE)));
+    return object;
+}
+
+static napi_value AbilityCompletionHandlerForAtomicServiceInit(napi_env env, napi_value exports)
+{
+    napi_value failureCode = InitFailureCodeObject(env);
+    if (failureCode == nullptr) {
+        TAG_LOGE(AAFwkTag::JSNAPI, "null failureCode");
+        return nullptr;
+    }
+
+    napi_property_descriptor exportObjs[] = {
+        DECLARE_NAPI_PROPERTY("FailureCode", failureCode),
+    };
+
+    napi_status status = napi_define_properties(env, exports, sizeof(exportObjs) / sizeof(exportObjs[0]), exportObjs);
+    if (status != napi_ok) {
+        TAG_LOGE(AAFwkTag::JSNAPI, "define properties failed");
+        return nullptr;
+    }
+
+    return exports;
+}
+
+/*
+ * The module definition.
+ */
+static napi_module _module = {
+    .nm_version = 0,
+    .nm_flags = 0,
+    .nm_filename = nullptr,
+    .nm_register_func = AbilityCompletionHandlerForAtomicServiceInit,
+    .nm_modname = "app.ability.CompletionHandlerForAtomicService",
+    .nm_priv = (static_cast<void *>(0)),
+    .reserved = {0}
+};
+
+/*
+ * The module registration.
+ */
+extern "C" __attribute__((constructor)) void RegisterModule(void)
+{
+    napi_module_register(&_module);
+}
+}
+}

frameworks/native/ability/ability_runtime/ability_context_impl.cpp

@@ -1330,18 +1330,33 @@ void AbilityContextImpl::OnRequestSuccess(const std::string &requestId, const Ap
             }
         }
     }
-
     if (result != nullptr) {
         TAG_LOGI(AAFwkTag::CONTEXT, "requestId=%{public}s, call onRequestSuccess", requestId.c_str());
         result->onRequestSuccess_(element, message);
         return;
     }
+    std::shared_ptr<OnAtomicRequestResult> atomicResult = nullptr;
+    {
+        std::lock_guard lock(onAtomicRequestResultMutex_);
+        for (auto iter = onAtomicRequestResults_.begin(); iter != onAtomicRequestResults_.end(); iter++) {
+            if ((*iter)->requestId_ == requestId) {
+                atomicResult = *iter;
+                onAtomicRequestResults_.erase(iter);
+                break;
+            }
+        }
+    }
+    if (atomicResult != nullptr) {
+        TAG_LOGI(AAFwkTag::CONTEXT, "requestId=%{public}s, call onRequestSuccess", requestId.c_str());
+        atomicResult->onRequestSuccess_(atomicResult->appId_);
+        return;
+    }
 
     TAG_LOGE(AAFwkTag::CONTEXT, "requestId=%{public}s not exist", requestId.c_str());
 }
 
 void AbilityContextImpl::OnRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-    const std::string &message)
+    const std::string &message, int32_t resultCode)
 {
     std::shared_ptr<OnRequestResultElement> result = nullptr;
     {
@@ -1354,12 +1369,30 @@ void AbilityContextImpl::OnRequestFailure(const std::string &requestId, const Ap
             }
         }
     }
-
     if (result != nullptr) {
         TAG_LOGI(AAFwkTag::CONTEXT, "requestId=%{public}s, call onRequestFailure", requestId.c_str());
         result->onRequestFailure_(element, message);
         return;
     }
+    std::shared_ptr<OnAtomicRequestResult> atomicResult = nullptr;
+    {
+        std::lock_guard lock(onAtomicRequestResultMutex_);
+        for (auto iter = onAtomicRequestResults_.begin(); iter != onAtomicRequestResults_.end(); iter++) {
+            if ((*iter)->requestId_ == requestId) {
+                atomicResult = *iter;
+                onAtomicRequestResults_.erase(iter);
+                break;
+            }
+        }
+    }
+    if (atomicResult != nullptr) {
+        TAG_LOGI(AAFwkTag::CONTEXT, "requestId=%{public}s, call onRequestFailure", requestId.c_str());
+        int32_t failureCode = 0;
+        std::string failureMessage;
+        GetFailureInfoByMessage(message, failureCode, failureMessage, resultCode);
+        atomicResult->onRequestFailure_(atomicResult->appId_, failureCode, failureMessage);
+        return;
+    }
 
     TAG_LOGE(AAFwkTag::CONTEXT, "requestId=%{public}s not exist", requestId.c_str());
 }
@@ -1407,5 +1440,39 @@ ErrCode AbilityContextImpl::SetOnNewWantSkipScenarios(int32_t scenarios)
     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
     return AAFwk::AbilityManagerClient::GetInstance()->SetOnNewWantSkipScenarios(token_, scenarios);
 }
+
+ErrCode AbilityContextImpl::AddCompletionHandlerForAtomicService(const std::string &requestId,
+    OnAtomicRequestSuccess onRequestSucc, OnAtomicRequestFailure onRequestFail, const std::string &appId)
+{
+    if (onRequestSucc == nullptr || onRequestFail == nullptr) {
+        TAG_LOGE(AAFwkTag::CONTEXT, "either func is null");
+        return ERR_INVALID_VALUE;
+    }
+    std::lock_guard lock(onAtomicRequestResultMutex_);
+    for (auto iter = onAtomicRequestResults_.begin(); iter != onAtomicRequestResults_.end(); iter++) {
+        if ((*iter)->requestId_ == requestId) {
+            TAG_LOGI(AAFwkTag::CONTEXT, "requestId=%{public}s already exists", requestId.c_str());
+            return ERR_OK;
+        }
+    }
+    onAtomicRequestResults_.emplace_back(std::make_shared<OnAtomicRequestResult>(
+        requestId, appId, onRequestSucc, onRequestFail));
+    return ERR_OK;
+}
+
+void AbilityContextImpl::GetFailureInfoByMessage(
+    const std::string &message, int32_t &failureCode, std::string &failureMessage, int32_t resultCode)
+{
+    if (resultCode == USER_CANCEL) {
+        failureCode = static_cast<int32_t>(FailureCode::FAILURE_CODE_USER_CANCEL);
+        failureMessage = "User cancelled redirection";
+    } else if (message.find("User refused redirection") != std::string::npos) {
+        failureCode = static_cast<int32_t>(FailureCode::FAILURE_CODE_USER_REFUSE);
+        failureMessage = "User refused redirection";
+    } else {
+        failureCode = static_cast<int32_t>(FailureCode::FAILURE_CODE_SYSTEM_MALFUNCTION);
+        failureMessage = "failed to open atomicservice";
+    }
+}
 } // namespace AbilityRuntime
 } // namespace OHOS

frameworks/native/ability/native/ability_runtime/js_ability_context.cpp

@@ -525,6 +525,56 @@ void JsAbilityContext::UnwrapCompletionHandlerInStartOptions(napi_env env, napi_
     options.requestId_ = requestId;
 }
 
+void JsAbilityContext::UnWrapCompletionHandlerForAtomicService(
+    napi_env env, napi_value param, AAFwk::StartOptions &options, const std::string &appId)
+{
+    napi_value completionHandlerForAtomicService = AppExecFwk::GetPropertyValueByPropertyName(env, param,
+        "completionHandlerForAtomicService", napi_object);
+    if (completionHandlerForAtomicService == nullptr) {
+        TAG_LOGD(AAFwkTag::CONTEXT, "null completionHandlerForAtomicService");
+        return;
+    }
+    napi_value onRequestSuccFunc = AppExecFwk::GetPropertyValueByPropertyName(env, completionHandlerForAtomicService,
+        "onAtomicServiceRequestSuccess", napi_function);
+    napi_value onRequestFailFunc = AppExecFwk::GetPropertyValueByPropertyName(env, completionHandlerForAtomicService,
+        "onAtomicServiceRequestFailure", napi_function);
+    if (onRequestSuccFunc == nullptr || onRequestFailFunc == nullptr) {
+        TAG_LOGE(AAFwkTag::CONTEXT, "null onRequestSuccFunc or onRequestFailFunc");
+        return;
+    }
+    OnAtomicRequestSuccess onRequestSucc = [env, completionHandlerForAtomicService, onRequestSuccFunc](
+        const std::string &appId) {
+        napi_value argv[ARGC_ONE] = { CreateJsValue(env, appId) };
+        napi_status status = napi_call_function(
+            env, completionHandlerForAtomicService, onRequestSuccFunc, ARGC_ONE, argv, nullptr);
+        if (status != napi_ok) {
+            TAG_LOGE(AAFwkTag::CONTEXT, "call onRequestSuccess, failed: %{public}d", status);
+        }
+    };
+    OnAtomicRequestFailure onRequestFail = [env, completionHandlerForAtomicService, onRequestFailFunc](
+        const std::string &appId, int32_t failureCode, const std::string &message) {
+        napi_value argv[ARGC_THREE] = { CreateJsValue(env, appId), CreateJsValue(env, failureCode),
+            CreateJsValue(env, message) };
+        napi_status status = napi_call_function(
+            env, completionHandlerForAtomicService, onRequestFailFunc, ARGC_THREE, argv, nullptr);
+        if (status != napi_ok) {
+            TAG_LOGE(AAFwkTag::CONTEXT, "call onRequestFailure, failed: %{public}d", status);
+        }
+    };
+    auto context = context_.lock();
+    if (!context) {
+        TAG_LOGE(AAFwkTag::CONTEXT, "null context");
+        return;
+    }
+    std::string requestId = std::to_string(static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(
+        std::chrono::high_resolution_clock::now().time_since_epoch()).count()));
+    if (context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId) != ERR_OK) {
+        TAG_LOGE(AAFwkTag::CONTEXT, "add completionHandler failed");
+        return;
+    }
+    options.requestId_ = requestId;
+}
+
 napi_value JsAbilityContext::OnStartAbility(napi_env env, NapiCallbackInfo& info, bool isStartRecent)
 {
     StartAsyncTrace(HITRACE_TAG_ABILITY_MANAGER, TRACE_ATOMIC_SERVICE, TRACE_ATOMIC_SERVICE_ID);
@@ -2968,7 +3018,7 @@ napi_value JsAbilityContext::OnOpenAtomicService(napi_env env, NapiCallbackInfo&
             ThrowInvalidParamError(env, "Parse param startOptions failed, startOptions must be StartOption.");
             return CreateJsUndefined(env);
         }
-        UnwrapCompletionHandlerInStartOptions(env, info.argv[INDEX_ONE], startOptions);
+        UnWrapCompletionHandlerForAtomicService(env, info.argv[INDEX_ONE], startOptions, appId);
     }
 
     std::string bundleName = ATOMIC_SERVICE_PREFIX + appId;

frameworks/native/ability/native/ability_runtime/js_ui_ability.cpp

@@ -1392,16 +1392,16 @@ void JsUIAbility::HandleCollaboration(const Want &want)
 #endif
 
 void JsUIAbility::OnAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-    const std::string &message)
+    const std::string &message, int32_t resultCode)
 {
     TAG_LOGD(AAFwkTag::UIABILITY, "OnAbilityRequestFailure called");
-    UIAbility::OnAbilityRequestFailure(requestId, element, message);
+    UIAbility::OnAbilityRequestFailure(requestId, element, message, resultCode);
     auto abilityContext = GetAbilityContext();
     if (abilityContext == nullptr) {
         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext");
         return;
     }
-    abilityContext->OnRequestFailure(requestId, element, message);
+    abilityContext->OnRequestFailure(requestId, element, message, resultCode);
 }
 
 void JsUIAbility::OnAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element,

frameworks/native/ability/native/ability_thread.cpp

@@ -292,7 +292,7 @@ void AbilityThread::ScheduleCollaborate(const Want &want)
 }
 
 void AbilityThread::ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-    const std::string &message)
+    const std::string &message, int32_t resultCode)
 {
     TAG_LOGD(AAFwkTag::ABILITY, "called");
 }

frameworks/native/ability/native/extension.cpp

@@ -205,7 +205,7 @@ bool Extension::OnInsightIntentExecuteDone(uint64_t intentId, const AppExecFwk::
 }
 
 void Extension::OnExtensionAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-    const std::string &message)
+    const std::string &message, int32_t resultCode)
 {
 }
 

frameworks/native/ability/native/extension_ability_thread.cpp

@@ -638,7 +638,7 @@ void ExtensionAbilityThread::DumpAbilityInfo(const std::vector<std::string> &par
 }
 
 void ExtensionAbilityThread::ScheduleAbilityRequestFailure(const std::string &requestId,
-    const AppExecFwk::ElementName &element, const std::string &message)
+    const AppExecFwk::ElementName &element, const std::string &message, int32_t resultCode)
 {
     TAG_LOGD(AAFwkTag::EXT, "ExtensionAbilityThread::ScheduleAbilityRequestFailure called");
     if (extensionImpl_ == nullptr) {
@@ -646,14 +646,15 @@ void ExtensionAbilityThread::ScheduleAbilityRequestFailure(const std::string &re
         return;
     }
     wptr<ExtensionAbilityThread> weak = this;
-    auto task = [weak, requestId, element, message]() {
+    auto task = [weak, requestId, element, message, resultCode]() {
         auto extensionAbilityThread = weak.promote();
         if (extensionAbilityThread == nullptr) {
             TAG_LOGE(AAFwkTag::EXT, "null extensionAbilityThread");
             return;
         }
         if (extensionAbilityThread->extensionImpl_ != nullptr) {
-            extensionAbilityThread->extensionImpl_->ScheduleAbilityRequestFailure(requestId, element, message);
+            extensionAbilityThread->extensionImpl_->ScheduleAbilityRequestFailure(
+                requestId, element, message, resultCode);
             return;
         }
     };

frameworks/native/ability/native/extension_impl.cpp

@@ -471,14 +471,14 @@ void ExtensionImpl::SetLaunchParam(const AAFwk::LaunchParam &launchParam)
 }
 
 void ExtensionImpl::ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-    const std::string &message)
+    const std::string &message, int32_t resultCode)
 {
     TAG_LOGD(AAFwkTag::EXT, "ScheduleAbilityRequestFailure called");
     if (extension_ == nullptr) {
         TAG_LOGE(AAFwkTag::EXT, "null extension_");
         return;
     }
-    extension_->OnExtensionAbilityRequestFailure(requestId, element, message);
+    extension_->OnExtensionAbilityRequestFailure(requestId, element, message, resultCode);
 }
 
 void ExtensionImpl::ScheduleAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element)

frameworks/native/ability/native/js_service_extension_context.cpp

@@ -398,38 +398,39 @@ private:
         return result;
     }
 
-    void UnwrapCompletionHandlerInStartOptions(napi_env env, napi_value param,
-        AAFwk::StartOptions &options)
+    void UnWrapCompletionHandlerForAtomicService(
+        napi_env env, napi_value param, AAFwk::StartOptions &options, const std::string &appId)
     {
-        napi_value completionHandler = AppExecFwk::GetPropertyValueByPropertyName(env, param,
-            "completionHandler", napi_object);
-        if (completionHandler == nullptr) {
-            TAG_LOGD(AAFwkTag::SERVICE_EXT, "null completionHandler");
+        napi_value completionHandlerForAtomicService = AppExecFwk::GetPropertyValueByPropertyName(env, param,
+            "completionHandlerForAtomicService", napi_object);
+        if (completionHandlerForAtomicService == nullptr) {
+            TAG_LOGD(AAFwkTag::SERVICE_EXT, "null completionHandlerForAtomicService");
             return;
         }
-        TAG_LOGI(AAFwkTag::SERVICE_EXT, "completionHandler exists");
-        napi_value onRequestSuccObj = AppExecFwk::GetPropertyValueByPropertyName(env, completionHandler,
-            "onRequestSuccess", napi_function);
-        napi_value onRequestFailObj = AppExecFwk::GetPropertyValueByPropertyName(env, completionHandler,
-            "onRequestFailure", napi_function);
-        if (onRequestSuccObj == nullptr || onRequestFailObj == nullptr) {
-            TAG_LOGE(AAFwkTag::SERVICE_EXT, "null onRequestSuccObj or onRequestFailObj");
+        TAG_LOGI(AAFwkTag::SERVICE_EXT, "completionHandlerForAtomicService exists");
+        napi_value onRequestSuccFunc = AppExecFwk::GetPropertyValueByPropertyName(env,
+            completionHandlerForAtomicService, "onAtomicServiceRequestSuccess", napi_function);
+        napi_value onRequestFailFunc = AppExecFwk::GetPropertyValueByPropertyName(env,
+            completionHandlerForAtomicService, "onAtomicServiceRequestFailure", napi_function);
+        if (onRequestSuccFunc == nullptr || onRequestFailFunc == nullptr) {
+            TAG_LOGE(AAFwkTag::SERVICE_EXT, "null onRequestSuccFunc or onRequestFailFunc");
             return;
         }
-        OnRequestResult onRequestSucc = [env, completionHandler, onRequestSuccObj](
-            const AppExecFwk::ElementName &element, const std::string &message) {
-            size_t argc = ARGC_TWO;
-            napi_value argv[ARGC_TWO] = { AppExecFwk::WrapElementName(env, element), CreateJsValue(env, message) };
-            napi_status status = napi_call_function(env, completionHandler, onRequestSuccObj, argc, argv, nullptr);
+        OnAtomicRequestSuccess onRequestSucc = [env, completionHandlerForAtomicService, onRequestSuccFunc](
+            const std::string &appId) {
+            napi_value argv[ARGC_ONE] = { CreateJsValue(env, appId) };
+            napi_status status = napi_call_function(
+                env, completionHandlerForAtomicService, onRequestSuccFunc, ARGC_ONE, argv, nullptr);
             if (status != napi_ok) {
                 TAG_LOGE(AAFwkTag::SERVICE_EXT, "call onRequestSuccess, failed: %{public}d", status);
             }
         };
-        OnRequestResult onRequestFail = [env, completionHandler, onRequestFailObj](
-            const AppExecFwk::ElementName &element, const std::string &message) {
-            size_t argc = ARGC_TWO;
-            napi_value argv[ARGC_TWO] = { AppExecFwk::WrapElementName(env, element), CreateJsValue(env, message) };
-            napi_status status = napi_call_function(env, completionHandler, onRequestFailObj, argc, argv, nullptr);
+        OnAtomicRequestFailure onRequestFail = [env, completionHandlerForAtomicService, onRequestFailFunc](
+            const std::string &appId, int32_t failureCode, const std::string &message) {
+            napi_value argv[ARGC_THREE] = { CreateJsValue(env, appId), CreateJsValue(env, failureCode),
+                CreateJsValue(env, message) };
+            napi_status status = napi_call_function(
+                env, completionHandlerForAtomicService, onRequestFailFunc, ARGC_THREE, argv, nullptr);
             if (status != napi_ok) {
                 TAG_LOGE(AAFwkTag::SERVICE_EXT, "call onRequestFailure, failed: %{public}d", status);
             }
@@ -439,10 +440,10 @@ private:
             TAG_LOGE(AAFwkTag::SERVICE_EXT, "null context");
             return;
         }
-        auto time = static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(
-            std::chrono::high_resolution_clock::now().time_since_epoch()).count());
-        std::string requestId = std::to_string(time);
-        if (context->AddCompletionHandler(requestId, onRequestSucc, onRequestFail) != ERR_OK) {
+        std::string requestId = std::to_string(
+            static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::high_resolution_clock::now().time_since_epoch()).count()));
+        if (context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId) != ERR_OK) {
             TAG_LOGE(AAFwkTag::SERVICE_EXT, "add completionHandler failed");
             return;
         }
@@ -473,7 +474,7 @@ private:
                 ThrowInvalidParamError(env, "Parse param startOptions failed, startOptions must be StartOption.");
                 return CreateJsUndefined(env);
             }
-            UnwrapCompletionHandlerInStartOptions(env, info.argv[INDEX_ONE], startOptions);
+            UnWrapCompletionHandlerForAtomicService(env, info.argv[INDEX_ONE], startOptions, appId);
         }
 
         std::string bundleName = ATOMIC_SERVICE_PREFIX + appId;

frameworks/native/ability/native/ui_ability.cpp

@@ -844,7 +844,7 @@ void UIAbility::HandleCollaboration(const AAFwk::Want &want)
 }
 
 void UIAbility::OnAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-    const std::string &message)
+    const std::string &message, int32_t resultCode)
 {
     TAG_LOGD(AAFwkTag::UIABILITY, "called");
 }

frameworks/native/ability/native/ui_ability_impl.cpp

@@ -938,14 +938,14 @@ void UIAbilityImpl::ScheduleCollaborate(const Want &want)
 }
 
 void UIAbilityImpl::ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-    const std::string &message)
+    const std::string &message, int32_t resultCode)
 {
     TAG_LOGD(AAFwkTag::UIABILITY, "ScheduleAbilityRequestFailure called");
     if (ability_ == nullptr) {
         TAG_LOGE(AAFwkTag::UIABILITY, "null ability_");
         return;
     }
-    ability_->OnAbilityRequestFailure(requestId, element, message);
+    ability_->OnAbilityRequestFailure(requestId, element, message, resultCode);
 }
 
 void UIAbilityImpl::ScheduleAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element)

frameworks/native/ability/native/ui_ability_thread.cpp

@@ -705,7 +705,7 @@ void UIAbilityThread::ScheduleCollaborate(const Want &want)
 }
 
 void UIAbilityThread::ScheduleAbilityRequestFailure(const std::string &requestId,
-    const AppExecFwk::ElementName &element, const std::string &message)
+    const AppExecFwk::ElementName &element, const std::string &message, int32_t resultCode)
 {
     TAG_LOGD(AAFwkTag::UIABILITY, "ScheduleAbilityRequestFailure called");
     if (abilityImpl_ == nullptr) {
@@ -713,14 +713,14 @@ void UIAbilityThread::ScheduleAbilityRequestFailure(const std::string &requestId
         return;
     }
     wptr<UIAbilityThread> weak = this;
-    auto task = [weak, requestId, element, message]() {
+    auto task = [weak, requestId, element, message, resultCode]() {
         auto abilityThread = weak.promote();
         if (abilityThread == nullptr) {
             TAG_LOGE(AAFwkTag::UIABILITY, "null abilityThread");
             return;
         }
         if (abilityThread->abilityImpl_ != nullptr) {
-            abilityThread->abilityImpl_->ScheduleAbilityRequestFailure(requestId, element, message);
+            abilityThread->abilityImpl_->ScheduleAbilityRequestFailure(requestId, element, message, resultCode);
             return;
         }
     };

frameworks/native/ability/native/ui_extension_base/js_ui_extension_context.cpp

@@ -1032,7 +1032,7 @@ napi_value JsUIExtensionContext::OnOpenAtomicService(napi_env env, NapiCallbackI
                 "Parse param startOptions failed, startOptions must be StartOption.");
             return CreateJsUndefined(env);
         }
-        UnwrapCompletionHandlerInStartOptions(env, info.argv[INDEX_ONE], startOptions);
+        UnWrapCompletionHandlerForAtomicService(env, info.argv[INDEX_ONE], startOptions, appId);
         unwrapArgc++;
     }
     std::string bundleName = ATOMIC_SERVICE_PREFIX + appId;
@@ -1724,38 +1724,39 @@ napi_value JSUIExtensionConnection::CallObjectMethod(const char* name, napi_valu
     return result;
 }
 
-void JsUIExtensionContext::UnwrapCompletionHandlerInStartOptions(napi_env env, napi_value param,
-    AAFwk::StartOptions &options)
+void JsUIExtensionContext::UnWrapCompletionHandlerForAtomicService(
+    napi_env env, napi_value param, AAFwk::StartOptions &options, const std::string &appId)
 {
-    napi_value completionHandler = AppExecFwk::GetPropertyValueByPropertyName(env, param,
-        "completionHandler", napi_object);
-    if (completionHandler == nullptr) {
-        TAG_LOGD(AAFwkTag::UI_EXT, "null completionHandler");
+    napi_value completionHandlerForAtomicService = AppExecFwk::GetPropertyValueByPropertyName(env, param,
+        "completionHandlerForAtomicService", napi_object);
+    if (completionHandlerForAtomicService == nullptr) {
+        TAG_LOGD(AAFwkTag::UI_EXT, "null completionHandlerForAtomicService");
         return;
     }
-    TAG_LOGI(AAFwkTag::UI_EXT, "completionHandler exists");
-    napi_value onRequestSuccObj = AppExecFwk::GetPropertyValueByPropertyName(env, completionHandler,
-        "onRequestSuccess", napi_function);
-    napi_value onRequestFailObj = AppExecFwk::GetPropertyValueByPropertyName(env, completionHandler,
-        "onRequestFailure", napi_function);
-    if (onRequestSuccObj == nullptr || onRequestFailObj == nullptr) {
-        TAG_LOGE(AAFwkTag::UI_EXT, "null onRequestSuccObj or onRequestFailObj");
+    TAG_LOGI(AAFwkTag::UI_EXT, "completionHandlerForAtomicService exists");
+    napi_value onRequestSuccFunc = AppExecFwk::GetPropertyValueByPropertyName(env, completionHandlerForAtomicService,
+        "onAtomicServiceRequestSuccess", napi_function);
+    napi_value onRequestFailFunc = AppExecFwk::GetPropertyValueByPropertyName(env, completionHandlerForAtomicService,
+        "onAtomicServiceRequestFailure", napi_function);
+    if (onRequestSuccFunc == nullptr || onRequestFailFunc == nullptr) {
+        TAG_LOGE(AAFwkTag::UI_EXT, "null onRequestSuccFunc or onRequestFailFunc");
         return;
     }
-    OnRequestResult onRequestSucc = [env, completionHandler, onRequestSuccObj](const AppExecFwk::ElementName &element,
-        const std::string &message) {
-        size_t argc = ARGC_TWO;
-        napi_value argv[ARGC_TWO] = { AppExecFwk::WrapElementName(env, element), CreateJsValue(env, message) };
-        napi_status status = napi_call_function(env, completionHandler, onRequestSuccObj, argc, argv, nullptr);
+    OnAtomicRequestSuccess onRequestSucc = [env, completionHandlerForAtomicService, onRequestSuccFunc](
+        const std::string &appId) {
+        napi_value argv[ARGC_ONE] = { CreateJsValue(env, appId) };
+        napi_status status = napi_call_function(
+            env, completionHandlerForAtomicService, onRequestSuccFunc, ARGC_ONE, argv, nullptr);
         if (status != napi_ok) {
             TAG_LOGE(AAFwkTag::UI_EXT, "call onRequestSuccess, failed: %{public}d", status);
         }
     };
-    OnRequestResult onRequestFail = [env, completionHandler, onRequestFailObj](const AppExecFwk::ElementName &element,
-        const std::string &message) {
-        size_t argc = ARGC_TWO;
-        napi_value argv[ARGC_TWO] = { AppExecFwk::WrapElementName(env, element), CreateJsValue(env, message) };
-        napi_status status = napi_call_function(env, completionHandler, onRequestFailObj, argc, argv, nullptr);
+    OnAtomicRequestFailure onRequestFail = [env, completionHandlerForAtomicService, onRequestFailFunc](
+        const std::string &appId, int32_t failureCode, const std::string &message) {
+        napi_value argv[ARGC_THREE] = { CreateJsValue(env, appId), CreateJsValue(env, failureCode),
+            CreateJsValue(env, message) };
+        napi_status status = napi_call_function(
+            env, completionHandlerForAtomicService, onRequestFailFunc, ARGC_THREE, argv, nullptr);
         if (status != napi_ok) {
             TAG_LOGE(AAFwkTag::UI_EXT, "call onRequestFailure, failed: %{public}d", status);
         }
@@ -1767,7 +1768,7 @@ void JsUIExtensionContext::UnwrapCompletionHandlerInStartOptions(napi_env env, n
     }
     std::string requestId = std::to_string(static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(
         std::chrono::high_resolution_clock::now().time_since_epoch()).count()));
-    if (context->AddCompletionHandler(requestId, onRequestSucc, onRequestFail) != ERR_OK) {
+    if (context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId) != ERR_OK) {
         TAG_LOGE(AAFwkTag::UI_EXT, "add completionHandler failed");
         return;
     }

frameworks/native/ability/native/ui_extension_base/ui_extension_context.cpp

@@ -467,56 +467,91 @@ void UIExtensionContext::RequestComponentTerminate()
     }
 }
 
-ErrCode UIExtensionContext::AddCompletionHandler(const std::string &requestId, OnRequestResult onRequestSucc,
-    OnRequestResult onRequestFail)
+ErrCode UIExtensionContext::AddCompletionHandlerForAtomicService(const std::string &requestId,
+    OnAtomicRequestSuccess onRequestSucc, OnAtomicRequestFailure onRequestFail, const std::string &appId)
 {
     if (onRequestSucc == nullptr || onRequestFail == nullptr) {
         TAG_LOGE(AAFwkTag::UI_EXT, "either func is null");
         return ERR_INVALID_VALUE;
     }
     std::lock_guard lock(onRequestResultMutex_);
-    for (auto iter = onRequestResults_.begin(); iter != onRequestResults_.end(); iter++) {
-        if (iter->requestId_ == requestId) {
+    for (auto iter = onAtomicRequestResults_.begin(); iter != onAtomicRequestResults_.end(); iter++) {
+        if ((*iter)->requestId_ == requestId) {
             TAG_LOGI(AAFwkTag::UI_EXT, "requestId=%{public}s already exists", requestId.c_str());
             return ERR_OK;
         }
     }
-    onRequestResults_.emplace_back(requestId, onRequestSucc, onRequestFail);
+    onAtomicRequestResults_.emplace_back(std::make_shared<OnAtomicRequestResult>(
+        requestId, appId, onRequestSucc, onRequestFail));
     return ERR_OK;
 }
 
 void UIExtensionContext::OnRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element,
     const std::string &message)
 {
-    std::lock_guard<std::mutex> lock(onRequestResultMutex_);
-    for (auto iter = onRequestResults_.begin(); iter != onRequestResults_.end(); iter++) {
-        if (iter->requestId_ == requestId) {
-            TAG_LOGI(AAFwkTag::UI_EXT, "requestId=%{public}s, call onRequestSuccess", requestId.c_str());
-            iter->onRequestSuccess_(element, message);
-            onRequestResults_.erase(iter);
-            return;
+    std::shared_ptr<OnAtomicRequestResult> atomicResult = nullptr;
+    {
+        std::lock_guard<std::mutex> lock(onRequestResultMutex_);
+        for (auto iter = onAtomicRequestResults_.begin(); iter != onAtomicRequestResults_.end(); iter++) {
+            if ((*iter)->requestId_ == requestId) {
+                atomicResult = *iter;
+                onAtomicRequestResults_.erase(iter);
+                break;
+            }
         }
     }
 
+    if (atomicResult != nullptr) {
+        TAG_LOGI(AAFwkTag::CONTEXT, "requestId=%{public}s, call onRequestSuccess", requestId.c_str());
+        atomicResult->onRequestSuccess_(atomicResult->appId_);
+        return;
+    }
+
     TAG_LOGE(AAFwkTag::UI_EXT, "requestId=%{public}s not exist", requestId.c_str());
 }
 
 void UIExtensionContext::OnRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-    const std::string &message)
+    const std::string &message, int32_t resultCode)
 {
-    std::lock_guard<std::mutex> lock(onRequestResultMutex_);
-    for (auto iter = onRequestResults_.begin(); iter != onRequestResults_.end(); iter++) {
-        if (iter->requestId_ == requestId) {
-            TAG_LOGI(AAFwkTag::UI_EXT, "requestId=%{public}s, call onRequestFailure", requestId.c_str());
-            iter->onRequestFailure_(element, message);
-            onRequestResults_.erase(iter);
-            return;
+    std::shared_ptr<OnAtomicRequestResult> atomicResult = nullptr;
+    {
+        std::lock_guard lock(onRequestResultMutex_);
+        for (auto iter = onAtomicRequestResults_.begin(); iter != onAtomicRequestResults_.end(); iter++) {
+            if ((*iter)->requestId_ == requestId) {
+                atomicResult = *iter;
+                onAtomicRequestResults_.erase(iter);
+                break;
+            }
         }
     }
 
+    if (atomicResult != nullptr) {
+        TAG_LOGI(AAFwkTag::UI_EXT, "requestId=%{public}s, call onRequestFailure", requestId.c_str());
+        int32_t failureCode = 0;
+        std::string failureMessage;
+        GetFailureInfoByMessage(message, failureCode, failureMessage, resultCode);
+        atomicResult->onRequestFailure_(atomicResult->appId_, failureCode, failureMessage);
+        return;
+    }
+
     TAG_LOGE(AAFwkTag::UI_EXT, "requestId=%{public}s not exist", requestId.c_str());
 }
 
+void UIExtensionContext::GetFailureInfoByMessage(
+    const std::string &message, int32_t &failureCode, std::string &failureMessage, int32_t resultCode)
+{
+    if (resultCode == USER_CANCEL) {
+        failureCode = static_cast<int32_t>(FailureCode::FAILURE_CODE_USER_CANCEL);
+        failureMessage = "User cancelled redirection";
+    } else if (message.find("User refused redirection") != std::string::npos) {
+        failureCode = static_cast<int32_t>(FailureCode::FAILURE_CODE_USER_REFUSE);
+        failureMessage = "User refused redirection";
+    } else {
+        failureCode = static_cast<int32_t>(FailureCode::FAILURE_CODE_SYSTEM_MALFUNCTION);
+        failureMessage = "failed to open atomicservice";
+    }
+}
+
 int32_t UIExtensionContext::curRequestCode_ = 0;
 std::mutex UIExtensionContext::requestCodeMutex_;
 }  // namespace AbilityRuntime

frameworks/native/appkit/ability_runtime/extension_context.cpp

@@ -35,8 +35,8 @@ std::shared_ptr<AppExecFwk::AbilityInfo> ExtensionContext::GetAbilityInfo() cons
     return abilityInfo_;
 }
 
-ErrCode ExtensionContext::AddCompletionHandler(const std::string &requestId, OnRequestResult onRequestSucc,
-    OnRequestResult onRequestFail)
+ErrCode ExtensionContext::AddCompletionHandlerForAtomicService(const std::string &requestId,
+    OnAtomicRequestSuccess onRequestSucc, OnAtomicRequestFailure onRequestFail, const std::string &appId)
 {
     return ERR_OK;
 }
@@ -47,7 +47,7 @@ void ExtensionContext::OnRequestSuccess(const std::string &requestId, const AppE
 }
 
 void ExtensionContext::OnRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-    const std::string &message)
+    const std::string &message, int32_t resultCode)
 {
 }
 }  // namespace AbilityRuntime

frameworks/native/appkit/ability_runtime/service_extension_context.cpp

@@ -286,69 +286,88 @@ ErrCode ServiceExtensionContext::OpenAtomicService(const AAFwk::Want &want, cons
     return err;
 }
 
-ErrCode ServiceExtensionContext::AddCompletionHandler(const std::string &requestId, OnRequestResult onRequestSucc,
-    OnRequestResult onRequestFail)
+ErrCode ServiceExtensionContext::AddCompletionHandlerForAtomicService(const std::string &requestId,
+    OnAtomicRequestSuccess onRequestSucc, OnAtomicRequestFailure onRequestFail, const std::string &appId)
 {
     if (onRequestSucc == nullptr || onRequestFail == nullptr) {
         TAG_LOGE(AAFwkTag::APPKIT, "either func is null");
         return ERR_INVALID_VALUE;
     }
     std::lock_guard lock(onRequestResultMutex_);
-    for (auto iter = onRequestResults_.begin(); iter != onRequestResults_.end(); iter++) {
+    for (auto iter = onAtomicRequestResults_.begin(); iter != onAtomicRequestResults_.end(); iter++) {
         if ((*iter)->requestId_ == requestId) {
             TAG_LOGI(AAFwkTag::APPKIT, "requestId=%{public}s already exists", requestId.c_str());
             return ERR_OK;
         }
     }
-    onRequestResults_.emplace_back(std::make_shared<OnRequestResultElement>(requestId, onRequestSucc, onRequestFail));
+    onAtomicRequestResults_.emplace_back(std::make_shared<OnAtomicRequestResult>(
+        requestId, appId, onRequestSucc, onRequestFail));
     return ERR_OK;
 }
 
 void ServiceExtensionContext::OnRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element,
     const std::string &message)
 {
-    std::shared_ptr<OnRequestResultElement> result = nullptr;
+    std::shared_ptr<OnAtomicRequestResult> atomicResult = nullptr;
     {
         std::lock_guard lock(onRequestResultMutex_);
-        for (auto iter = onRequestResults_.begin(); iter != onRequestResults_.end(); iter++) {
+        for (auto iter = onAtomicRequestResults_.begin(); iter != onAtomicRequestResults_.end(); iter++) {
             if ((*iter)->requestId_ == requestId) {
-                result = *iter;
-                onRequestResults_.erase(iter);
+                atomicResult = *iter;
+                onAtomicRequestResults_.erase(iter);
                 break;
             }
         }
     }
 
-    if (result != nullptr) {
+    if (atomicResult != nullptr) {
         TAG_LOGI(AAFwkTag::APPKIT, "requestId=%{public}s, call onRequestSuccess", requestId.c_str());
-        result->onRequestSuccess_(element, message);
+        atomicResult->onRequestSuccess_(atomicResult->appId_);
         return;
     }
     TAG_LOGE(AAFwkTag::APPKIT, "requestId=%{public}s not exist", requestId.c_str());
 }
 
 void ServiceExtensionContext::OnRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-    const std::string &message)
+    const std::string &message, int32_t resultCode)
 {
-    std::shared_ptr<OnRequestResultElement> result = nullptr;
+    std::shared_ptr<OnAtomicRequestResult> atomicResult = nullptr;
     {
         std::lock_guard lock(onRequestResultMutex_);
-        for (auto iter = onRequestResults_.begin(); iter != onRequestResults_.end(); iter++) {
+        for (auto iter = onAtomicRequestResults_.begin(); iter != onAtomicRequestResults_.end(); iter++) {
             if ((*iter)->requestId_ == requestId) {
-                result = *iter;
-                onRequestResults_.erase(iter);
+                atomicResult = *iter;
+                onAtomicRequestResults_.erase(iter);
                 break;
             }
         }
     }
 
-    if (result != nullptr) {
+    if (atomicResult != nullptr) {
         TAG_LOGI(AAFwkTag::APPKIT, "requestId=%{public}s, call onRequestFailure", requestId.c_str());
-        result->onRequestFailure_(element, message);
+        int32_t failureCode = 0;
+        std::string failureMessage;
+        GetFailureInfoByMessage(message, failureCode, failureMessage, resultCode);
+        atomicResult->onRequestFailure_(atomicResult->appId_, failureCode, failureMessage);
         return;
     }
 
     TAG_LOGE(AAFwkTag::APPKIT, "requestId=%{public}s not exist", requestId.c_str());
 }
+
+void ServiceExtensionContext::GetFailureInfoByMessage(
+    const std::string &message, int32_t &failureCode, std::string &failureMessage, int32_t resultCode)
+{
+    if (resultCode == USER_CANCEL) {
+        failureCode = static_cast<int32_t>(FailureCode::FAILURE_CODE_USER_CANCEL);
+        failureMessage = "User cancelled redirection";
+    } else if (message.find("User refused redirection") != std::string::npos) {
+        failureCode = static_cast<int32_t>(FailureCode::FAILURE_CODE_USER_REFUSE);
+        failureMessage = "User refused redirection";
+    } else {
+        failureCode = static_cast<int32_t>(FailureCode::FAILURE_CODE_SYSTEM_MALFUNCTION);
+        failureMessage = "failed to open atomicservice";
+    }
+}
 }  // namespace AbilityRuntime
 }  // namespace OHOS

interfaces/inner_api/ability_manager/include/ability_scheduler_interface.h

@@ -307,7 +307,7 @@ public:
     virtual void ScheduleCollaborate(const Want &want) = 0;
 
     virtual void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) = 0;
+        const std::string &message, int32_t resultCode = 0) = 0;
 
     virtual void ScheduleAbilityRequestSuccess(const std::string &requestId,
         const AppExecFwk::ElementName &element) = 0;

interfaces/inner_api/ability_manager/include/start_options.h

@@ -28,7 +28,10 @@ struct WindowCreateParams;
 }
 
 namespace AbilityRuntime {
+constexpr int32_t USER_CANCEL = -7;
 using OnRequestResult = std::function<void(const AppExecFwk::ElementName&, const std::string&)>;
+using OnAtomicRequestSuccess = std::function<void(const std::string&)>;
+using OnAtomicRequestFailure = std::function<void(const std::string&, int32_t, const std::string&)>;
 struct OnRequestResultElement {
     std::string requestId_;
     OnRequestResult onRequestSuccess_;
@@ -39,6 +42,22 @@ struct OnRequestResultElement {
         onRequestFailure_(onRequestFail)
     {}
 };
+struct OnAtomicRequestResult {
+    std::string requestId_;
+    std::string appId_;
+    OnAtomicRequestSuccess onRequestSuccess_;
+    OnAtomicRequestFailure onRequestFailure_;
+
+    OnAtomicRequestResult(const std::string &requestId, std::string appId, OnAtomicRequestSuccess onRequestSucc,
+        OnAtomicRequestFailure onRequestFail) : requestId_(requestId), appId_(appId), onRequestSuccess_(onRequestSucc),
+        onRequestFailure_(onRequestFail)
+    {}
+};
+enum class FailureCode {
+    FAILURE_CODE_SYSTEM_MALFUNCTION = 0,
+    FAILURE_CODE_USER_CANCEL = 1,
+    FAILURE_CODE_USER_REFUSE = 2,
+};
 }
 
 namespace AAFwk {

interfaces/kits/native/ability/ability_runtime/ability_context.h

@@ -486,7 +486,10 @@ public:
      * @param message, the message returned to the callback.
      */
     virtual void OnRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) = 0;
+        const std::string &message, int32_t resultCode = 0) = 0;
+    
+    virtual ErrCode AddCompletionHandlerForAtomicService(const std::string &requestId,
+        OnAtomicRequestSuccess onRequestSucc, OnAtomicRequestFailure onRequestFail, const std::string &appId) = 0;
 
 protected:
     bool IsContext(size_t contextTypeId) override

interfaces/kits/native/ability/ability_runtime/ability_context_impl.h

@@ -362,7 +362,7 @@ public:
      * @param message, the message returned to the callback.
      */
     void OnRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override;
+        const std::string &message, int32_t resultCode = 0) override;
 
     ErrCode StartAppServiceExtensionAbility(const Want &want) override;
     ErrCode StopAppServiceExtensionAbility(const Want& want) override;
@@ -370,6 +370,9 @@ public:
         const sptr<AbilityConnectCallback>& connectCallback) override;
     ErrCode SetOnNewWantSkipScenarios(int32_t scenarios) override;
 
+    ErrCode AddCompletionHandlerForAtomicService(const std::string &requestId, OnAtomicRequestSuccess onRequestSucc,
+        OnAtomicRequestFailure onRequestFail, const std::string &appId) override;
+
 private:
     sptr<IRemoteObject> token_ = nullptr;
     std::shared_ptr<AppExecFwk::AbilityInfo> abilityInfo_ = nullptr;
@@ -397,9 +400,13 @@ private:
     void OnAbilityResultInner(int requestCode, int resultCode, const AAFwk::Want &resultData);
     sptr<IRemoteObject> GetSessionToken();
     void SetWindowRectangleParams(AAFwk::Want &want);
+    void GetFailureInfoByMessage(const std::string &message, int32_t &failureCode,
+        std::string &failureMessage, int32_t resultCode);
 
     std::mutex onRequestResultMutex_;
+    std::mutex onAtomicRequestResultMutex_;
     std::vector<std::shared_ptr<OnRequestResultElement>> onRequestResults_;
+    std::vector<std::shared_ptr<OnAtomicRequestResult>> onAtomicRequestResults_;
 };
 } // namespace AbilityRuntime
 } // namespace OHOS

interfaces/kits/native/ability/native/ability_runtime/js_ability_context.h

@@ -177,6 +177,8 @@ private:
         int32_t &userId, napi_value &lastParam);
     napi_value SyncSetMissionContinueState(napi_env env, NapiCallbackInfo& info, const AAFwk::ContinueState& state);
     static int32_t GenerateRequestCode();
+    void UnWrapCompletionHandlerForAtomicService(
+        napi_env env, napi_value param, AAFwk::StartOptions &options, const std::string &appId);
     static int32_t curRequestCode_;
     static std::mutex requestCodeMutex_;
 

interfaces/kits/native/ability/native/ability_runtime/js_ui_ability.h

@@ -368,7 +368,7 @@ public:
      * @param message, the message to be returned to the calling app.
      */
     void OnAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override;
+        const std::string &message, int32_t resultCode = 0) override;
 
     /**
      * @brief Called when startAbility request succeeded.

interfaces/kits/native/ability/native/ability_thread.h

@@ -360,7 +360,7 @@ public:
     void ScheduleCollaborate(const Want &want) override;
 
     void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override;
+        const std::string &message, int32_t resultCode = 0) override;
 
     void ScheduleAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element) override;
 

interfaces/kits/native/ability/native/extension.h

@@ -262,7 +262,7 @@ public:
     virtual bool OnInsightIntentExecuteDone(uint64_t intentId, const AppExecFwk::InsightIntentExecuteResult &result);
 
     virtual void OnExtensionAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message);
+        const std::string &message, int32_t resultCode = 0);
 
     virtual void OnExtensionAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element,
         const std::string &message);

interfaces/kits/native/ability/native/extension_ability_thread.h

@@ -131,7 +131,7 @@ public:
     void DumpAbilityInfo(const std::vector<std::string> &params, std::vector<std::string> &info) override;
 
     void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override;
+        const std::string &message, int32_t resultCode = 0) override;
 
     void ScheduleAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element) override;
 

interfaces/kits/native/ability/native/extension_base.h

@@ -91,7 +91,7 @@ public:
     void SetExtensionCommon(const std::shared_ptr<ExtensionCommon> &common);
 
     void OnExtensionAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override;
+        const std::string &message, int32_t resultCode = 0) override;
 
     void OnExtensionAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element,
         const std::string &message) override;

interfaces/kits/native/ability/native/extension_base.inl

@@ -122,15 +122,15 @@ void ExtensionBase<C>::SetExtensionCommon(const std::shared_ptr<ExtensionCommon>
 }
 
 template<class C>
-void ExtensionBase<C>::OnExtensionAbilityRequestFailure(
-    const std::string &requestId, const AppExecFwk::ElementName &element, const std::string &message)
+void ExtensionBase<C>::OnExtensionAbilityRequestFailure(const std::string &requestId,
+    const AppExecFwk::ElementName &element, const std::string &message, int32_t resultCode)
 {
     TAG_LOGD(AAFwkTag::EXT, "OnAbilityRequestFailure called");
     if (context_ == nullptr) {
         TAG_LOGE(AAFwkTag::EXT, "null context_");
         return;
     }
-    context_->OnRequestFailure(requestId, element, message);
+    context_->OnRequestFailure(requestId, element, message, resultCode);
 }
 
 template<class C>

interfaces/kits/native/ability/native/extension_impl.h

@@ -161,7 +161,7 @@ public:
     void SetLaunchParam(const AAFwk::LaunchParam &launchParam);
 
     void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message);
+        const std::string &message, int32_t resultCode = 0);
 
     void ScheduleAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element);
 

interfaces/kits/native/ability/native/ui_ability.h

@@ -633,7 +633,7 @@ public:
      * @param message, the message to be returned to the calling app.
      */
     virtual void OnAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message);
+        const std::string &message, int32_t resultCode = 0);
 
     /**
      * @brief Called when startAbility request succeeded.

interfaces/kits/native/ability/native/ui_ability_impl.h

@@ -177,7 +177,7 @@ public:
     void ScheduleCollaborate(const Want &want);
 
     void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message);
+        const std::string &message, int32_t resultCode = 0);
 
     void ScheduleAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element);
 

interfaces/kits/native/ability/native/ui_ability_thread.h

@@ -155,7 +155,7 @@ public:
     void ScheduleCollaborate(const Want &want) override;
 
     void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override;
+        const std::string &message, int32_t resultCode = 0) override;
 
     void ScheduleAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element) override;
 

interfaces/kits/native/ability/native/ui_extension_base/js_ui_extension_context.h

@@ -101,7 +101,8 @@ private:
     napi_value OnOpenLink(napi_env env, NapiCallbackInfo& info);
     napi_value OnOpenLinkInner(napi_env env, const AAFwk::Want& want,
         int requestCode, const std::string& startTime, const std::string& url);
-    void UnwrapCompletionHandlerInStartOptions(napi_env env, napi_value param, AAFwk::StartOptions &options);
+    void UnWrapCompletionHandlerForAtomicService(
+        napi_env env, napi_value param, AAFwk::StartOptions &options, const std::string &appId);
 #ifdef SUPPORT_SCREEN
     void InitDisplayId(AAFwk::Want &want);
     void InitDisplayId(AAFwk::Want &want, AAFwk::StartOptions &startOptions, napi_env &env, NapiCallbackInfo& info);

interfaces/kits/native/ability/native/ui_extension_base/ui_extension_context.h

@@ -187,14 +187,14 @@ public:
 
     void RemoveResultCallbackTask(int requestCode);
 
-    ErrCode AddCompletionHandler(const std::string &requestId, OnRequestResult onRequestSucc,
-        OnRequestResult onRequestFail) override;
+    ErrCode AddCompletionHandlerForAtomicService(const std::string &requestId, OnAtomicRequestSuccess onRequestSucc,
+        OnAtomicRequestFailure onRequestFail, const std::string &appId) override;
 
     void OnRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element,
         const std::string &message) override;
 
     void OnRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override;
+        const std::string &message, int32_t resultCode = 0) override;
 
     /**
      * @brief Start a new ability using type;
@@ -238,9 +238,12 @@ private:
     OHOS::AppExecFwk::AbilityType GetAbilityInfoType() const;
 
     void OnAbilityResultInner(int requestCode, int resultCode, const AAFwk::Want &resultData);
+
+    void GetFailureInfoByMessage(const std::string &message, int32_t &failureCode,
+        std::string &failureMessage, int32_t resultCode);
     
     std::mutex onRequestResultMutex_;
-    std::vector<OnRequestResultElement> onRequestResults_;
+    std::vector<std::shared_ptr<OnAtomicRequestResult>> onAtomicRequestResults_;
 };
 }  // namespace AbilityRuntime
 }  // namespace OHOS

interfaces/kits/native/appkit/ability_runtime/extension_context.h

@@ -53,8 +53,8 @@ public:
      * @param onRequestFail, the callback ot be called upon request failure.
      * @return ERR_OK on success, otherwise failure.
      */
-    virtual ErrCode AddCompletionHandler(const std::string &requestId, OnRequestResult onRequestSucc,
-        OnRequestResult onRequestFail);
+    virtual ErrCode AddCompletionHandlerForAtomicService(const std::string &requestId,
+        OnAtomicRequestSuccess onRequestSucc, OnAtomicRequestFailure onRequestFail, const std::string &appId);
 
     /**
      * @brief Callback on request success.
@@ -74,7 +74,7 @@ public:
      * @param message, the message returned to the callback.
      */
     virtual void OnRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message);
+        const std::string &message, int32_t resultCode = 0);
 
     using SelfType = ExtensionContext;
     static const size_t CONTEXT_TYPE_ID;

interfaces/kits/native/appkit/ability_runtime/service_extension_context.h

@@ -174,14 +174,14 @@ public:
     ErrCode OpenLink(const AAFwk::Want& want, int reuqestCode);
     ErrCode OpenAtomicService(const AAFwk::Want &want, const AAFwk::StartOptions &options);
 
-    ErrCode AddCompletionHandler(const std::string &requestId, OnRequestResult onRequestSucc,
-        OnRequestResult onRequestFail) override;
+    ErrCode AddCompletionHandlerForAtomicService(const std::string &requestId, OnAtomicRequestSuccess onRequestSucc,
+        OnAtomicRequestFailure onRequestFail, const std::string &appId) override;
     
     void OnRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element,
         const std::string &message) override;
 
     void OnRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override;
+        const std::string &message, int32_t resultCode = 0) override;
 
 protected:
     bool IsContext(size_t contextTypeId) override
@@ -200,8 +200,11 @@ private:
      */
     OHOS::AppExecFwk::AbilityType GetAbilityInfoType() const;
 
+    void GetFailureInfoByMessage(const std::string &message, int32_t &failureCode,
+        std::string &failureMessage, int32_t resultCode);
+
     std::mutex onRequestResultMutex_;
-    std::vector<std::shared_ptr<OnRequestResultElement>> onRequestResults_;
+    std::vector<std::shared_ptr<OnAtomicRequestResult>> onAtomicRequestResults_;
 };
 }  // namespace AbilityRuntime
 }  // namespace OHOS

services/abilitymgr/include/ability_record.h

@@ -1179,7 +1179,7 @@ public:
     }
 
     void NotifyAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message);
+        const std::string &message, int32_t resultCode = 0);
 
     void NotifyAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element);
     void NotifyAbilitiesRequestDone(const std::string &requestKey, int32_t resultCode);

services/abilitymgr/include/ability_scheduler_proxy.h

@@ -334,7 +334,7 @@ public:
     void ScheduleCollaborate(const Want &want) override;
 
     void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override;
+        const std::string &message, int32_t resultCode = 0) override;
 
     void ScheduleAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element) override;
 

services/abilitymgr/include/dialog_session/dialog_session_manager.h

@@ -132,8 +132,6 @@ private:
 
     void NotifyAbilityRequestFailure(const std::string &dialogSessionId, const Want &want);
 
-    AppExecFwk::ElementName GetWantElement(const Want &want);
-
     mutable ffrt::mutex dialogSessionRecordLock_;
     std::unordered_map<std::string, sptr<DialogSessionInfo>> dialogSessionInfoMap_;
     std::unordered_map<std::string, std::shared_ptr<DialogCallerInfo>> dialogCallerInfoMap_;

services/abilitymgr/include/lifecycle_deal.h

@@ -87,7 +87,7 @@ public:
     void UpdateSessionToken(sptr<IRemoteObject> sessionToken);
     void ScheduleCollaborate(const Want &want);
     void NotifyAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message);
+        const std::string &message, int32_t resultCode = 0);
     void NotifyAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element);
     void NotifyAbilitiesRequestDone(const std::string &requestKey, int32_t resultCode);
 

services/abilitymgr/include/scene_board/ui_ability_lifecycle_manager.h

@@ -460,7 +460,6 @@ private:
 
     void SetLastExitReason(std::shared_ptr<AbilityRecord> &abilityRecord) const;
     void SetReceiverInfo(const AbilityRequest &abilityRequest, std::shared_ptr<AbilityRecord> &abilityRecord) const;
-    AppExecFwk::ElementName GetWantElement(sptr<SessionInfo> &sessionInfo, const AbilityRequest &abilityRequest);
 
     /**
      * @brief Execute PrepareTerminateApp when it is implemented

services/abilitymgr/src/ability_record.cpp

@@ -3881,13 +3881,13 @@ void AbilityRecord::ScheduleCollaborate(const Want &want)
 }
 
 void AbilityRecord::NotifyAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-    const std::string &message)
+    const std::string &message, int32_t resultCode)
 {
     CHECK_POINTER(lifecycleDeal_);
     nlohmann::json jsonObject = nlohmann::json {
         { JSON_KEY_ERR_MSG, message },
     };
-    lifecycleDeal_->NotifyAbilityRequestFailure(requestId, element, jsonObject.dump());
+    lifecycleDeal_->NotifyAbilityRequestFailure(requestId, element, jsonObject.dump(), resultCode);
 }
 
 void AbilityRecord::NotifyAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element)

services/abilitymgr/src/ability_scheduler_proxy.cpp

@@ -1232,7 +1232,7 @@ void AbilitySchedulerProxy::ScheduleCollaborate(const Want &want)
 }
 
 void AbilitySchedulerProxy::ScheduleAbilityRequestFailure(const std::string &requestId,
-    const AppExecFwk::ElementName &element, const std::string &message)
+    const AppExecFwk::ElementName &element, const std::string &message, int32_t resultCode)
 {
     MessageParcel data;
     MessageParcel reply;
@@ -1258,6 +1258,11 @@ void AbilitySchedulerProxy::ScheduleAbilityRequestFailure(const std::string &req
         AbilityRuntime::ErrorMgsUtil::GetInstance().UpdateErrorMsg(msgKey, "write message failed");
         return;
     }
+    if (!data.WriteInt32(resultCode)) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "write resultCode failed");
+        AbilityRuntime::ErrorMgsUtil::GetInstance().UpdateErrorMsg(msgKey, "write resultCode failed");
+        return;
+    }
     int32_t err = SendTransactCmd(IAbilityScheduler::SCHEDULE_ABILITY_REQUEST_FAILURE, data, reply, option);
     if (err != NO_ERROR) {
         TAG_LOGE(AAFwkTag::ABILITYMGR, "fail, err: %{public}d", err);

services/abilitymgr/src/ability_scheduler_stub.cpp

@@ -766,7 +766,8 @@ int AbilitySchedulerStub::ScheduleAbilityRequestFailureInner(MessageParcel &data
         return ERR_INVALID_VALUE;
     }
     std::string message = data.ReadString();
-    ScheduleAbilityRequestFailure(requestId, *element, message);
+    int32_t resultCode = data.ReadInt32();
+    ScheduleAbilityRequestFailure(requestId, *element, message, resultCode);
     return NO_ERROR;
 }
 

services/abilitymgr/src/dialog_session/dialog_session_manager.cpp

@@ -234,28 +234,6 @@ void DialogSessionManager::GenerateDialogCallerInfo(AbilityRequest &abilityReque
     dialogCallerInfo->needGrantUriPermission = needGrantUriPermission;
 }
 
-AppExecFwk::ElementName DialogSessionManager::GetWantElement(const Want &want)
-{
-    auto bms = AbilityUtil::GetBundleManagerHelper();
-    auto abilityMgr = DelayedSingleton<AbilityManagerService>::GetInstance();
-    if (bms == nullptr || abilityMgr == nullptr) {
-        return want.GetElement();
-    }
-    AppExecFwk::BundleInfo bundleInfo;
-    if (!IN_PROCESS_CALL(bms->GetBundleInfo(want.GetBundle(),
-        static_cast<int32_t>(AppExecFwk::GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION),
-        bundleInfo, abilityMgr->GetUserId()))) {
-        TAG_LOGE(AAFwkTag::ABILITYMGR, "GetBundleInfo failed");
-        return want.GetElement();
-    }
-    if (bundleInfo.applicationInfo.bundleType == AppExecFwk::BundleType::ATOMIC_SERVICE) {
-        AppExecFwk::ElementName element;
-        element.SetBundleName(want.GetElement().GetBundleName());
-        return element;
-    }
-    return want.GetElement();
-}
-
 void DialogSessionManager::NotifyAbilityRequestFailure(const std::string &dialogSessionId, const Want &want)
 {
     auto callerInfo = GetDialogCallerInfo(dialogSessionId);
@@ -276,7 +254,7 @@ void DialogSessionManager::NotifyAbilityRequestFailure(const std::string &dialog
     } else if (callerInfo->type == SelectorType::INTERCEPTOR_SELECTOR) {
         message = "User closed the interceptor picker";
     }
-    abilityRecord->NotifyAbilityRequestFailure(requestId, GetWantElement(want), message);
+    abilityRecord->NotifyAbilityRequestFailure(requestId, want.GetElement(), message);
 }
 
 int DialogSessionManager::SendDialogResult(const Want &want, const std::string &dialogSessionId, bool isAllowed)

services/abilitymgr/src/free_install_manager.cpp

@@ -345,7 +345,7 @@ void FreeInstallManager::HandleOnFreeInstallFail(int32_t recordId, FreeInstallIn
             return;
         }
         abilityRecord->NotifyAbilityRequestFailure(freeInstallInfo.startOptions->requestId_,
-            freeInstallInfo.want.GetElement(), "Free installation failed");
+            freeInstallInfo.want.GetElement(), "Free installation failed", resultCode);
     }
 
     if (isAsync) {

services/abilitymgr/src/lifecycle_deal.cpp

@@ -202,11 +202,11 @@ void LifecycleDeal::ScheduleCollaborate(const Want &want)
 }
 
 void LifecycleDeal::NotifyAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-    const std::string &message)
+    const std::string &message, int32_t resultCode)
 {
     auto abilityScheduler = GetScheduler();
     CHECK_POINTER(abilityScheduler);
-    abilityScheduler->ScheduleAbilityRequestFailure(requestId, element, message);
+    abilityScheduler->ScheduleAbilityRequestFailure(requestId, element, message, resultCode);
 }
 
 void LifecycleDeal::NotifyAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element)

services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp

@@ -1529,17 +1529,6 @@ sptr<SessionInfo> UIAbilityLifecycleManager::CreateSessionInfo(const AbilityRequ
     return sessionInfo;
 }
 
-AppExecFwk::ElementName UIAbilityLifecycleManager::GetWantElement(
-    sptr<SessionInfo> &sessionInfo, const AbilityRequest &abilityRequest)
-{
-    if (sessionInfo != nullptr && sessionInfo->isAtomicService) {
-        AppExecFwk::ElementName element;
-        element.SetBundleName(abilityRequest.want.GetElement().GetBundleName());
-        return element;
-    }
-    return abilityRequest.want.GetElement();
-}
-
 int UIAbilityLifecycleManager::NotifySCBPendingActivation(sptr<SessionInfo> &sessionInfo,
     const AbilityRequest &abilityRequest, std::string &errMsg)
 {
@@ -1574,7 +1563,7 @@ int UIAbilityLifecycleManager::NotifySCBPendingActivation(sptr<SessionInfo> &ses
         CheckCallerFromBackground(abilityRecord, sessionInfo);
         auto requestId = abilityRequest.want.GetStringParam(KEY_REQUEST_ID);
         if (!requestId.empty()) {
-            abilityRecord->NotifyAbilityRequestSuccess(requestId, GetWantElement(sessionInfo, abilityRequest));
+            abilityRecord->NotifyAbilityRequestSuccess(requestId, abilityRequest.want.GetElement());
         }
         const_cast<AbilityRequest &>(abilityRequest).want.RemoveParam(KEY_REQUEST_ID);
         TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, NotifySCBPendingActivation for callerSession, target: %{public}s"
@@ -1592,7 +1581,7 @@ int UIAbilityLifecycleManager::NotifySCBPendingActivation(sptr<SessionInfo> &ses
         auto requestId = abilityRequest.want.GetStringParam(KEY_REQUEST_ID);
         if (!requestId.empty()) {
             TAG_LOGI(AAFwkTag::ABILITYMGR, "notify request success, requestId:%{public}s", requestId.c_str());
-            abilityRecord->NotifyAbilityRequestSuccess(requestId, GetWantElement(sessionInfo, abilityRequest));
+            abilityRecord->NotifyAbilityRequestSuccess(requestId, abilityRequest.want.GetElement());
         }
         const_cast<AbilityRequest &>(abilityRequest).want.RemoveParam(KEY_REQUEST_ID);
     }

test/fuzztest/attachabilitythread_fuzzer/attachabilitythread_fuzzer.cpp

@@ -159,7 +159,7 @@ public:
     {}
 
     void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override
+        const std::string &message, int32_t resultCode = 0) override
     {}
 
     void ScheduleAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element) override

test/fuzztest/dataabilityrecordfirst_fuzzer/dataabilityrecordfirst_fuzzer.cpp

@@ -159,7 +159,7 @@ public:
     {}
 
     void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override
+        const std::string &message, int32_t resultCode) override
     {}
 
     void ScheduleAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element) override

test/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_client.h

@@ -155,7 +155,7 @@ public:
     virtual void ScheduleCollaborate(const Want &want) {}
 
     virtual void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message)
+        const std::string &message, int32_t resultCode)
     {}
 
     virtual void ScheduleAbilityRequestSuccess(const std::string &requestId, const AppExecFwk::ElementName &element)

test/mock/frameworks_kits_ability_native_test/include/mock_ability_scheduler_for_observer.h

@@ -83,7 +83,7 @@ public:
     virtual void ScheduleCollaborate(const Want &want) override {}
 
     virtual void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override
+        const std::string &message, int32_t resultCode) override
     {}
 
     virtual void ScheduleAbilityRequestSuccess(const std::string &requestId,

test/mock/services_abilitymgr_test/libs/aakit/include/ability_scheduler.h

@@ -119,7 +119,7 @@ public:
     virtual void ScheduleCollaborate(const Want &want) override {}
 
     virtual void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override
+        const std::string &message, int32_t resultCode) override
     {}
 
     virtual void ScheduleAbilityRequestSuccess(const std::string &requestId,

test/mock/services_abilitymgr_test/libs/ability_scheduler_mock/ability_scheduler_mock.h

@@ -177,7 +177,7 @@ public:
     }
 
     virtual void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override
+        const std::string &message, int32_t resultCode) override
     {}
 
     virtual void ScheduleAbilityRequestSuccess(const std::string &requestId,

test/moduletest/mock/include/mock_ability_scheduler.h

@@ -133,7 +133,7 @@ public:
     virtual void ScheduleCollaborate(const Want &want) override {}
 
     virtual void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override
+        const std::string &message, int32_t resultCode) override
     {}
 
     virtual void ScheduleAbilityRequestSuccess(const std::string &requestId,

test/moduletest/mock/include/mock_ability_scheduler_stub.h

@@ -73,7 +73,7 @@ public:
     virtual void ScheduleCollaborate(const Want &want) override {}
 
     virtual void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override
+        const std::string &message, int32_t resultCode) override
     {}
 
     virtual void ScheduleAbilityRequestSuccess(const std::string &requestId,

test/unittest/ability_extension_base_test/ability_extension_base_test.cpp

@@ -262,7 +262,7 @@ HWTEST_F(AbilityExtensionBaseTest, OnExtensionAbilityRequestFailure_0100, TestSi
     class TestExtensionBase : public ExtensionBase<ExtensionContext> {
     public:
         void OnExtensionAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-            const std::string &message) override
+            const std::string &message, int32_t resultCode = 0) override
         {
             lastRequestId_ = requestId;
             lastElement_ = element;

test/unittest/ability_manager_service_thirteenth_test/mock/src/mock_ability_record.cpp

@@ -2006,7 +2006,7 @@ void AbilityRecord::ScheduleCollaborate(const Want &want)
 }
 
 void AbilityRecord::NotifyAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-    const std::string &message)
+    const std::string &message, int32_t resultCode)
 {
 }
 

test/unittest/ability_scheduler_stub_second_test/ability_schedule_stub_second_mock.h

@@ -167,7 +167,7 @@ public:
     virtual void ScheduleCollaborate(const Want &want) override {}
 
     virtual void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override
+        const std::string &message, int32_t resultCode = 0) override
     {}
 
     virtual void ScheduleAbilityRequestSuccess(const std::string &requestId,

test/unittest/ability_scheduler_stub_test/ability_schedule_stub_mock.h

@@ -164,7 +164,7 @@ public:
     virtual void ScheduleCollaborate(const Want &want) override {}
 
     virtual void ScheduleAbilityRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message) override
+        const std::string &message, int32_t resultCode = 0) override
     {}
 
     virtual void ScheduleAbilityRequestSuccess(const std::string &requestId,

test/unittest/dialog_session_manager_test/dialog_session_manager_test.cpp

@@ -872,22 +872,5 @@ HWTEST_F(DialogSessionManagerTest, HandleErmsResultBySCB_001, TestSize.Level1)
     EXPECT_NE(result, ERR_INVALID_VALUE);
     GTEST_LOG_(INFO) << "HandleErmsResultBySCB_001 end";
 }
-
-/**
- * @tc.name: GetWantElement_001
- * @tc.desc: test GetWantElement function
- * @tc.type: FUNC
- */
-HWTEST_F(DialogSessionManagerTest, GetWantElement_001, TestSize.Level1)
-{
-    GTEST_LOG_(INFO) << "GetWantElement_001 start";
-    DialogSessionManager dialogSessionManager;
-    Want want;
-    AppExecFwk::ElementName element("", "com.test.demo", "MainAbility");
-    want.SetElement(element);
-    AppExecFwk::ElementName result = dialogSessionManager.GetWantElement(want);
-    EXPECT_EQ(result.GetAbilityName(), "MainAbility");
-    GTEST_LOG_(INFO) << "GetWantElement_001 end";
-}
 }  // namespace AAFwk
 }  // namespace OHOS

test/unittest/frameworks_kits_ability_ability_runtime_test/ability_context_impl_test.cpp

@@ -49,6 +49,7 @@ const std::string FLAG_AUTH_READ_URI_PERMISSION = "ability.want.params.uriPermis
 const int DISPLAY_ID = 1001;
 const int32_t COLOR_MODE1 = -2;
 const int32_t COLOR_MODE2 = 2;
+const int32_t USER_CANCEL = -7;
 }
 
 class MyAbilityCallback : public IAbilityCallback {
@@ -2395,5 +2396,144 @@ HWTEST_F(AbilityContextImplTest, ConnectAppServiceExtensionAbility_0200, Functio
     bool ret = context_->ConnectAppServiceExtensionAbility(want, connectCallback);
     EXPECT_NE(ret, ERR_OK);
 }
+
+/**
+ * @tc.number: AddCompletionHandlerForAtomicService_0100
+ * @tc.name: AddCompletionHandlerForAtomicService
+ * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
+ */
+HWTEST_F(AbilityContextImplTest, AddCompletionHandlerForAtomicService_100, Function | MediumTest | Level1)
+{
+    std::string requestId = "1234567890";
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = nullptr;
+    OnAtomicRequestFailure onRequestFail = nullptr;
+    auto result = context_->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
+    EXPECT_EQ(result, ERR_INVALID_VALUE);
+    EXPECT_EQ(context_->onAtomicRequestResults_.empty(), true);
+}
+
+/**
+ * @tc.number: AddCompletionHandlerForAtomicService_0200
+ * @tc.name: AddCompletionHandlerForAtomicService
+ * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
+ */
+HWTEST_F(AbilityContextImplTest, AddCompletionHandlerForAtomicService_0200, Function | MediumTest | Level1)
+{
+    std::string requestId = "1234567890";
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = nullptr;
+    auto result = context_->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
+    EXPECT_EQ(result, ERR_INVALID_VALUE);
+    EXPECT_EQ(context_->onAtomicRequestResults_.empty(), true);
+}
+
+/**
+ * @tc.number: AddCompletionHandlerForAtomicService_0300
+ * @tc.name: AddCompletionHandlerForAtomicService
+ * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
+ */
+HWTEST_F(AbilityContextImplTest, AddCompletionHandlerForAtomicService_0300, Function | MediumTest | Level1)
+{
+    std::string requestId = "1234567890";
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
+    auto result = context_->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
+    EXPECT_EQ(result, ERR_OK);
+    EXPECT_EQ(context_->onAtomicRequestResults_.empty(), false);
+    context_->onAtomicRequestResults_.clear();
+}
+
+/**
+ * @tc.number: AddCompletionHandler_0400
+ * @tc.name: AddCompletionHandlerForAtomicService
+ * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
+ */
+HWTEST_F(AbilityContextImplTest, AddCompletionHandler_0400, Function | MediumTest | Level1)
+{
+    std::string requestId = "1234567890";
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
+    context_->onAtomicRequestResults_.emplace_back(
+        std::make_shared<OnAtomicRequestResult>(requestId, appId, onRequestSucc, onRequestFail));
+    auto result = context_->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
+    EXPECT_EQ(result, ERR_OK);
+    std::string norequestId = "test";
+    result = context_->AddCompletionHandlerForAtomicService(norequestId, onRequestSucc, onRequestFail, appId);
+    EXPECT_EQ(context_->onAtomicRequestResults_.size(), 2);
+    context_->onAtomicRequestResults_.clear();
+}
+
+/**
+ * @tc.number: OnRequestSuccess_0300
+ * @tc.name: OnRequestSuccess
+ * @tc.desc: Verify that function OnRequestSuccess.
+ */
+HWTEST_F(AbilityContextImplTest, OnRequestSuccess_0300, Function | MediumTest | Level1)
+{
+    std::string requestId = "1234567890";
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
+    auto result = context_->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
+    EXPECT_EQ(result, ERR_OK);
+    EXPECT_EQ(context_->onAtomicRequestResults_.empty(), false);
+    AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
+    std::string norequestId = "test";
+    context_->OnRequestSuccess(norequestId, element, "success");
+    EXPECT_EQ(context_->onAtomicRequestResults_.empty(), false);
+    context_->OnRequestSuccess(requestId, element, "success");
+    EXPECT_EQ(context_->onAtomicRequestResults_.empty(), true);
+}
+
+/**
+ * @tc.number: OnRequestFailure_0300
+ * @tc.name: OnRequestFailure
+ * @tc.desc: Verify that function OnRequestFailure.
+ */
+HWTEST_F(AbilityContextImplTest, OnRequestFailure_0300, Function | MediumTest | Level1)
+{
+    std::string requestId = "1234567890";
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
+    auto result = context_->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
+    EXPECT_EQ(result, ERR_OK);
+    EXPECT_EQ(context_->onAtomicRequestResults_.empty(), false);
+    AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
+    std::string norequestId = "test";
+    context_->OnRequestFailure(norequestId, element, "failure");
+    EXPECT_EQ(context_->onAtomicRequestResults_.empty(), false);
+    context_->OnRequestFailure(requestId, element, "failure");
+    EXPECT_EQ(context_->onAtomicRequestResults_.empty(), true);
+    context_->onAtomicRequestResults_.clear();
+}
+
+/**
+ * @tc.number: GetFailureInfoByMessage_0100
+ * @tc.name: GetFailureInfoByMessage
+ * @tc.desc: Verify that function GetFailureInfoByMessage.
+ */
+HWTEST_F(AbilityContextImplTest, GetFailureInfoByMessage_0100, Function | MediumTest | Level1)
+{
+    std::string message = "User refused redirection";
+    int32_t faileCode = 0;
+    std::string failReason;
+    int32_t resultCode = USER_CANCEL;
+    context_->GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
+    EXPECT_EQ(faileCode, 1);
+    EXPECT_EQ(failReason, "User cancelled redirection");
+    resultCode = 0;
+    context_->GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
+    EXPECT_EQ(faileCode, 2);
+    EXPECT_EQ(failReason, "User refused redirection");
+    message = "test";
+    context_->GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
+    EXPECT_EQ(faileCode, 0);
+    EXPECT_EQ(failReason, "failed to open atomicservice");
+}
 } // namespace AppExecFwk
 } // namespace OHOS

test/unittest/frameworks_kits_ability_ability_runtime_test/ability_context_test.cpp

@@ -504,6 +504,11 @@ public:
     {
         return;
     }
+    virtual ErrCode AddCompletionHandlerForAtomicService(const std::string &requestId,
+        OnAtomicRequestSuccess onRequestSucc, OnAtomicRequestFailure onRequestFail, const std::string &appId)
+    {
+        return ERR_OK;
+    }
 
     /**
      * @brief Add CompletioHandler.
@@ -540,7 +545,7 @@ public:
      * @param message, the message returned to the callback.
      */
     virtual void OnRequestFailure(const std::string &requestId, const AppExecFwk::ElementName &element,
-        const std::string &message)
+        const std::string &message, int32_t resultCode)
     {
         return;
     }

test/unittest/service_extension_context_test/service_extension_context_test.cpp

@@ -571,75 +571,84 @@ HWTEST_F(ServiceExtensionContextTest, service_extension_context_OpenAtomicServic
 }
 
 /**
- * @tc.number: AddCompletionHandler_0100
- * @tc.name: AddCompletionHandler
- * @tc.desc: Verify that function AddCompletionHandler.
+ * @tc.number: AddCompletionHandlerForAtomicService_0100
+ * @tc.name: AddCompletionHandlerForAtomicService
+ * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
  */
-HWTEST_F(ServiceExtensionContextTest, AddCompletionHandler_100, Function | MediumTest | Level1)
+HWTEST_F(ServiceExtensionContextTest, AddCompletionHandlerForAtomicService_100, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = nullptr;
-    OnRequestResult onRequestFail = nullptr;
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = nullptr;
+    OnAtomicRequestFailure onRequestFail = nullptr;
     ServiceExtensionContext serviceExtensionContextTest;
-    auto result = serviceExtensionContextTest.AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    auto result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
+        requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_INVALID_VALUE);
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), true);
+    EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
 }
 
 /**
- * @tc.number: AddCompletionHandler_0200
- * @tc.name: AddCompletionHandler
- * @tc.desc: Verify that function AddCompletionHandler.
+ * @tc.number: AddCompletionHandlerForAtomicService_0200
+ * @tc.name: AddCompletionHandlerForAtomicService
+ * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
  */
-HWTEST_F(ServiceExtensionContextTest, AddCompletionHandler_0200, Function | MediumTest | Level1)
+HWTEST_F(ServiceExtensionContextTest, AddCompletionHandlerForAtomicService_0200, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = [](const AppExecFwk::ElementName&, const std::string&) {};
-    OnRequestResult onRequestFail = nullptr;
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = nullptr;
     ServiceExtensionContext serviceExtensionContextTest;
-    auto result = serviceExtensionContextTest.AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    auto result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
+        requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_INVALID_VALUE);
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), true);
+    EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
 }
 
 /**
- * @tc.number: AddCompletionHandler_0300
- * @tc.name: AddCompletionHandler
- * @tc.desc: Verify that function AddCompletionHandler.
+ * @tc.number: AddCompletionHandlerForAtomicService_0300
+ * @tc.name: AddCompletionHandlerForAtomicService
+ * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
  */
-HWTEST_F(ServiceExtensionContextTest, AddCompletionHandler_0300, Function | MediumTest | Level1)
+HWTEST_F(ServiceExtensionContextTest, AddCompletionHandlerForAtomicService_0300, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = [](const AppExecFwk::ElementName&, const std::string&) {};
-    OnRequestResult onRequestFail = [](const AppExecFwk::ElementName&, const std::string&) {};
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
     ServiceExtensionContext serviceExtensionContextTest;
-    auto result = serviceExtensionContextTest.AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    auto result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
+        requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_OK);
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), false);
-    serviceExtensionContextTest.onRequestResults_.clear();
+    EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), false);
+    serviceExtensionContextTest.onAtomicRequestResults_.clear();
 }
 
 /**
- * @tc.number: AddCompletionHandler_0400
- * @tc.name: AddCompletionHandler
- * @tc.desc: Verify that function AddCompletionHandler.
+ * @tc.number: AddCompletionHandlerForAtomicService_0400
+ * @tc.name: AddCompletionHandlerForAtomicService
+ * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
  */
-HWTEST_F(ServiceExtensionContextTest, AddCompletionHandler_0400, Function | MediumTest | Level1)
+HWTEST_F(ServiceExtensionContextTest, AddCompletionHandlerForAtomicService_0400, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = [](const AppExecFwk::ElementName&, const std::string&) {};
-    OnRequestResult onRequestFail = [](const AppExecFwk::ElementName&, const std::string&) {};
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
     ServiceExtensionContext serviceExtensionContextTest;
     std::string norequestId = "test";
-    serviceExtensionContextTest.onRequestResults_.clear();
-    serviceExtensionContextTest.onRequestResults_.emplace_back(
-        std::make_shared<OnRequestResultElement>(requestId, onRequestSucc, onRequestFail));
-    auto result = serviceExtensionContextTest.AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    serviceExtensionContextTest.onAtomicRequestResults_.clear();
+    serviceExtensionContextTest.onAtomicRequestResults_.emplace_back(
+        std::make_shared<OnAtomicRequestResult>(requestId, appId, onRequestSucc, onRequestFail));
+    auto result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
+        requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_OK);
-    result = serviceExtensionContextTest.AddCompletionHandler(norequestId, onRequestSucc, onRequestFail);
+    result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
+        norequestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_OK);
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.size(), 2);
-    serviceExtensionContextTest.onRequestResults_.clear();
+    EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.size(), 2);
+    serviceExtensionContextTest.onAtomicRequestResults_.clear();
 }
 
 /**
@@ -650,15 +659,17 @@ HWTEST_F(ServiceExtensionContextTest, AddCompletionHandler_0400, Function | Medi
 HWTEST_F(ServiceExtensionContextTest, OnRequestSuccess_0100, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = [](const AppExecFwk::ElementName&, const std::string&) {};
-    OnRequestResult onRequestFail = [](const AppExecFwk::ElementName&, const std::string&) {};
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
     ServiceExtensionContext serviceExtensionContextTest;
-    auto result = serviceExtensionContextTest.AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    auto result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
+        requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_OK);
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), false);
+    EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), false);
     AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
     serviceExtensionContextTest.OnRequestSuccess(requestId, element, "success");
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), true);
+    EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
 }
 
 /**
@@ -670,10 +681,10 @@ HWTEST_F(ServiceExtensionContextTest, OnRequestSuccess_0200, Function | MediumTe
 {
     std::string requestId = "1234567890";
     ServiceExtensionContext serviceExtensionContextTest;
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), true);
+    EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
     AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
     serviceExtensionContextTest.OnRequestSuccess(requestId, element, "success");
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), true);
+    EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
 }
 
 /**
@@ -684,17 +695,19 @@ HWTEST_F(ServiceExtensionContextTest, OnRequestSuccess_0200, Function | MediumTe
 HWTEST_F(ServiceExtensionContextTest, OnRequestSuccess_0300, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = [](const AppExecFwk::ElementName&, const std::string&) {};
-    OnRequestResult onRequestFail = [](const AppExecFwk::ElementName&, const std::string&) {};
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
     ServiceExtensionContext serviceExtensionContextTest;
-    auto result = serviceExtensionContextTest.AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    auto result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
+        requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_OK);
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), false);
+    EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), false);
     AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
     std::string norequestId = "test";
     serviceExtensionContextTest.OnRequestSuccess(norequestId, element, "success");
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), false);
-    serviceExtensionContextTest.onRequestResults_.clear();
+    EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), false);
+    serviceExtensionContextTest.onAtomicRequestResults_.clear();
 }
 
 /**
@@ -705,16 +718,18 @@ HWTEST_F(ServiceExtensionContextTest, OnRequestSuccess_0300, Function | MediumTe
 HWTEST_F(ServiceExtensionContextTest, OnRequestFailure_0100, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = [](const AppExecFwk::ElementName&, const std::string&) {};
-    OnRequestResult onRequestFail = [](const AppExecFwk::ElementName&, const std::string&) {};
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
     ServiceExtensionContext serviceExtensionContextTest;
-    auto result = serviceExtensionContextTest.AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    auto result = serviceExtensionContextTest.AddCompletionHandlerForAtomicService(
+        requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_OK);
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), false);
+    EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), false);
     AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
     serviceExtensionContextTest.OnRequestFailure(requestId, element, "failure");
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), true);
-    serviceExtensionContextTest.onRequestResults_.clear();
+    EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
+    serviceExtensionContextTest.onAtomicRequestResults_.clear();
 }
 
 /**
@@ -726,10 +741,10 @@ HWTEST_F(ServiceExtensionContextTest, OnRequestFailure_0200, Function | MediumTe
 {
     std::string requestId = "1234567890";
     ServiceExtensionContext serviceExtensionContextTest;
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), true);
+    EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
     AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
     serviceExtensionContextTest.OnRequestFailure(requestId, element, "failure");
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), true);
+    EXPECT_EQ(serviceExtensionContextTest.onAtomicRequestResults_.empty(), true);
 }
 
 /**
@@ -740,17 +755,43 @@ HWTEST_F(ServiceExtensionContextTest, OnRequestFailure_0200, Function | MediumTe
 HWTEST_F(ServiceExtensionContextTest, OnRequestFailure_0300, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = [](const AppExecFwk::ElementName&, const std::string&) {};
-    OnRequestResult onRequestFail = [](const AppExecFwk::ElementName&, const std::string&) {};
-    ServiceExtensionContext serviceExtensionContextTest;
-    auto result = serviceExtensionContextTest.AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
+    ServiceExtensionContext contextTest;
+    auto result = contextTest.AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_OK);
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), false);
+    EXPECT_EQ(contextTest.onAtomicRequestResults_.empty(), false);
     AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
     std::string norequestId = "test";
-    serviceExtensionContextTest.OnRequestFailure(norequestId, element, "failure");
-    EXPECT_EQ(serviceExtensionContextTest.onRequestResults_.empty(), false);
-    serviceExtensionContextTest.onRequestResults_.clear();
+    contextTest.OnRequestFailure(norequestId, element, "failure");
+    EXPECT_EQ(contextTest.onAtomicRequestResults_.empty(), false);
+    contextTest.onAtomicRequestResults_.clear();
+}
+
+/**
+ * @tc.number: GetFailureInfoByMessage_0100
+ * @tc.name: GetFailureInfoByMessage
+ * @tc.desc: Verify that function GetFailureInfoByMessage.
+ */
+HWTEST_F(ServiceExtensionContextTest, GetFailureInfoByMessage_0100, Function | MediumTest | Level1)
+{
+    std::string message = "User refused redirection";
+    int32_t faileCode = 0;
+    std::string failReason;
+    ServiceExtensionContext contextTest;
+    int32_t resultCode = USER_CANCEL;
+    contextTest.GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
+    EXPECT_EQ(faileCode, 1);
+    EXPECT_EQ(failReason, "User cancelled redirection");
+    resultCode = 0;
+    contextTest.GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
+    EXPECT_EQ(faileCode, 2);
+    EXPECT_EQ(failReason, "User refused redirection");
+    message = "test";
+    contextTest.GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
+    EXPECT_EQ(faileCode, 0);
+    EXPECT_EQ(failReason, "failed to open atomicservice");
 }
 }
 }

test/unittest/ui_ability_lifecycle_manager_test/ui_ability_lifecycle_manager_test.cpp

@@ -6826,32 +6826,5 @@ HWTEST_F(UIAbilityLifecycleManagerTest, EnableListForSCBRecovery_001, TestSize.L
     EXPECT_TRUE(mgr->isSCBRecovery_);
     EXPECT_TRUE(mgr->coldStartInSCBRecovery_.empty());
 }
-
-
-/**
- * @tc.name: UIAbilityLifecycleManager_GetWantElement_0100
- * @tc.desc: GetWantElement
- * @tc.type: FUNC
- */
-HWTEST_F(UIAbilityLifecycleManagerTest, GetWantElement_0100, TestSize.Level1)
-{
-    auto mgr = std::make_unique<UIAbilityLifecycleManager>();
-    Want want;
-    AppExecFwk::ElementName element("", "com.test.demo", "MainAbility");
-    want.SetElement(element);
-    AbilityRequest abilityRequest;
-    abilityRequest.want = want;
-    sptr<SessionInfo> sessionInfo = nullptr;
-    AppExecFwk::ElementName result = mgr->GetWantElement(sessionInfo, abilityRequest);
-    EXPECT_EQ(result.GetAbilityName(), "MainAbility");
-    sessionInfo = new SessionInfo();
-    ASSERT_NE(sessionInfo, nullptr);
-    sessionInfo->isAtomicService = false;
-    result = mgr->GetWantElement(sessionInfo, abilityRequest);
-    EXPECT_EQ(result.GetAbilityName(), "MainAbility");
-    sessionInfo->isAtomicService = true;
-    result = mgr->GetWantElement(sessionInfo, abilityRequest);
-    EXPECT_TRUE(result.GetAbilityName().empty());
-}
 }  // namespace AAFwk
 }  // namespace OHOS

test/unittest/ui_extension_context_test/ui_extension_context_test.cpp

@@ -839,76 +839,81 @@ HWTEST_F(UIExtensionContextTest, IsTerminating_0100, TestSize.Level1)
 }
 
 /**
- * @tc.number: AddCompletionHandler_0100
- * @tc.name: AddCompletionHandler
- * @tc.desc: Verify that function AddCompletionHandler.
+ * @tc.number: AddCompletionHandlerForAtomicService_0100
+ * @tc.name: AddCompletionHandlerForAtomicService
+ * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
  */
-HWTEST_F(UIExtensionContextTest, AddCompletionHandler_100, Function | MediumTest | Level1)
+HWTEST_F(UIExtensionContextTest, AddCompletionHandlerForAtomicService_100, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = nullptr;
-    OnRequestResult onRequestFail = nullptr;
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = nullptr;
+    OnAtomicRequestFailure onRequestFail = nullptr;
     auto context = std::make_shared<UIExtensionContext>();
     ASSERT_NE(context, nullptr);
-    auto result = context->AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_INVALID_VALUE);
-    EXPECT_EQ(context->onRequestResults_.empty(), true);
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
 }
 
 /**
- * @tc.number: AddCompletionHandler_0200
- * @tc.name: AddCompletionHandler
- * @tc.desc: Verify that function AddCompletionHandler.
+ * @tc.number: AddCompletionHandlerForAtomicService_0200
+ * @tc.name: AddCompletionHandlerForAtomicService
+ * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
  */
-HWTEST_F(UIExtensionContextTest, AddCompletionHandler_0200, Function | MediumTest | Level1)
+HWTEST_F(UIExtensionContextTest, AddCompletionHandlerForAtomicService_0200, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = [](const AppExecFwk::ElementName&, const std::string&) {};
-    OnRequestResult onRequestFail = nullptr;
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = nullptr;
     auto context = std::make_shared<UIExtensionContext>();
     ASSERT_NE(context, nullptr);
-    auto result = context->AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_INVALID_VALUE);
-    EXPECT_EQ(context->onRequestResults_.empty(), true);
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
 }
 
 /**
- * @tc.number: AddCompletionHandler_0300
- * @tc.name: AddCompletionHandler
- * @tc.desc: Verify that function AddCompletionHandler.
+ * @tc.number: AddCompletionHandlerForAtomicService_0300
+ * @tc.name: AddCompletionHandlerForAtomicService
+ * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
  */
-HWTEST_F(UIExtensionContextTest, AddCompletionHandler_0300, Function | MediumTest | Level1)
+HWTEST_F(UIExtensionContextTest, AddCompletionHandlerForAtomicService_0300, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = [](const AppExecFwk::ElementName&, const std::string&) {};
-    OnRequestResult onRequestFail = [](const AppExecFwk::ElementName&, const std::string&) {};
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
     auto context = std::make_shared<UIExtensionContext>();
     ASSERT_NE(context, nullptr);
-    auto result = context->AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_OK);
-    EXPECT_EQ(context->onRequestResults_.empty(), false);
-    context->onRequestResults_.clear();
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), false);
+    context->onAtomicRequestResults_.clear();
 }
 
 /**
  * @tc.number: AddCompletionHandler_0400
- * @tc.name: AddCompletionHandler
- * @tc.desc: Verify that function AddCompletionHandler.
+ * @tc.name: AddCompletionHandlerForAtomicService
+ * @tc.desc: Verify that function AddCompletionHandlerForAtomicService.
  */
 HWTEST_F(UIExtensionContextTest, AddCompletionHandler_0400, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = [](const AppExecFwk::ElementName&, const std::string&) {};
-    OnRequestResult onRequestFail = [](const AppExecFwk::ElementName&, const std::string&) {};
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
     auto context = std::make_shared<UIExtensionContext>();
     ASSERT_NE(context, nullptr);
-    context->onRequestResults_.emplace_back(requestId, onRequestSucc, onRequestFail);
-    auto result = context->AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    context->onAtomicRequestResults_.emplace_back(
+        std::make_shared<OnAtomicRequestResult>(requestId, appId, onRequestSucc, onRequestFail));
+    auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_OK);
     std::string norequestId = "test";
-    result = context->AddCompletionHandler(norequestId, onRequestSucc, onRequestFail);
-    EXPECT_EQ(context->onRequestResults_.size(), 2);
-    context->onRequestResults_.clear();
+    result = context->AddCompletionHandlerForAtomicService(norequestId, onRequestSucc, onRequestFail, appId);
+    EXPECT_EQ(context->onAtomicRequestResults_.size(), 2);
+    context->onAtomicRequestResults_.clear();
 }
 
 /**
@@ -919,16 +924,17 @@ HWTEST_F(UIExtensionContextTest, AddCompletionHandler_0400, Function | MediumTes
 HWTEST_F(UIExtensionContextTest, OnRequestSuccess_0100, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = [](const AppExecFwk::ElementName&, const std::string&) {};
-    OnRequestResult onRequestFail = [](const AppExecFwk::ElementName&, const std::string&) {};
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
     auto context = std::make_shared<UIExtensionContext>();
     ASSERT_NE(context, nullptr);
-    auto result = context->AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_OK);
-    EXPECT_EQ(context->onRequestResults_.empty(), false);
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), false);
     AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
     context->OnRequestSuccess(requestId, element, "success");
-    EXPECT_EQ(context->onRequestResults_.empty(), true);
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
 }
 
 /**
@@ -941,10 +947,10 @@ HWTEST_F(UIExtensionContextTest, OnRequestSuccess_0200, Function | MediumTest |
     std::string requestId = "1234567890";
     auto context = std::make_shared<UIExtensionContext>();
     ASSERT_NE(context, nullptr);
-    EXPECT_EQ(context->onRequestResults_.empty(), true);
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
     AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
     context->OnRequestSuccess(requestId, element, "success");
-    EXPECT_EQ(context->onRequestResults_.empty(), true);
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
 }
 
 /**
@@ -955,18 +961,19 @@ HWTEST_F(UIExtensionContextTest, OnRequestSuccess_0200, Function | MediumTest |
 HWTEST_F(UIExtensionContextTest, OnRequestSuccess_0300, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = [](const AppExecFwk::ElementName&, const std::string&) {};
-    OnRequestResult onRequestFail = [](const AppExecFwk::ElementName&, const std::string&) {};
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
     auto context = std::make_shared<UIExtensionContext>();
     ASSERT_NE(context, nullptr);
-    auto result = context->AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_OK);
-    EXPECT_EQ(context->onRequestResults_.empty(), false);
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), false);
     AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
     std::string norequestId = "test";
     context->OnRequestSuccess(norequestId, element, "success");
-    EXPECT_EQ(context->onRequestResults_.empty(), false);
-    context->onRequestResults_.clear();
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), false);
+    context->onAtomicRequestResults_.clear();
 }
 
 /**
@@ -977,17 +984,18 @@ HWTEST_F(UIExtensionContextTest, OnRequestSuccess_0300, Function | MediumTest |
 HWTEST_F(UIExtensionContextTest, OnRequestFailure_0100, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = [](const AppExecFwk::ElementName&, const std::string&) {};
-    OnRequestResult onRequestFail = [](const AppExecFwk::ElementName&, const std::string&) {};
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
     auto context = std::make_shared<UIExtensionContext>();
     ASSERT_NE(context, nullptr);
-    auto result = context->AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_OK);
-    EXPECT_EQ(context->onRequestResults_.empty(), false);
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), false);
     AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
     context->OnRequestFailure(requestId, element, "failure");
-    EXPECT_EQ(context->onRequestResults_.empty(), true);
-    context->onRequestResults_.clear();
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
+    context->onAtomicRequestResults_.clear();
 }
 
 /**
@@ -1000,10 +1008,10 @@ HWTEST_F(UIExtensionContextTest, OnRequestFailure_0200, Function | MediumTest |
     std::string requestId = "1234567890";
     auto context = std::make_shared<UIExtensionContext>();
     ASSERT_NE(context, nullptr);
-    EXPECT_EQ(context->onRequestResults_.empty(), true);
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
     AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
     context->OnRequestFailure(requestId, element, "failure");
-    EXPECT_EQ(context->onRequestResults_.empty(), true);
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), true);
 }
 
 /**
@@ -1014,18 +1022,45 @@ HWTEST_F(UIExtensionContextTest, OnRequestFailure_0200, Function | MediumTest |
 HWTEST_F(UIExtensionContextTest, OnRequestFailure_0300, Function | MediumTest | Level1)
 {
     std::string requestId = "1234567890";
-    OnRequestResult onRequestSucc = [](const AppExecFwk::ElementName&, const std::string&) {};
-    OnRequestResult onRequestFail = [](const AppExecFwk::ElementName&, const std::string&) {};
+    std::string appId = "atomic";
+    OnAtomicRequestSuccess onRequestSucc = [](const std::string&) {};
+    OnAtomicRequestFailure onRequestFail = [](const std::string&, int32_t, const std::string&) {};
     auto context = std::make_shared<UIExtensionContext>();
     ASSERT_NE(context, nullptr);
-    auto result = context->AddCompletionHandler(requestId, onRequestSucc, onRequestFail);
+    auto result = context->AddCompletionHandlerForAtomicService(requestId, onRequestSucc, onRequestFail, appId);
     EXPECT_EQ(result, ERR_OK);
-    EXPECT_EQ(context->onRequestResults_.empty(), false);
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), false);
     AppExecFwk::ElementName element("", "com.example.com", "MainAbility");
     std::string norequestId = "test";
     context->OnRequestFailure(norequestId, element, "failure");
-    EXPECT_EQ(context->onRequestResults_.empty(), false);
-    context->onRequestResults_.clear();
+    EXPECT_EQ(context->onAtomicRequestResults_.empty(), false);
+    context->onAtomicRequestResults_.clear();
+}
+
+/**
+ * @tc.number: GetFailureInfoByMessage_0100
+ * @tc.name: GetFailureInfoByMessage
+ * @tc.desc: Verify that function GetFailureInfoByMessage.
+ */
+HWTEST_F(UIExtensionContextTest, GetFailureInfoByMessage_0100, Function | MediumTest | Level1)
+{
+    std::string message = "User refused redirection";
+    int32_t faileCode = 0;
+    std::string failReason;
+    int32_t resultCode = USER_CANCEL;
+    auto context = std::make_shared<UIExtensionContext>();
+    ASSERT_NE(context, nullptr);
+    context->GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
+    EXPECT_EQ(faileCode, 1);
+    EXPECT_EQ(failReason, "User cancelled redirection");
+    resultCode = 0;
+    context->GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
+    EXPECT_EQ(faileCode, 2);
+    EXPECT_EQ(failReason, "User refused redirection");
+    message = "test";
+    context->GetFailureInfoByMessage(message, faileCode, failReason, resultCode);
+    EXPECT_EQ(faileCode, 0);
+    EXPECT_EQ(failReason, "failed to open atomicservice");
 }
 } // namespace AbilityRuntime
 } // namespace OHOS