Merge branch 'master' of gitee.com:openharmony/ability_ability_runtime into DuliBianYi_20241016

Signed-off-by: jiangzhijun8 <jiangzhijun7@huawei.com>

ability_runtime.gni

@@ -92,8 +92,8 @@ access_token_path = "//base/security/access_token"
 declare_args() {
   background_task_mgr_continuous_task_enable = true
   resource_schedule_service_enable = true
-  ability_runtime_power = true
   ability_runtime_feature_sandboxmanager = false
+  ability_runtime_power = true
   ability_runtime_relational = true
   ability_runtime_ces = true
   ability_runtime_resource = true

cj_environment/frameworks/cj_environment/src/cj_environment.cpp

@@ -411,6 +411,7 @@ void* CJEnvironment::LoadCJLibrary(const char* dlName)
         return nullptr;
     }
 
+    isLoadCJLibrary_ = true;
     return handle;
 }
 
@@ -437,9 +438,15 @@ void* CJEnvironment::LoadCJLibrary(OHOS::CJEnvironment::LibraryKind kind, const
         LOGE("load cj library failed: %{public}s", DynamicGetError());
         return nullptr;
     }
+    isLoadCJLibrary_ = true;
     return handle;
 }
 
+bool CJEnvironment::CheckLoadCJLibrary()
+{
+    return isLoadCJLibrary_;
+}
+
 void CJEnvironment::UnLoadCJLibrary(void* handle)
 {
     DynamicFreeLibrary(handle);
@@ -516,6 +523,9 @@ CJ_EXPORT extern "C" CJEnvMethods* OHOS_GetCJEnvInstance()
         },
         .setSanitizerKindRuntimeVersion = [](SanitizerKind kind) {
             return CJEnvironment::GetInstance()->SetSanitizerKindRuntimeVersion(kind);
+        },
+        .checkLoadCJLibrary = []() {
+            return CJEnvironment::GetInstance()->CheckLoadCJLibrary();
         }
     };
     return &gCJEnvMethods;

cj_environment/interfaces/inner_api/cj_environment.h

@@ -57,6 +57,7 @@ public:
         return isUISchedulerStarted_;
     }
     bool StartUIScheduler();
+    bool CheckLoadCJLibrary();
     void StopUIScheduler();
     enum LibraryKind {
         SYSTEM,
@@ -86,6 +87,7 @@ private:
     bool LoadRuntimeApis();
     static CJRuntimeAPI lazyApis_;
     bool isRuntimeStarted_{false};
+    bool isLoadCJLibrary_{false};
     bool isUISchedulerStarted_{false};
     void* uiScheduler_ {nullptr};
     SanitizerKind sanitizerKind_ {SanitizerKind::NONE};

cj_environment/interfaces/inner_api/cj_envsetup.h

@@ -51,6 +51,7 @@ struct CJEnvMethods {
     bool (*startDebugger)() = nullptr;
     void (*registerCJUncaughtExceptionHandler)(const CJUncaughtExceptionInfo& uncaughtExceptionInfo) = nullptr;
     void (*setSanitizerKindRuntimeVersion)(SanitizerKind kind) = nullptr;
+    bool (*checkLoadCJLibrary)() = nullptr;
 };
 
 class CJEnv {

frameworks/cj/BUILD.gn

@@ -19,5 +19,6 @@ group("cj_ability_packages") {
     "${ability_runtime_path}/frameworks/cj/ffi:cj_ability_ffi",
     "${ability_runtime_path}/frameworks/cj/ffi/app/errormanager:cj_errormanager_ffi",
     "${ability_runtime_path}/frameworks/cj/ffi/ark_interop_helper:ark_interop_helper_ffi",
+    "${ability_runtime_path}/frameworks/cj/ffi/want_agent:cj_want_agent_ffi",
   ]
 }

frameworks/cj/ffi/cj_want_ffi.cpp

@@ -42,7 +42,7 @@ WantHandle FFICJWantCreateWithWantInfo(CJWantParams params)
     want->SetUri(params.uri);
     want->SetAction(params.action);
     want->SetType(params.wantType);
-    want->SetParams(OHOS::AAFwk::WantParamWrapper::ParseWantParams(params.parameters));
+    want->SetParams(OHOS::AAFwk::WantParamWrapper::ParseWantParamsWithBrackets(params.parameters));
 
     return want;
 }

frameworks/cj/ffi/want_agent/BUILD.gn

@@ -0,0 +1,64 @@
+# Copyright (c) 2024 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")
+import("//foundation/ability/ability_runtime/cj_environment/cj_environment.gni")
+
+ohos_shared_library("cj_want_agent_ffi") {
+  defines = [
+    "AMS_LOG_TAG = \"CJ_ABILITY_FFI\"",
+    "AMS_LOG_DOMAIN = 0xD001150",
+  ]
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+  include_dirs = [
+    "${ability_runtime_path}/interfaces/kits/native/ability/native",
+    "${ability_runtime_path}/frameworks/cj/ffi",
+    "${ability_runtime_path}/frameworks/cj/ffi/want_agent",
+    "${ability_runtime_services_path}/common/include",
+  ]
+
+  deps = [
+    "${ability_runtime_innerkits_path}/ability_manager:ability_start_options",
+    "${ability_runtime_innerkits_path}/wantagent:wantagent_innerkits",
+    "${ability_runtime_native_path}/appkit:app_context",
+    "${ability_runtime_path}/frameworks/cj/ffi:cj_ability_ffi",
+  ]
+
+  external_deps = [
+    "ability_base:want",
+    "c_utils:utils",
+    "hilog:libhilog",
+    "napi:cj_bind_ffi",
+    "napi:cj_bind_native",
+  ]
+
+  sources = [ "cj_want_agent_ffi.cpp" ]
+
+  cflags = [
+    "-fstack-protector-all",
+    "-fstack-protector-strong",
+    "-O2",
+    "-D_FORTIFY_SOURCE=2",
+  ]
+
+  cflags_cc = cflags
+
+  innerapi_tags = [ "platformsdk" ]
+  subsystem_name = "ability"
+  part_name = "ability_runtime"
+}

frameworks/cj/ffi/want_agent/cj_want_agent_ffi.cpp

@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) 2024 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 "want_agent_helper.h"
+#include "want_params_wrapper.h"
+#include "start_options.h"
+#include "cj_want_agent_ffi.h"
+#include "cj_ability_runtime_error.h"
+#include "cj_utils_ffi.h"
+#include "cj_lambda.h"
+
+namespace OHOS {
+namespace FfiWantAgent {
+
+using namespace OHOS::AbilityRuntime;
+
+constexpr int32_t BUSINESS_ERROR_CODE_OK = 0;
+constexpr int32_t NOTEQ = -1;
+
+CJTriggerCompleteCallBack::CJTriggerCompleteCallBack()
+{}
+
+CJTriggerCompleteCallBack::~CJTriggerCompleteCallBack()
+{}
+
+void CJTriggerCompleteCallBack::SetCallbackInfo(std::function<void(CJCompleteData)> callback)
+{
+    callback_ = callback;
+}
+
+void CJTriggerCompleteCallBack::SetWantAgentInstance(int64_t wantAgent)
+{
+    wantAgent_ = wantAgent;
+}
+
+void CJTriggerCompleteCallBack::OnSendFinished(
+    const AAFwk::Want &want, int resultCode, const std::string &resultData, const AAFwk::WantParams &resultExtras)
+{
+    CJCompleteData data = { .info = wantAgent_, .want = new (std::nothrow) AAFwk::Want(want),
+        .finalCode = resultCode, .finalData = CreateCStringFromString(resultData),
+        .extraInfo = CreateCStringFromString(OHOS::AAFwk::WantParamWrapper(resultExtras).ToString())};
+    callback_(data);
+}
+
+std::string CJWantAgent::OnGetBundleName(int32_t *errCode)
+{
+    std::string bundleName = "";
+    *errCode = WantAgentHelper::GetBundleName(wantAgent_, bundleName);
+    return bundleName;
+}
+
+int32_t CJWantAgent::OnGetUid(int32_t *errCode)
+{
+    int uid = -1;
+    *errCode = WantAgentHelper::GetUid(wantAgent_, uid);
+    return uid;
+}
+
+void CJWantAgent::OnCancel(int32_t *errCode)
+{
+    *errCode = WantAgentHelper::Cancel(wantAgent_);
+}
+
+void CJWantAgent::OnTrigger(CJTriggerInfo cjTriggerInfo, std::function<void(CJCompleteData)> callback, int32_t *errCode)
+{
+    TAG_LOGD(AAFwkTag::WANTAGENT, "called");
+    std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent> wantAgent = nullptr;
+    TriggerInfo triggerInfo;
+    auto triggerObj = std::make_shared<CJTriggerCompleteCallBack>();
+    *errCode = UnWrapTriggerInfoParam(cjTriggerInfo, callback, wantAgent, triggerInfo, triggerObj);
+    if (*errCode != NO_ERROR) {
+        return;
+    }
+    TAG_LOGD(AAFwkTag::WANTAGENT, "called");
+    WantAgentHelper::TriggerWantAgent(wantAgent, triggerObj, triggerInfo);
+}
+
+int32_t CJWantAgent::UnWrapTriggerInfoParam(CJTriggerInfo cjTriggerInfo, std::function<void(CJCompleteData)> callback,
+    std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent> &wantAgent, TriggerInfo &triggerInfo,
+    std::shared_ptr<CJTriggerCompleteCallBack> &triggerObj)
+{
+    wantAgent = wantAgent_;
+    std::shared_ptr<AAFwk::Want> want = nullptr;
+    if (cjTriggerInfo.hasWant) {
+        auto actualWant = reinterpret_cast<AAFwk::Want*>(cjTriggerInfo.want);
+        want = std::make_shared<AAFwk::Want>(*actualWant);
+    }
+    std::string permission = std::string(cjTriggerInfo.permission);
+    std::shared_ptr<AAFwk::WantParams> extraInfo = nullptr;
+    if (cjTriggerInfo.extraInfos != nullptr) {
+        extraInfo = std::make_shared<AAFwk::WantParams>(
+            OHOS::AAFwk::WantParamWrapper::ParseWantParamsWithBrackets(cjTriggerInfo.extraInfos));
+    }
+    std::shared_ptr<AAFwk::StartOptions> startOptions = std::make_shared<AAFwk::StartOptions>();
+    
+    TriggerInfo triggerInfoData(permission, extraInfo, want, startOptions, cjTriggerInfo.code);
+    triggerInfo = triggerInfoData;
+    if (triggerObj != nullptr) {
+        triggerObj->SetCallbackInfo(callback);
+        triggerObj->SetWantAgentInstance(GetID());
+    }
+    return BUSINESS_ERROR_CODE_OK;
+}
+
+int32_t CJWantAgent::OnGetOperationType(int32_t *errCode)
+{
+    int32_t operType;
+    *errCode = WantAgentHelper::GetType(wantAgent_, operType);
+    return operType;
+}
+
+bool CJWantAgent::OnEqual(std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent> second, int32_t *errCode)
+{
+    *errCode = WantAgentHelper::IsEquals(wantAgent_, second);
+    if (*errCode == BUSINESS_ERROR_CODE_OK) {
+        return true;
+    } else if (*errCode == NOTEQ) {
+        *errCode = BUSINESS_ERROR_CODE_OK;
+    }
+    return false;
+}
+
+extern "C" {
+int64_t FfiWantAgentGetWantAgent(CJWantAgentInfo info, int32_t *errCode)
+{
+    std::shared_ptr<AAFwk::WantParams> extraInfo =
+        std::make_shared<AAFwk::WantParams>(
+            OHOS::AAFwk::WantParamWrapper::ParseWantParamsWithBrackets(info.extraInfos));
+    std::vector<WantAgentConstant::Flags> wantAgentFlags;
+    for (int64_t i = 0; i < info.actionFlags.size; i++) {
+        wantAgentFlags.emplace_back(static_cast<WantAgentConstant::Flags>(info.actionFlags.head[i]));
+    }
+    std::vector<std::shared_ptr<AAFwk::Want>> wants;
+    for (int64_t i = 0; i < info.wants.size; i++) {
+        auto actualWant = reinterpret_cast<AAFwk::Want*>(info.wants.head[i]);
+        wants.emplace_back(std::make_shared<AAFwk::Want>(*actualWant));
+    }
+    WantAgentInfo wantAgentInfo(info.requestCode,
+                                static_cast<WantAgentConstant::OperationType>(info.actionType),
+                                wantAgentFlags,
+                                wants,
+                                extraInfo);
+    auto context = Context::GetApplicationContext();
+    std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent> wantAgent = nullptr;
+    ErrCode result = WantAgentHelper::GetWantAgent(context, wantAgentInfo, wantAgent);
+    if (result != NO_ERROR) {
+        *errCode = result;
+        return -1;
+    } else {
+        OHOS::AbilityRuntime::WantAgent::WantAgent* pWantAgent = nullptr;
+        if (wantAgent == nullptr) {
+            *errCode = ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
+            return -1;
+        } else {
+            pWantAgent = new (std::nothrow) OHOS::AbilityRuntime::WantAgent::WantAgent(
+                wantAgent->GetPendingWant());
+        }
+        if (pWantAgent == nullptr) {
+            *errCode = ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
+            return -1;
+        } else {
+            auto nativeWantAgent = OHOS::FFI::FFIData::Create<CJWantAgent>(
+                std::make_shared<OHOS::AbilityRuntime::WantAgent::WantAgent>(*pWantAgent));
+            return nativeWantAgent->GetID();
+        }
+    }
+}
+
+char* FfiWantAgentGetBoundleName(int64_t cjWantAgent, int32_t *errCode)
+{
+    auto nativeWantAgent = OHOS::FFI::FFIData::GetData<CJWantAgent>(cjWantAgent);
+    if (nativeWantAgent == nullptr) {
+        *errCode = ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
+        return nullptr;
+    }
+    std::string bundleName = nativeWantAgent->OnGetBundleName(errCode);
+    if (*errCode != NO_ERROR) {
+        return nullptr;
+    }
+    return CreateCStringFromString(bundleName);
+}
+
+int32_t FfiWantAgentGetUid(int64_t cjWantAgent, int32_t *errCode)
+{
+    auto nativeWantAgent = OHOS::FFI::FFIData::GetData<CJWantAgent>(cjWantAgent);
+    if (nativeWantAgent == nullptr) {
+        *errCode = ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
+        return -1;
+    }
+    return nativeWantAgent->OnGetUid(errCode);
+}
+
+void FfiWantAgentCancel(int64_t cjWantAgent, int32_t *errCode)
+{
+    auto nativeWantAgent = OHOS::FFI::FFIData::GetData<CJWantAgent>(cjWantAgent);
+    if (nativeWantAgent == nullptr) {
+        *errCode = ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
+        return;
+    }
+    return nativeWantAgent->OnCancel(errCode);
+}
+
+void FfiWantAgentTrigger(int64_t cjWantAgent, CJTriggerInfo triggerInfo,
+    void (*callback)(CJCompleteData), int32_t *errCode)
+{
+    auto nativeWantAgent = OHOS::FFI::FFIData::GetData<CJWantAgent>(cjWantAgent);
+    if (nativeWantAgent == nullptr) {
+        *errCode = ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
+        return;
+    }
+    return nativeWantAgent->OnTrigger(triggerInfo, CJLambda::Create(callback), errCode);
+}
+
+int32_t FfiWantAgentGetOperationType(int64_t cjWantAgent, int32_t *errCode)
+{
+    auto nativeWantAgent = OHOS::FFI::FFIData::GetData<CJWantAgent>(cjWantAgent);
+    if (nativeWantAgent == nullptr) {
+        *errCode = ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
+        return -1;
+    }
+    return nativeWantAgent->OnGetOperationType(errCode);
+}
+
+bool FfiWantAgentEqual(int64_t cjWantAgentFirst, int64_t cjWantAgentSecond, int32_t *errCode)
+{
+    auto nativeWantAgentFirst = OHOS::FFI::FFIData::GetData<CJWantAgent>(cjWantAgentFirst);
+    auto nativeWantAgentSecond = OHOS::FFI::FFIData::GetData<CJWantAgent>(cjWantAgentSecond);
+    if (nativeWantAgentFirst == nullptr || nativeWantAgentSecond == nullptr) {
+        *errCode = ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER;
+        return false;
+    }
+    return nativeWantAgentFirst->OnEqual(nativeWantAgentSecond->wantAgent_, errCode);
+}
+}
+} // namespace FfiWantAgent
+} // namespace OHOS

frameworks/cj/ffi/want_agent/cj_want_agent_ffi.h

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2024 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.
+ */
+
+#ifndef CJ_WANT_AGENT_FFI_H
+#define CJ_WANT_AGENT_FFI_H
+
+#include <cstdint>
+
+#include "application_context.h"
+#include "want.h"
+#include "want_agent.h"
+#include "want_agent_constant.h"
+#include "want_params.h"
+#include "cj_common_ffi.h"
+#include "cj_want_agent_utils.h"
+#include "ffi_remote_data.h"
+
+namespace OHOS {
+namespace FfiWantAgent {
+
+using namespace OHOS::AbilityRuntime::WantAgent;
+
+class CJTriggerCompleteCallBack : public CompletedCallback {
+public:
+    CJTriggerCompleteCallBack();
+    virtual ~CJTriggerCompleteCallBack();
+
+public:
+    void OnSendFinished(const AAFwk::Want &want, int resultCode, const std::string &resultData,
+        const AAFwk::WantParams &resultExtras) override;
+    void SetCallbackInfo(std::function<void(CJCompleteData)> callback);
+    void SetWantAgentInstance(int64_t wantAgent);
+
+private:
+    std::function<void(CJCompleteData)> callback_;
+    int64_t wantAgent_;
+};
+
+class CJWantAgent : public OHOS::FFI::FFIData {
+    DECL_TYPE(CJWantAgent, OHOS::FFI::FFIData)
+public:
+    explicit CJWantAgent(std::shared_ptr<WantAgent> wantAgent)
+        : wantAgent_(wantAgent) {};
+    
+    std::string OnGetBundleName(int32_t *errCode);
+    int32_t OnGetUid(int32_t *errCode);
+    void OnCancel(int32_t *errCode);
+    void OnTrigger(CJTriggerInfo triggerInfo, std::function<void(CJCompleteData)> callback, int32_t *errCode);
+    int32_t OnGetOperationType(int32_t *errCode);
+    bool OnEqual(std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent> second, int32_t *errCode);
+
+private:
+    int32_t UnWrapTriggerInfoParam(CJTriggerInfo cjTriggerInfo, std::function<void(CJCompleteData)> callback,
+        std::shared_ptr<WantAgent> &wantAgent, TriggerInfo &triggerInfo,
+        std::shared_ptr<CJTriggerCompleteCallBack> &triggerObj);
+
+public:
+    std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent> wantAgent_;
+};
+
+extern "C" {
+    FFI_EXPORT int64_t FfiWantAgentGetWantAgent(CJWantAgentInfo info, int32_t *errCode);
+    FFI_EXPORT char* FfiWantAgentGetBoundleName(int64_t cjWantAgent, int32_t *errCode);
+    FFI_EXPORT int32_t FfiWantAgentGetUid(int64_t cjWantAgent, int32_t *errCode);
+    FFI_EXPORT void FfiWantAgentCancel(int64_t cjWantAgent, int32_t *errCode);
+    FFI_EXPORT void FfiWantAgentTrigger(int64_t cjWantAgent, CJTriggerInfo triggerInfo,
+        void (*callback)(CJCompleteData), int32_t *errCode);
+    FFI_EXPORT int32_t FfiWantAgentGetOperationType(int64_t cjWantAgent, int32_t *errCode);
+    FFI_EXPORT bool FfiWantAgentEqual(int64_t cjWantAgentFirst, int64_t cjWantAgentSecond, int32_t *errCode);
+}
+
+}
+}
+#endif // CJ_WANT_AGENT_FFI_H

frameworks/cj/ffi/want_agent/cj_want_agent_utils.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2024 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.
+ */
+
+#ifndef CJ_WANT_AGENT_UTILS_FFI_H
+#define CJ_WANT_AGENT_UTILS_FFI_H
+
+#include <string>
+
+#include "want_agent_constant.h"
+#include "want_agent_helper.h"
+#include "cj_want_ffi.h"
+#include "cj_common_ffi.h"
+
+namespace OHOS {
+namespace FfiWantAgent {
+
+struct CJWantArr {
+    WantHandle* head;
+    int64_t size;
+};
+
+struct CJWantAgentInfo {
+    CJWantArr wants;
+    int32_t actionType;
+    int32_t requestCode;
+    CArrI32 actionFlags;
+    // Record<string, Object>
+    char* extraInfos;
+};
+
+struct CJTriggerInfo {
+    int32_t code;
+    WantHandle want;
+    bool hasWant;
+    char* permission;
+    // Record<string, Object>
+    char* extraInfos;
+};
+
+struct CJCompleteData {
+    int64_t info;
+    WantHandle want;
+    int32_t finalCode;
+    char* finalData;
+    // Record<string, Object>
+    char* extraInfo;
+};
+
+}
+}
+#endif // CJ_WANT_AGENT_UTILS_FFI_H

frameworks/js/napi/ability/ability.js

@@ -14,11 +14,15 @@
  */
 let Callee = requireNapi('application.Callee');
 let AbilityConstant = requireNapi('app.ability.AbilityConstant');
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
 
 class Ability {
   constructor() {
     this.callee = new Callee('rpc.application.callee');
-    console.log('Ability::constructor callee is ' + typeof this.callee + ' ' + this.callee);
+    hilog.sLogI(domainID, TAG, 'Ability::constructor callee is ' + typeof this.callee + ' ' + this.callee);
   }
   onCreate(want) { }
   onDestroy() { }
@@ -32,7 +36,7 @@ class Ability {
   onMemoryLevel(level) { }
   onWindowStageRestore(windowStage) { }
   onCallRequest() {
-    console.log('Ability::onCallRequest callee is ' + typeof this.callee + ' ' + this.callee);
+    hilog.sLogI(domainID, TAG, 'Ability::onCallRequest callee is ' + typeof this.callee + ' ' + this.callee);
     return this.callee;
   }
   onContinue(wantParams) { }

frameworks/js/napi/abilityDataUriUtils/ability_data_uri_utils.js

@@ -12,6 +12,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
+
 const URI_SPLIT = '/';
 
 const ERROR_CODE_INVALID_PARAM = 401;
@@ -39,7 +44,7 @@ class DataUriError extends Error {
 
 let dataUriUtils = {
   getId: (uri) => {
-    console.debug('DataUriUtils getId called.');
+    hilog.sLogD(domainID, TAG, 'DataUriUtils getId called.');
     if (typeof uri !== 'string') {
       throw new DataUriError(ERROR_CODE_INVALID_PARAM);
     }
@@ -54,7 +59,7 @@ let dataUriUtils = {
     return Number(ret);
   },
   updateId: (uri, id) => {
-    console.debug('DataUriUtils updateId called.');
+    hilog.sLogD(domainID, TAG, 'DataUriUtils updateId called.');
     if (typeof uri !== 'string' || typeof id !== 'number') {
       throw new DataUriError(ERROR_CODE_INVALID_PARAM);
     }
@@ -65,7 +70,7 @@ let dataUriUtils = {
     return ret + URI_SPLIT + id;
   },
   deleteId: (uri) => {
-    console.debug('DataUriUtils deleteId called.');
+    hilog.sLogD(domainID, TAG, 'DataUriUtils deleteId called.');
     if (typeof uri !== 'string') {
       throw new DataUriError(ERROR_CODE_INVALID_PARAM);
     }
@@ -80,7 +85,7 @@ let dataUriUtils = {
     return uri.substring(0, index);
   },
   attachId: (uri, id) => {
-    console.debug('DataUriUtils attachId called.');
+    hilog.sLogD(domainID, TAG, 'DataUriUtils attachId called.');
     if (typeof uri !== 'string' || typeof id !== 'number') {
       throw new DataUriError(ERROR_CODE_INVALID_PARAM);
     }

frameworks/js/napi/ability_context/ability_context.js

@@ -15,6 +15,10 @@
 
 let Context = requireNapi('application.Context');
 let Caller = requireNapi('application.Caller');
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
 
 const ERROR_CODE_INVALID_PARAM = 401;
 const ERROR_MSG_INVALID_PARAM = 'Invalid input parameter.';
@@ -61,7 +65,7 @@ class AbilityContext extends Context {
   startAbilityByCall(want) {
     return new Promise(async (resolve, reject) => {
       if (typeof want !== 'object' || want == null) {
-        console.log('AbilityContext::startAbilityByCall input param error');
+        hilog.sLogI(domainID, TAG, 'AbilityContext::startAbilityByCall input param error');
         reject(new ParamError('Parse param want failed, want must be Want'));
         return;
       }
@@ -70,13 +74,13 @@ class AbilityContext extends Context {
       try {
         callee = await this.__context_impl__.startAbilityByCall(want);
       } catch (error) {
-        console.log('AbilityContext::startAbilityByCall Obtain remoteObject failed');
+        hilog.sLogI(domainID, TAG, 'AbilityContext::startAbilityByCall Obtain remoteObject failed');
         reject(error);
         return;
       }
 
       resolve(new Caller(callee));
-      console.log('AbilityContext::startAbilityByCall success');
+      hilog.sLogI(domainID, TAG, 'AbilityContext::startAbilityByCall success');
       return;
     });
   }
@@ -84,7 +88,7 @@ class AbilityContext extends Context {
   startAbilityByCallWithAccount(want, accountId) {
     return new Promise(async (resolve, reject) => {
       if (typeof want !== 'object' || want == null || typeof accountId !== 'number') {
-        console.log('AbilityContext::startAbilityByCall With accountId input param error');
+        hilog.sLogI(domainID, TAG, 'AbilityContext::startAbilityByCall With accountId input param error');
         reject(new ParamError(
           'Parse param want or accountId failed, want must be Want and accountId must be number'));
         return;
@@ -94,13 +98,13 @@ class AbilityContext extends Context {
       try {
         callee = await this.__context_impl__.startAbilityByCall(want, accountId);
       } catch (error) {
-        console.log('AbilityContext::startAbilityByCall With accountId Obtain remoteObject failed');
+        hilog.sLogI(domainID, TAG, 'AbilityContext::startAbilityByCall With accountId Obtain remoteObject failed');
         reject(error);
         return;
       }
 
       resolve(new Caller(callee));
-      console.log('AbilityContext::startAbilityByCall With accountId success');
+      hilog.sLogI(domainID, TAG, 'AbilityContext::startAbilityByCall With accountId success');
       return;
     });
   }

frameworks/js/napi/app/ability_lifecycle_callback/BUILD.gn

@@ -43,7 +43,7 @@ ohos_shared_library("abilitylifecyclecallback") {
   ]
 
   external_deps = [ "napi:ace_napi" ]
-  
+
   relative_install_dir = "module/app/ability"
   subsystem_name = "ability"
   part_name = "ability_runtime"

frameworks/js/napi/app/ability_lifecycle_callback/ability_lifecycle_callback.js

@@ -12,96 +12,100 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
 
 class AbilityLifecycleCallback {
   constructor() {}
 
   onAbilityCreate(ability) {
-    console.log('onAbilityCreate');
+    hilog.sLogI(domainID, TAG, 'onAbilityCreate');
   }
 
   onWindowStageCreate(ability, windowStage) {
-    console.log('onWindowStageCreate');
+    hilog.sLogI(domainID, TAG, 'onWindowStageCreate');
   }
 
   onWindowStageActive(ability, windowStage) {
-    console.log('onWindowStageActive');
+    hilog.sLogI(domainID, TAG, 'onWindowStageActive');
   }
 
   onWindowStageInactive(ability, windowStage) {
-    console.log('onWindowStageInactive');
+    hilog.sLogI(domainID, TAG, 'onWindowStageInactive');
   }
 
   onWindowStageDestroy(ability, windowStage) {
-    console.log('onWindowStageDestroy');
+    hilog.sLogI(domainID, TAG, 'onWindowStageDestroy');
   }
 
   onAbilityDestroy(ability) {
-    console.log('onAbilityDestroy');
+    hilog.sLogI(domainID, TAG, 'onAbilityDestroy');
   }
 
   onAbilityForeground(ability) {
-    console.log('onAbilityForeground');
+    hilog.sLogI(domainID, TAG, 'onAbilityForeground');
   }
 
   onAbilityBackground(ability) {
-    console.log('onAbilityBackground');
+    hilog.sLogI(domainID, TAG, 'onAbilityBackground');
   }
 
   onAbilityContinue(ability) {
-    console.log('onAbilityContinue');
+    hilog.sLogI(domainID, TAG, 'onAbilityContinue');
   }
 
   onNewWant(ability) {
-    console.log('onNewWant');
+    hilog.sLogI(domainID, TAG, 'onNewWant');
   }
 
   onWillNewWant(ability) {
-    console.log('onWillNewWant');
+    hilog.sLogI(domainID, TAG, 'onWillNewWant');
   }
 
   onAbilityWillCreate(ability) {
-    console.log('onAbilityWillCreate');
+    hilog.sLogI(domainID, TAG, 'onAbilityWillCreate');
   }
 
   onWindowStageWillCreate(ability, windowStage) {
-    console.log('onWindowStageWillCreate');
+    hilog.sLogI(domainID, TAG, 'onWindowStageWillCreate');
   }
 
   onWindowStageWillDestroy(ability, windowStage) {
-    console.log('onWindowStageWillDestroy');
+    hilog.sLogI(domainID, TAG, 'onWindowStageWillDestroy');
   }
 
   onAbilityWillDestroy(ability) {
-    console.log('onAbilityWillDestroy');
+    hilog.sLogI(domainID, TAG, 'onAbilityWillDestroy');
   }
 
   onAbilityWillForeground(ability) {
-    console.log('onAbilityWillForeground');
+    hilog.sLogI(domainID, TAG, 'onAbilityWillForeground');
   }
 
   onAbilityWillBackground(ability) {
-    console.log('onAbilityWillBackground');
+    hilog.sLogI(domainID, TAG, 'onAbilityWillBackground');
   }
 
   onAbilityWillContinue(ability) {
-    console.log('onAbilityWillContinue');
+    hilog.sLogI(domainID, TAG, 'onAbilityWillContinue');
   }
 
   onWindowStageWillRestore(ability, windowStage) {
-    console.log('onWindowStageWillRestore');
+    hilog.sLogI(domainID, TAG, 'onWindowStageWillRestore');
   }
 
   onWindowStageRestore(ability, windowStage) {
-    console.log('onWindowStageRestore');
+    hilog.sLogI(domainID, TAG, 'onWindowStageRestore');
   }
 
   onAbilityWillSaveState(ability) {
-    console.log('onAbilityWillSaveState');
+    hilog.sLogI(domainID, TAG, 'onAbilityWillSaveState');
   }
 
   onAbilitySaveState(ability) {
-    console.log('onAbilitySaveState');
+    hilog.sLogI(domainID, TAG, 'onAbilitySaveState');
   }
 }
 

frameworks/js/napi/app/ability_stage/ability_stage.js

@@ -13,15 +13,20 @@
  * limitations under the License.
  */
 
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
+
 class AbilityStage {
   constructor() { }
   onCreate() { }
   onDestroy() { }
   onAcceptWant(want) {
-    console.log('onAcceptWant, want:' + want.abilityName);
+    hilog.sLogI(domainID, TAG, 'onAcceptWant, want:' + want.abilityName);
   }
   onNewProcessRequest(want) {
-    console.log('onNewProcessRequest, want:' + want.abilityName);
+    hilog.sLogI(domainID, TAG, 'onNewProcessRequest, want:' + want.abilityName);
   }
   onConfigurationUpdated(config) { }
   onConfigurationUpdate(newConfig) { }

frameworks/js/napi/app/application_state_change_callback/application_state_change_callback.js

@@ -13,15 +13,20 @@
  * limitations under the License.
  */
 
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
+
 class ApplicationStateChangeCallback {
   constructor() {}
 
   onApplicationForeground() {
-    console.log('onApplicationForeground');
+    hilog.sLogI(domainID, TAG, 'onApplicationForeground');
   }
 
   onApplicationBackground() {
-    console.log('onApplicationBackground');
+    hilog.sLogI(domainID, TAG, 'onApplicationBackground');
   }
 }
 

frameworks/js/napi/app/context/BUILD.gn

@@ -42,7 +42,7 @@ ohos_shared_library("context_napi") {
   ]
 
   external_deps = [ "napi:ace_napi" ]
-  
+
   relative_install_dir = "module/application"
   subsystem_name = "ability"
   part_name = "ability_runtime"

frameworks/js/napi/app/environment_callback/environment_callback.js

@@ -13,15 +13,20 @@
  * limitations under the License.
  */
 
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
+
 class EnvironmentCallback {
   constructor() {}
 
   onConfigurationUpdated(config) {
-    console.log('onConfigurationUpdated');
+    hilog.sLogI(domainID, TAG, 'onConfigurationUpdated');
   }
 
   onMemoryLevel(level) {
-    console.log('onMemoryLevel');
+    hilog.sLogI(domainID, TAG, 'onMemoryLevel');
   }
 }
 

frameworks/js/napi/app/sendable_context_manager/js_sendable_context_manager.cpp

@@ -111,13 +111,22 @@ napi_value CreateJsBaseContextFromSendable(napi_env env, void* wrapped)
     }
 
     auto workContext = new (std::nothrow) std::weak_ptr<Context>(contextPtr);
-    auto status = napi_wrap(env, object, workContext,
+    auto status = napi_coerce_to_native_binding_object(env, object, DetachCallbackFunc, AttachBaseContext,
+        workContext, nullptr);
+    if (status != napi_ok) {
+        TAG_LOGE(AAFwkTag::CONTEXT, "coerce context failed: %{public}d", status);
+        delete workContext;
+        return nullptr;
+    }
+
+    status = napi_wrap(env, object, workContext,
         [](napi_env, void *data, void *) {
             TAG_LOGD(AAFwkTag::CONTEXT, "finalizer for weak_ptr context");
             delete static_cast<std::weak_ptr<Context> *>(data);
         }, nullptr, nullptr);
     if (status != napi_ok) {
         TAG_LOGE(AAFwkTag::CONTEXT, "wrap context failed: %{public}d", status);
+        delete workContext;
         return nullptr;
     }
 
@@ -160,13 +169,22 @@ napi_value CreateJsApplicationContextFromSendable(napi_env env, void* wrapped)
     }
 
     auto workContext = new (std::nothrow) std::weak_ptr<ApplicationContext>(applicationContext);
-    auto status = napi_wrap(env, object, workContext,
+    auto status = napi_coerce_to_native_binding_object(env, object, DetachCallbackFunc, AttachApplicationContext,
+        workContext, nullptr);
+    if (status != napi_ok) {
+        TAG_LOGE(AAFwkTag::CONTEXT, "coerce application context failed: %{public}d", status);
+        delete workContext;
+        return nullptr;
+    }
+
+    status = napi_wrap(env, object, workContext,
         [](napi_env, void *data, void *) {
             TAG_LOGD(AAFwkTag::CONTEXT, "finalizer for weak_ptr application context");
             delete static_cast<std::weak_ptr<ApplicationContext> *>(data);
         }, nullptr, nullptr);
     if (status != napi_ok) {
         TAG_LOGE(AAFwkTag::CONTEXT, "wrap application context failed: %{public}d", status);
+        delete workContext;
         return nullptr;
     }
 
@@ -209,13 +227,22 @@ napi_value CreateJsAbilityStageContextFromSendable(napi_env env, void* wrapped)
     }
 
     auto workContext = new (std::nothrow) std::weak_ptr<AbilityStageContext>(abilitystageContext);
-    auto status = napi_wrap(env, object, workContext,
+    auto status = napi_coerce_to_native_binding_object(env, object, DetachCallbackFunc, AttachAbilityStageContext,
+        workContext, nullptr);
+    if (status != napi_ok) {
+        TAG_LOGE(AAFwkTag::CONTEXT, "coerce ability stage context failed: %{public}d", status);
+        delete workContext;
+        return nullptr;
+    }
+
+    status = napi_wrap(env, object, workContext,
         [](napi_env, void *data, void *) {
             TAG_LOGD(AAFwkTag::CONTEXT, "finalizer for weak_ptr ability stage context");
             delete static_cast<std::weak_ptr<AbilityStageContext> *>(data);
         }, nullptr, nullptr);
     if (status != napi_ok) {
         TAG_LOGE(AAFwkTag::CONTEXT, "wrap ability stage context failed: %{public}d", status);
+        delete workContext;
         return nullptr;
     }
 
@@ -258,13 +285,22 @@ napi_value CreateJsUIAbilityContextFromSendable(napi_env env, void* wrapped)
     }
 
     auto workContext = new (std::nothrow) std::weak_ptr<AbilityContext>(uiAbilityContext);
-    auto status = napi_wrap(env, object, workContext,
+    auto status = napi_coerce_to_native_binding_object(env, object, DetachCallbackFunc, AttachJsUIAbilityContext,
+        workContext, nullptr);
+    if (status != napi_ok) {
+        TAG_LOGE(AAFwkTag::CONTEXT, "coerce ui ability context failed: %{public}d", status);
+        delete workContext;
+        return nullptr;
+    }
+
+    status = napi_wrap(env, object, workContext,
         [](napi_env, void *data, void *) {
             TAG_LOGD(AAFwkTag::CONTEXT, "finalizer for weak_ptr ui ability context");
             delete static_cast<std::weak_ptr<AbilityContext> *>(data);
         }, nullptr, nullptr);
     if (status != napi_ok) {
         TAG_LOGE(AAFwkTag::CONTEXT, "wrap ui ability context failed: %{public}d", status);
+        delete workContext;
         return nullptr;
     }
 

frameworks/js/napi/app_startup/async_task_excutor/async_task_excutor.ts

@@ -16,12 +16,9 @@
 async function concurrentFunc(startup, asyncCallback, context, startupName): void {
   'use concurrent';
   console.log('concurrentFunc start.');
-  let startupResult;
-  await startup.init(context).then((result: Object) => {
-    startupResult = result;
-    let taskPool = requireNapi('taskpool');
-    taskPool.Task.sendData(asyncCallback, startupName, startupResult);
-  });
+  let startupResult = await startup.init(context);
+  let taskPool = requireNapi('taskpool');
+  taskPool.Task.sendData(asyncCallback, startupName, startupResult);
   console.log('concurrentFunc end.');
 }
 

frameworks/js/napi/auto_fill_extension_ability/BUILD.gn

@@ -43,7 +43,7 @@ ohos_shared_library("autofillextensionability_napi") {
   ]
 
   external_deps = [ "napi:ace_napi" ]
-  
+
   relative_install_dir = "module/app/ability"
   subsystem_name = "ability"
   part_name = "ability_runtime"

frameworks/js/napi/auto_fill_extension_ability/auto_fill_extension_ability.js

@@ -14,38 +14,42 @@
  */
 
 let ExtensionAbility = requireNapi('app.ability.ExtensionAbility');
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
 
 class AutoFillExtensionAbility extends ExtensionAbility {
   onCreate() {
-    console.log('onCreate');
+    hilog.sLogI(domainID, TAG, 'onCreate');
   }
 
   onFillRequest(session, request, callback) {
-    console.log('onFillRequest');
+    hilog.sLogI(domainID, TAG, 'onFillRequest');
   }
 
   onSaveRequest(session, request, callback) {
-    console.log('onSaveRequest');
+    hilog.sLogI(domainID, TAG, 'onSaveRequest');
   }
 
   onUpdateRequest(request) {
-    console.log('onUpdateRequest');
+    hilog.sLogI(domainID, TAG, 'onUpdateRequest');
   }
 
   onSessionDestroy(session) {
-    console.log('onSessionDestroy');
+    hilog.sLogI(domainID, TAG, 'onSessionDestroy');
   }
 
   onForeground() {
-    console.log('onForeground');
+    hilog.sLogI(domainID, TAG, 'onForeground');
   }
 
   onBackground() {
-    console.log('onBackground');
+    hilog.sLogI(domainID, TAG, 'onBackground');
   }
 
   onDestroy() {
-    console.log('onDestroy');
+    hilog.sLogI(domainID, TAG, 'onDestroy');
   }
 }
 

frameworks/js/napi/callee/callee.js

@@ -14,6 +14,10 @@
  */
 let rpc = requireNapi('rpc');
 let accessControl = requireNapi('abilityAccessCtrl');
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
 
 const EVENT_CALL_NOTIFY = 1;
 const REQUEST_SUCCESS = 0;
@@ -63,9 +67,9 @@ class Callee extends rpc.RemoteObject {
       super(des);
       this.callList = new Map();
       this.startUpNewRule = false;
-      console.log('Callee constructor is OK ' + typeof des);
+      hilog.sLogI(domainID, TAG, 'Callee constructor is OK ' + typeof des);
     } else {
-      console.log('Callee constructor error, des is ' + typeof des);
+      hilog.sLogI(domainID, TAG, 'Callee constructor error, des is ' + typeof des);
       return null;
     }
   }
@@ -75,31 +79,31 @@ class Callee extends rpc.RemoteObject {
   }
 
   onRemoteMessageRequest(code, data, reply, option) {
-    console.log('Callee onRemoteMessageRequest code [' + typeof code + ' ' + code + ']');
+    hilog.sLogI(domainID, TAG, 'Callee onRemoteMessageRequest code [' + typeof code + ' ' + code + ']');
     if (!this.StartUpRuleCheck()) {
       return false;
     }
 
     if (typeof code !== 'number' || typeof data !== 'object' ||
       typeof reply !== 'object' || typeof option !== 'object') {
-      console.log('Callee onRemoteMessageRequest error, code is [' +
+      hilog.sLogI(domainID, TAG, 'Callee onRemoteMessageRequest error, code is [' +
         typeof code + '], data is [' + typeof data + '], reply is [' +
         typeof reply + '], option is [' + typeof option + ']');
       return false;
     }
 
-    console.log('Callee onRemoteMessageRequest code proc');
+    hilog.sLogI(domainID, TAG, 'Callee onRemoteMessageRequest code proc');
     if (code === EVENT_CALL_NOTIFY) {
       if (this.callList == null) {
-        console.log('Callee onRemoteMessageRequest error, this.callList is nullptr');
+        hilog.sLogI(domainID, TAG, 'Callee onRemoteMessageRequest error, this.callList is nullptr');
         return false;
       }
 
       let method = data.readString();
-      console.log('Callee onRemoteMessageRequest method [' + method + ']');
+      hilog.sLogI(domainID, TAG, 'Callee onRemoteMessageRequest method [' + method + ']');
       let func = this.callList.get(method);
       if (typeof func !== 'function') {
-        console.log('Callee onRemoteMessageRequest error, get func is ' + typeof func);
+        hilog.sLogI(domainID, TAG, 'Callee onRemoteMessageRequest error, get func is ' + typeof func);
         return false;
       }
 
@@ -108,71 +112,72 @@ class Callee extends rpc.RemoteObject {
         reply.writeInt(REQUEST_SUCCESS);
         reply.writeString(typeof result);
         reply.writeParcelable(result);
-        console.log('Callee onRemoteMessageRequest code proc Packed data');
+        hilog.sLogI(domainID, TAG, 'Callee onRemoteMessageRequest code proc Packed data');
       } else {
         reply.writeInt(REQUEST_FAILED);
         reply.writeString(typeof result);
-        console.log('Callee onRemoteMessageRequest error, retval is ' + REQUEST_FAILED + ', type is ' + typeof result);
+        hilog.sLogI(domainID, TAG, 'Callee onRemoteMessageRequest error, retval is ' +
+          REQUEST_FAILED + ', type is ' + typeof result, REQUEST_FAILED, typeof result);
       }
     } else {
-      console.log('Callee onRemoteMessageRequest error, code is ' + code);
+      hilog.sLogI(domainID, TAG, 'Callee onRemoteMessageRequest error, code is ' + code);
       return false;
     }
-    console.log('Callee onRemoteMessageRequest code proc success');
+    hilog.sLogI(domainID, TAG, 'Callee onRemoteMessageRequest code proc success');
     return true;
   }
 
   on(method, callback) {
     if (typeof method !== 'string' || method === '' || typeof callback !== 'function') {
-      console.log(
+      hilog.sLogI(domainID, TAG,
         'Callee on error, method is [' + typeof method + '], typeof callback [' + typeof callback + ']');
       throw new ThrowInvalidParamError('Parameter error: Failed to get method or callback.' +
         'method must be a non-empty string, callback must be a function.');
     }
 
     if (this.callList == null) {
-      console.log('Callee on error, this.callList is nullptr');
+      hilog.sLogI(domainID, TAG, 'Callee on error, this.callList is nullptr');
       throw new BusinessError(ERROR_CODE_INNER_ERROR);
     }
 
     if (this.callList.has(method)) {
-      console.log('Callee on error, [' + method + '] has registered');
+      hilog.sLogI(domainID, TAG, 'Callee on error, [' + method + '] has registered');
       throw new BusinessError(ERROR_CODE_FUNC_REGISTERED);
     }
 
     this.callList.set(method, callback);
-    console.log('Callee on method [' + method + ']');
+    hilog.sLogI(domainID, TAG, 'Callee on method [' + method + ']');
   }
 
   off(method) {
     if (typeof method !== 'string' || method === '') {
-      console.log('Callee off error, method is [' + typeof method + ']');
+      hilog.sLogI(domainID, TAG, 'Callee off error, method is [' + typeof method + ']');
       throw new ThrowInvalidParamError('Parameter error: Failed to get method, must be a string.');
     }
 
     if (this.callList == null) {
-      console.log('Callee off error, this.callList is null');
+      hilog.sLogI(domainID, TAG, 'Callee off error, this.callList is null');
       throw new BusinessError(ERROR_CODE_INNER_ERROR);
     }
 
     if (!this.callList.has(method)) {
-      console.log('Callee off error, this.callList not found ' + method);
+      hilog.sLogI(domainID, TAG, 'Callee off error, this.callList not found ' + method);
       throw new BusinessError(ERROR_CODE_FUNC_NOT_EXIST);
     }
 
     this.callList.delete(method);
-    console.log('Callee off method [' + method + ']');
+    hilog.sLogI(domainID, TAG, 'Callee off method [' + method + ']');
   }
 
   StartUpRuleCheck() {
     if (this.startUpNewRule && rpc.IPCSkeleton.isLocalCalling()) {
-      console.log('Use new start up rule, check caller permission.');
+      hilog.sLogI(domainID, TAG, 'Use new start up rule, check caller permission.');
       let accessManger = accessControl.createAtManager();
       let accessTokenId = rpc.IPCSkeleton.getCallingTokenId();
       let grantStatus =
         accessManger.verifyAccessTokenSync(accessTokenId, PERMISSION_ABILITY_BACKGROUND_COMMUNICATION);
       if (grantStatus === accessControl.GrantStatus.PERMISSION_DENIED) {
-        console.log(
+        hilog.sLogI(domainID, TAG,
           'Callee onRemoteMessageRequest error, the Caller does not have PERMISSION_ABILITY_BACKGROUND_COMMUNICATION');
         return false;
       }

frameworks/js/napi/caller/caller.js

@@ -13,6 +13,10 @@
  * limitations under the License.
  */
 let rpc = requireNapi('rpc');
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
 
 const EVENT_CALL_NOTIFY = 1;
 const REQUEST_SUCCESS = 0;
@@ -56,7 +60,7 @@ class ThrowInvalidParamError extends Error {
 
 class Caller {
   constructor(obj) {
-    console.log('Caller::constructor obj is ' + typeof obj);
+    hilog.sLogI(domainID, TAG, 'Caller::constructor obj is ' + typeof obj);
     this.__call_obj__ = obj;
     this.releaseState = false;
   }
@@ -69,7 +73,7 @@ class Caller {
         return;
       }
 
-      console.log('Caller call msgData rpc.MessageSequence create');
+      hilog.sLogI(domainID, TAG, 'Caller call msgData rpc.MessageSequence create');
       let msgData = this.buildMsgData(method, data);
       let msgReply = rpc.MessageSequence.create();
 
@@ -77,16 +81,16 @@ class Caller {
       try {
         retData = await this.__call_obj__.callee.sendMessageRequest(EVENT_CALL_NOTIFY, msgData, msgReply,
           rpc.MessageOption());
-        console.log('Caller call msgData rpc.sendMessageRequest called');
+        hilog.sLogI(domainID, TAG, 'Caller call msgData rpc.sendMessageRequest called');
         if (retData.errCode !== 0) {
           msgData.reclaim();
           msgReply.reclaim();
-          console.log('Caller call return errCode ' + retData.errCode);
+          hilog.sLogI(domainID, TAG, 'Caller call return errCode ' + retData.errCode);
           reject(new BusinessError(retData.errCode));
           return;
         }
       } catch (e) {
-        console.log('Caller call msgData rpc.sendMessageRequest error ' + e);
+        hilog.sLogI(domainID, TAG, 'Caller call msgData rpc.sendMessageRequest error ' + e);
       }
 
       try {
@@ -96,21 +100,22 @@ class Caller {
           msgData.reclaim();
           msgReply.reclaim();
         } else {
-          console.log('Caller call retval is [' + retval + '], str [' + str + ']');
+          hilog.sLogD(domainID, TAG,
+            'Caller call retval is [' + retval + '], str [' + str + ']');
           msgData.reclaim();
           msgReply.reclaim();
           reject(new BusinessError(retval));
           return;
         }
       } catch (e) {
-        console.log('Caller call msgData sendMessageRequest retval error');
+        hilog.sLogI(domainID, TAG, 'Caller call msgData sendMessageRequest retval error');
         msgData.reclaim();
         msgReply.reclaim();
         reject(new BusinessError(ERROR_CODE_INNER_ERROR));
         return;
       }
 
-      console.log('Caller call msgData sendMessageRequest end');
+      hilog.sLogI(domainID, TAG, 'Caller call msgData sendMessageRequest end');
       resolve(undefined);
       return;
     });
@@ -118,14 +123,14 @@ class Caller {
 
   callWithResult(method, data) {
     return new Promise(async (resolve, reject) => {
-      console.log('Caller callWithResult method [' + method + ']');
+      hilog.sLogI(domainID, TAG, 'Caller callWithResult method [' + method + ']');
       const checkError = this.callCheck(method, data);
       if (checkError != null) {
         reject(checkError);
         return;
       }
 
-      console.log('Caller callWithResult msgData rpc.MessageSequence create');
+      hilog.sLogI(domainID, TAG, 'Caller callWithResult msgData rpc.MessageSequence create');
       let msgData = this.buildMsgData(method, data);
       let msgReply = rpc.MessageSequence.create();
 
@@ -134,16 +139,16 @@ class Caller {
       try {
         retData = await this.__call_obj__.callee.sendMessageRequest(EVENT_CALL_NOTIFY, msgData, msgReply,
           rpc.MessageOption());
-        console.log('Caller callWithResult msgData rpc.sendMessageRequest called');
+        hilog.sLogI(domainID, TAG, 'Caller callWithResult msgData rpc.sendMessageRequest called');
         if (retData.errCode !== 0) {
           msgData.reclaim();
           msgReply.reclaim();
-          console.log('Caller callWithResult return errCode ' + retData.errCode);
+          hilog.sLogI(domainID, TAG, 'Caller callWithResult return errCode ' + retData.errCode);
           reject(new BusinessError(retData.errCode));
           return;
         }
       } catch (e) {
-        console.log('Caller call msgData rpc.MessageSequence error ' + e);
+        hilog.sLogI(domainID, TAG, 'Caller call msgData rpc.MessageSequence error ' + e);
       }
 
       try {
@@ -153,35 +158,36 @@ class Caller {
           msgData.reclaim();
           reply = retData.reply;
         } else {
-          console.log('Caller callWithResult retval is [' + retval + '], str [' + str + ']');
+          hilog.sLogI(domainID, TAG,
+            'Caller callWithResult retval is [' + retval + '], str [' + str + ']');
           msgData.reclaim();
           msgReply.reclaim();
           reject(new BusinessError(retval));
           return;
         }
       } catch (e) {
-        console.log('Caller callWithResult msgData sendMessageRequest retval error');
+        hilog.sLogI(domainID, TAG, 'Caller callWithResult msgData sendMessageRequest retval error');
         msgData.reclaim();
         msgReply.reclaim();
         reject(new BusinessError(ERROR_CODE_INNER_ERROR));
         return;
       }
 
-      console.log('Caller callWithResult msgData sendMessageRequest end');
+      hilog.sLogI(domainID, TAG, 'Caller callWithResult msgData sendMessageRequest end');
       resolve(reply);
       return;
     });
   }
 
   release() {
-    console.log('Caller release js called.');
+    hilog.sLogI(domainID, TAG, 'Caller release js called.');
     if (this.releaseState === true) {
-      console.log('Caller release remoteObj releaseState is true');
+      hilog.sLogI(domainID, TAG, 'Caller release remoteObj releaseState is true');
       throw new BusinessError(ERROR_CODE_CALLER_RELEASED);
     }
 
     if (this.__call_obj__.callee == null) {
-      console.log('Caller release call remoteObj is released');
+      hilog.sLogI(domainID, TAG, 'Caller release call remoteObj is released');
       throw new BusinessError(ERROR_CODE_CLAAEE_INVALID);
     }
 
@@ -190,14 +196,14 @@ class Caller {
   }
 
   onRelease(callback) {
-    console.log('Caller onRelease jscallback called.');
+    hilog.sLogI(domainID, TAG, 'Caller onRelease jscallback called.');
     if (typeof callback !== 'function') {
-      console.log('Caller onRelease ' + typeof callback);
+      hilog.sLogI(domainID, TAG, 'Caller onRelease ' + typeof callback);
       throw new ThrowInvalidParamError('Parameter error: Failed to get callback, must be a function.');
     }
 
     if (this.releaseState === true) {
-      console.log('Caller onRelease remoteObj releaseState is true');
+      hilog.sLogI(domainID, TAG, 'Caller onRelease remoteObj releaseState is true');
       throw new BusinessError(ERROR_CODE_CALLER_RELEASED);
     }
 
@@ -205,14 +211,14 @@ class Caller {
   }
 
   onRemoteStateChange(callback) {
-    console.log('Caller onRemoteStateChange jscallback called.');
+    hilog.sLogI(domainID, TAG, 'Caller onRemoteStateChange jscallback called.');
     if (typeof callback !== 'function') {
-      console.log('Caller onRemoteStateChange ' + typeof callback);
+      hilog.sLogI(domainID, TAG, 'Caller onRemoteStateChange ' + typeof callback);
       throw new ThrowInvalidParamError('Parameter error: Failed to get callback, must be a function.');
     }
 
     if (this.releaseState === true) {
-      console.log('Caller onRemoteStateChange remoteObj releaseState is true');
+      hilog.sLogI(domainID, TAG, 'Caller onRemoteStateChange remoteObj releaseState is true');
       throw new BusinessError(ERROR_CODE_CALLER_RELEASED);
     }
 
@@ -220,20 +226,20 @@ class Caller {
   }
 
   on(type, callback) {
-    console.log('Caller onRelease jscallback called.');
+    hilog.sLogI(domainID, TAG, 'Caller onRelease jscallback called.');
     if (typeof type !== 'string' || type !== 'release') {
-      console.log(
+      hilog.sLogI(domainID, TAG,
         'Caller onRelease error, input [type] is invalid.');
       throw new ThrowInvalidParamError('Parameter error: Failed to get type, must be string type release.');
     }
 
     if (typeof callback !== 'function') {
-      console.log('Caller onRelease error ' + typeof callback);
+      hilog.sLogI(domainID, TAG, 'Caller onRelease error ' + typeof callback);
       throw new ThrowInvalidParamError('Parameter error: Failed to get callback, must be a function.');
     }
 
     if (this.releaseState === true) {
-      console.log('Caller onRelease error, remoteObj releaseState is true');
+      hilog.sLogI(domainID, TAG, 'Caller onRelease error, remoteObj releaseState is true');
       throw new BusinessError(ERROR_CODE_CALLER_RELEASED);
     }
 
@@ -242,13 +248,13 @@ class Caller {
 
   off(type, callback) {
     if (typeof type !== 'string' || type !== 'release') {
-      console.log(
-        'Caller onRelease error, input [type] is invalid.');
+      hilog.sLogI(domainID, TAG,
+         'Caller onRelease error, input [type] is invalid.');
       throw new ThrowInvalidParamError('Parameter error: Failed to get type, must be string type release.');
     }
 
     if (callback && typeof callback !== 'function') {
-      console.log('Caller onRelease error ' + typeof callback);
+      hilog.sLogI(domainID, TAG, 'Caller onRelease error ' + typeof callback);
       throw new ThrowInvalidParamError('Parameter error: Failed to get callback, must be a function.');
     }
     // Empty
@@ -256,23 +262,25 @@ class Caller {
 
   callCheck(method, data) {
     if (typeof method !== 'string' || typeof data !== 'object') {
-      console.log('Caller callCheck ' + typeof method + ' ' + typeof data);
+      hilog.sLogI(domainID, TAG,
+        'Caller callCheck ' + typeof method + ' ' + typeof data);
       return new ThrowInvalidParamError('Parameter error: Failed to get method or data, ' +
         'method must be a string, data must be a rpc.Parcelable');
     }
 
     if (method === '' || data == null) {
-      console.log('Caller callCheck ' + method + ', ' + data);
+      hilog.sLogI(domainID, TAG,
+        'Caller callCheck ' + method + ', ' + data);
       return new ThrowInvalidParamError('Parameter error: method or data is empty, Please check it.');
     }
 
     if (this.releaseState === true) {
-      console.log('Caller callCheck this.callee release');
+      hilog.sLogI(domainID, TAG, 'Caller callCheck this.callee release');
       return new BusinessError(ERROR_CODE_CALLER_RELEASED);
     }
 
     if (this.__call_obj__.callee == null) {
-      console.log('Caller callCheck this.callee is nullptr');
+      hilog.sLogI(domainID, TAG, 'Caller callCheck this.callee is nullptr');
       return new BusinessError(ERROR_CODE_CLAAEE_INVALID);
     }
     return null;

frameworks/js/napi/dataUriUtils/data_uri_utils.js

@@ -12,11 +12,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
+
 const URI_SPLIT = '/';
 
 let dataUriUtils = {
   getId: (uri) => {
-    console.debug('DataUriUtils getId called.');
+    hilog.sLogD(domainID, TAG, 'DataUriUtils getId called.');
     if (typeof uri !== 'string') {
       return -1;
     }
@@ -31,7 +37,7 @@ let dataUriUtils = {
     return Number(ret);
   },
   updateId: (uri, id) => {
-    console.debug('DataUriUtils updateId called.');
+    hilog.sLogD(domainID, TAG, 'DataUriUtils updateId called.');
     if (typeof uri !== 'string' || typeof id !== 'number') {
       return uri;
     }
@@ -42,7 +48,7 @@ let dataUriUtils = {
     return ret + URI_SPLIT + id;
   },
   deleteId: (uri) => {
-    console.debug('DataUriUtils deleteId called.');
+    hilog.sLogD(domainID, TAG, 'DataUriUtils deleteId called.');
     if (typeof uri !== 'string') {
       return uri;
     }
@@ -57,7 +63,7 @@ let dataUriUtils = {
     return uri.substring(0, index);
   },
   attachId: (uri, id) => {
-    console.debug('DataUriUtils attachId called.');
+    hilog.sLogD(domainID, TAG, 'DataUriUtils attachId called.');
     if (typeof uri !== 'string' || typeof id !== 'number') {
       return uri;
     }

frameworks/js/napi/extension_ability/extension_ability.js

@@ -13,14 +13,19 @@
  * limitations under the License.
  */
 
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
+
 class ExtensionAbility {
 
   onConfigurationUpdate(config) {
-    console.log('onConfigurationUpdate');
+    hilog.sLogI(domainID, TAG, 'onConfigurationUpdate');
   }
 
   onMemoryLevel(level) {
-    console.log('onMemoryLevel');
+    hilog.sLogI(domainID, TAG, 'onMemoryLevel');
   }
 }
 

frameworks/js/napi/inner/napi_common/BUILD.gn

@@ -62,7 +62,7 @@ ohos_shared_library("napi_common") {
     "ipc:ipc_napi",
     "json:nlohmann_json_static",
     "libuv:uv",
-    "napi:ace_napi",    
+    "napi:ace_napi",
   ]
 
   public_external_deps = [

frameworks/js/napi/inner/napi_common/napi_common.h

@@ -22,5 +22,5 @@
 #include "napi_common_util.h"
 #include "napi_common_want.h"
 #include "napi_common_start_options.h"
-#include "./open_link/napi_common_open_link_options.h"
+#include "open_link/napi_common_open_link_options.h"
 #endif  // OHOS_ABILITY_RUNTIME_NAPI_COMMON_H

frameworks/js/napi/insight_intent/insight_intent_executor/insight_intent_executor.js

@@ -13,32 +13,37 @@
  * limitations under the License.
  */
 
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
+
 class InsightIntentExecutor {
   constructor() {}
 
   onExecuteInUIAbilityForegroundMode(name, param, pageLoader) {
-    console.log(`onExecuteInUIAbilityForegroundMode ${name}`);
+    hilog.sLogI(domainID, TAG, `onExecuteInUIAbilityForegroundMode ${name}`);
     return {
       'code': 0
     };
   }
 
   onExecuteInUIAbilityBackgroundMode(name, param) {
-    console.log(`onExecuteInUIAbilityForegroundMode ${name}`);
+    hilog.sLogI(domainID, TAG, `onExecuteInUIAbilityForegroundMode ${name}`);
     return {
       'code': 0
     };
   }
 
   onExecuteInUIExtensionAbility(name, param, pageLoader) {
-    console.log(`onExecuteInUIExtensionAbility ${name}`);
+    hilog.sLogI(domainID, TAG, `onExecuteInUIExtensionAbility ${name}`);
     return {
       'code': 0
     };
   }
 
   onExecuteInServiceExtensionAbility(name, param) {
-    console.log(`onExecuteInServiceExtensionAbility ${name}`);
+    hilog.sLogI(domainID, TAG, `onExecuteInServiceExtensionAbility ${name}`);
     return {
       'code': 0
     };

frameworks/js/napi/insight_intent_context/insight_intent_context.js

@@ -13,13 +13,18 @@
  * limitations under the License.
  */
 
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
+
 class InsightIntentContext {
   constructor(obj) {
     this.__context_impl__ = obj;
   }
 
   startAbility(want, callback) {
-    console.log('startAbility');
+    hilog.sLogI(domainID, TAG, 'startAbility');
     return this.__context_impl__.startAbility(want, callback);
   }
 }

frameworks/js/napi/photo_editor_extension_context/BUILD.gn

@@ -54,7 +54,7 @@ ohos_shared_library("photoeditorextensioncontext_napi") {
   ]
 
   external_deps = [ "napi:ace_napi" ]
-  
+
   relative_install_dir = "module/application"
   subsystem_name = "ability"
   part_name = "ability_runtime"

frameworks/js/napi/photo_editor_extension_context/photo_editor_extension_context.js

@@ -14,6 +14,10 @@
  */
 
 let UIExtensionContext = requireNapi('application.UIExtensionContext');
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
 
 export class PhotoEditorExtensionContext extends UIExtensionContext {
     constructor(obj) {
@@ -21,12 +25,12 @@ export class PhotoEditorExtensionContext extends UIExtensionContext {
     }
 
     saveEditedContentWithUri(uri, asyncCallback) {
-        console.log('saveEditedContent with uri: ' + uri);
+        hilog.sLogI(domainID, TAG, 'saveEditedContent with uri: ' + uri);
         return this.__context_impl__.saveEditedContentWithUri(uri, asyncCallback);
     }
 
     saveEditedContentWithImage(image, option, asyncCallback) {
-        console.log('saveEditedContent with image pixmap.');
+        hilog.sLogI(domainID, TAG, 'saveEditedContent with image pixmap.');
         return this.__context_impl__.saveEditedContentWithImage(image, option, asyncCallback);
     }
 }

frameworks/js/napi/service_extension_ability/service_extension_ability.js

@@ -14,26 +14,30 @@
  */
 
 let ExtensionAbility = requireNapi('app.ability.ExtensionAbility');
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
 
 class ServiceExtensionAbility extends ExtensionAbility {
   onCreate(want) {
-    console.log('onCreate, want:' + want.abilityName);
+    hilog.sLogI(domainID, TAG, 'onCreate, want:' + want.abilityName);
   }
 
   onRequest(want, startId) {
-    console.log('onRequest, want:' + want.abilityName + ', startId:' + startId);
+    hilog.sLogI(domainID, TAG, 'onRequest, want:' + want.abilityName + ', startId:' + startId);
   }
 
   onConnect(want) {
-    console.log('onConnect, want:' + want.abilityName);
+    hilog.sLogI(domainID, TAG, 'onConnect, want:' + want.abilityName);
   }
 
   onDisconnect(want) {
-    console.log('onDisconnect');
+    hilog.sLogI(domainID, TAG, 'onDisconnect');
   }
 
   onDestroy() {
-    console.log('onDestroy');
+    hilog.sLogI(domainID, TAG, 'onDestroy');
   }
 }
 

frameworks/js/napi/service_extension_context/service_extension_context.js

@@ -15,6 +15,10 @@
 
 let ExtensionContext = requireNapi('application.ExtensionContext');
 let Caller = requireNapi('application.Caller');
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
 
 const ERROR_CODE_INVALID_PARAM = 401;
 const ERROR_MSG_INVALID_PARAM = 'Invalid input parameter.';
@@ -31,82 +35,82 @@ class ServiceExtensionContext extends ExtensionContext {
   }
 
   startAbility(want, options, callback) {
-    console.log('startAbility');
+    hilog.sLogI(domainID, TAG, 'startAbility');
     return this.__context_impl__.startAbility(want, options, callback);
   }
 
   openLink(link, options) {
-    console.log('openLink');
+    hilog.sLogI(domainID, TAG, 'openLink');
     return this.__context_impl__.openLink(link, options);
   }
 
   startAbilityAsCaller(want, options, callback) {
-    console.log('startAbilityAsCaller');
+    hilog.sLogI(domainID, TAG, 'startAbilityAsCaller');
     return this.__context_impl__.startAbilityAsCaller(want, options, callback);
   }
 
   startRecentAbility(want, options, callback) {
-    console.log('startRecentAbility');
+    hilog.sLogI(domainID, TAG, 'startRecentAbility');
     return this.__context_impl__.startRecentAbility(want, options, callback);
   }
 
   connectServiceExtensionAbility(want, options) {
-    console.log('connectServiceExtensionAbility');
+    hilog.sLogI(domainID, TAG, 'connectServiceExtensionAbility');
     return this.__context_impl__.connectServiceExtensionAbility(want, options);
   }
 
   startAbilityWithAccount(want, accountId, options, callback) {
-    console.log('startAbilityWithAccount');
+    hilog.sLogI(domainID, TAG, 'startAbilityWithAccount');
     return this.__context_impl__.startAbilityWithAccount(want, accountId, options, callback);
   }
 
   startServiceExtensionAbility(want, callback) {
-    console.log('startServiceExtensionAbility');
+    hilog.sLogI(domainID, TAG, 'startServiceExtensionAbility');
     return this.__context_impl__.startServiceExtensionAbility(want, callback);
   }
 
   startUIServiceExtensionAbility(want, callback) {
-    console.log('startUIServiceExtensionAbility');
+    hilog.sLogI(domainID, TAG, 'startUIServiceExtensionAbility');
     return this.__context_impl__.startUIServiceExtensionAbility(want, callback);
   }
 
   startServiceExtensionAbilityWithAccount(want, accountId, callback) {
-    console.log('startServiceExtensionAbilityWithAccount');
+    hilog.sLogI(domainID, TAG, 'startServiceExtensionAbilityWithAccount');
     return this.__context_impl__.startServiceExtensionAbilityWithAccount(want, accountId, callback);
   }
 
   stopServiceExtensionAbility(want, callback) {
-    console.log('stopServiceExtensionAbility');
+    hilog.sLogI(domainID, TAG, 'stopServiceExtensionAbility');
     return this.__context_impl__.stopServiceExtensionAbility(want, callback);
   }
 
   stopServiceExtensionAbilityWithAccount(want, accountId, callback) {
-    console.log('stopServiceExtensionAbilityWithAccount');
+    hilog.sLogI(domainID, TAG, 'stopServiceExtensionAbilityWithAccount');
     return this.__context_impl__.stopServiceExtensionAbilityWithAccount(want, accountId, callback);
   }
 
   connectAbilityWithAccount(want, accountId, options) {
-    console.log('connectAbilityWithAccount');
+    hilog.sLogI(domainID, TAG, 'connectAbilityWithAccount');
     return this.__context_impl__.connectAbilityWithAccount(want, accountId, options);
   }
 
   connectServiceExtensionAbilityWithAccount(want, accountId, options) {
-    console.log('connectServiceExtensionAbilityWithAccount');
+    hilog.sLogI(domainID, TAG, 'connectServiceExtensionAbilityWithAccount');
     return this.__context_impl__.connectServiceExtensionAbilityWithAccount(want, accountId, options);
   }
 
   disconnectAbility(connection, callback) {
-    console.log('disconnectAbility');
+    hilog.sLogI(domainID, TAG, 'disconnectAbility');
     return this.__context_impl__.disconnectAbility(connection, callback);
   }
 
   disconnectServiceExtensionAbility(connection, callback) {
-    console.log('disconnectServiceExtensionAbility');
+    hilog.sLogI(domainID, TAG, 'disconnectServiceExtensionAbility');
     return this.__context_impl__.disconnectServiceExtensionAbility(connection, callback);
   }
 
   terminateSelf(callback) {
-    console.log('terminateSelf');
+    hilog.sLogI(domainID, TAG, 'terminateSelf');
     return this.__context_impl__.terminateSelf(callback);
   }
 
@@ -117,7 +121,7 @@ class ServiceExtensionContext extends ExtensionContext {
   startAbilityByCall(want) {
     return new Promise(async (resolve, reject) => {
       if (typeof want !== 'object' || want == null) {
-        console.log('ServiceExtensionContext::startAbilityByCall input param error');
+        hilog.sLogI(domainID, TAG, 'ServiceExtensionContext::startAbilityByCall input param error');
         reject(new ParamError());
         return;
       }
@@ -126,13 +130,13 @@ class ServiceExtensionContext extends ExtensionContext {
       try {
         callee = await this.__context_impl__.startAbilityByCall(want);
       } catch (error) {
-        console.log('ServiceExtensionContext::startAbilityByCall Obtain remoteObject failed');
+        hilog.sLogI(domainID, TAG, 'ServiceExtensionContext::startAbilityByCall Obtain remoteObject failed');
         reject(error);
         return;
       }
 
       resolve(new Caller(callee));
-      console.log('ServiceExtensionContext::startAbilityByCall success');
+      hilog.sLogI(domainID, TAG, 'ServiceExtensionContext::startAbilityByCall success');
       return;
     });
   }
@@ -140,7 +144,7 @@ class ServiceExtensionContext extends ExtensionContext {
   startAbilityByCallWithAccount(want, accountId) {
     return new Promise(async (resolve, reject) => {
       if (typeof want !== 'object' || want == null || typeof accountId !== 'number') {
-        console.log('ServiceExtensionContext::startAbilityByCall With accountId input param error');
+        hilog.sLogI(domainID, TAG, 'ServiceExtensionContext::startAbilityByCall With accountId input param error');
         reject(new ParamError());
         return;
       }
@@ -149,19 +153,19 @@ class ServiceExtensionContext extends ExtensionContext {
       try {
         callee = await this.__context_impl__.startAbilityByCall(want, accountId);
       } catch (error) {
-        console.log('ServiceExtensionContext::startAbilityByCall With accountId Obtain remoteObject failed');
+        hilog.sLogI(domainID, TAG, 'ServiceExtensionContext::startAbilityByCall With accountId Obtain remoteObject failed');
         reject(error);
         return;
       }
 
       resolve(new Caller(callee));
-      console.log('ServiceExtensionContext::startAbilityByCall With accountId success');
+      hilog.sLogI(domainID, TAG, 'ServiceExtensionContext::startAbilityByCall With accountId success');
       return;
     });
   }
 
   preStartMission(bundleName, moduleName, abilityName, startTime) {
-    console.log('preStartMission');
+    hilog.sLogI(domainID, TAG, 'preStartMission');
     return this.__context_impl__.preStartMission(bundleName, moduleName, abilityName, startTime);
   }
 }

frameworks/js/napi/ui_extension_ability/ui_extension_ability.js

@@ -14,18 +14,22 @@
  */
 
 let ExtensionAbility = requireNapi('app.ability.ExtensionAbility');
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
 
 class UIExtensionAbility extends ExtensionAbility {
   onCreate(launchParam, want) {
-    console.log('onCreate');
+    hilog.sLogI(domainID, TAG, 'onCreate');
   }
 
   onRequest(want, startId) {
-    console.log('onRequest, want:' + want.abilityName + ', startId:' + startId);
+    hilog.sLogI(domainID, TAG, 'onRequest, want:' + want.abilityName + ', startId:' + startId);
   }
 
   onDestroy() {
-    console.log('onDestroy');
+    hilog.sLogI(domainID, TAG, 'onDestroy');
   }
 }
 

frameworks/js/napi/ui_extension_context/ui_extension_context.js

@@ -14,6 +14,10 @@
  */
 
 let ExtensionContext = requireNapi('application.ExtensionContext');
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
 
 const ERROR_CODE_INVALID_PARAM = 401;
 const ERROR_MSG_INVALID_PARAM = 'Invalid input parameter.';
@@ -30,12 +34,12 @@ class UIExtensionContext extends ExtensionContext {
   }
 
   startAbility(want, options, callback) {
-    console.log('startAbility');
+    hilog.sLogI(domainID, TAG, 'startAbility');
     return this.__context_impl__.startAbility(want, options, callback);
   }
 
   startUIServiceExtensionAbility(want, callback) {
-    console.log('startUIServiceExtensionAbility');
+    hilog.sLogI(domainID, TAG, 'startUIServiceExtensionAbility');
     return this.__context_impl__.startUIServiceExtensionAbility(want, callback);
   }
 
@@ -48,27 +52,27 @@ class UIExtensionContext extends ExtensionContext {
   }
 
   openLink(link, options, callback) {
-    console.log('openLink');
+    hilog.sLogI(domainID, TAG, 'openLink');
     return this.__context_impl__.openLink(link, options, callback);
   }
 
   terminateSelf(callback) {
-    console.log('terminateSelf');
+    hilog.sLogI(domainID, TAG, 'terminateSelf');
     return this.__context_impl__.terminateSelf(callback);
   }
 
   startAbilityForResult(want, options, callback) {
-    console.log('startAbilityForResult');
+    hilog.sLogI(domainID, TAG, 'startAbilityForResult');
     return this.__context_impl__.startAbilityForResult(want, options, callback);
   }
 
   startAbilityForResultAsCaller(want, options, callback) {
-    console.log('startAbilityForResultAsCaller');
+    hilog.sLogI(domainID, TAG, 'startAbilityForResultAsCaller');
     return this.__context_impl__.startAbilityForResultAsCaller(want, options, callback);
   }
 
   terminateSelfWithResult(abilityResult, callback) {
-    console.log('terminateSelfWithResult');
+    hilog.sLogI(domainID, TAG, 'terminateSelfWithResult');
     return this.__context_impl__.terminateSelfWithResult(abilityResult, callback);
   }
 

frameworks/js/napi/ui_service_extension_ability/ui_service_extension_ability.js

@@ -14,38 +14,42 @@
  */
 
 let ExtensionAbility = requireNapi('app.ability.ExtensionAbility');
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
 
 class UIServiceExtensionAbility extends ExtensionAbility {
   onCreate(want) {
-    console.log('onCreate, want:' + want.abilityName);
+    hilog.sLogI(domainID, TAG, 'onCreate, want:' + want.abilityName);
   }
 
   onRequest(want, startId) {
-    console.log('onRequest, want:' + want.abilityName + ', startId:' + startId);
+    hilog.sLogI(domainID, TAG, 'onRequest, want:' + want.abilityName + ', startId:' + startId);
   }
 
   onConnect(want, proxy) {
-    console.log('onConnect, want:' + want.abilityName + '');
+    hilog.sLogI(domainID, TAG, 'onConnect, want:' + want.abilityName + '');
   }
 
   onDisconnect(want, proxy) {
-    console.log('onDisconnect');
+    hilog.sLogI(domainID, TAG, 'onDisconnect');
   }
 
   onWindowWillCreate(config) {
-    console.log('onWindowStageWillCreate');
+    hilog.sLogI(domainID, TAG, 'onWindowStageWillCreate');
   }
 
   onWindowDidCreate(window) {
-    console.log('onWindowStageDidCreate');
+    hilog.sLogI(domainID, TAG, 'onWindowStageDidCreate');
   }
 
   onData(data) {
-    console.log('onData');
+    hilog.sLogI(domainID, TAG, 'onData');
   }
 
   onDestroy() {
-    console.log('onDestroy');
+    hilog.sLogI(domainID, TAG, 'onDestroy');
   }
 }
 

frameworks/js/napi/ui_service_extension_context/BUILD.gn

@@ -54,7 +54,7 @@ ohos_shared_library("uiserviceextensioncontext_napi") {
   ]
 
   external_deps = [ "napi:ace_napi" ]
-  
+
   relative_install_dir = "module/application"
   subsystem_name = "ability"
   part_name = "ability_runtime"

frameworks/js/napi/ui_service_extension_context/ui_service_extension_context.js

@@ -14,6 +14,10 @@
  */
 
 let ExtensionContext = requireNapi('application.ExtensionContext');
+let hilog = requireNapi('hilog');
+
+let domainID = 0xD001320;
+let TAG = 'JSENV';
 
 class UIServiceExtensionContext extends ExtensionContext {
   constructor(obj) {
@@ -21,27 +25,27 @@ class UIServiceExtensionContext extends ExtensionContext {
   }
 
   startAbility(want, options) {
-    console.log('startAbility');
+    hilog.sLogI(domainID, TAG, 'startAbility');
     return this.__context_impl__.startAbility(want, options);
   }
 
   terminateSelf() {
-    console.log('terminateSelf');
+    hilog.sLogI(domainID, TAG, 'terminateSelf');
     return this.__context_impl__.terminateSelf();
   }
 
   startAbilityByType(type, wantParam, abilityStartCallback) {
-    console.log('startAbilityByType');
+    hilog.sLogI(domainID, TAG, 'startAbilityByType');
     return this.__context_impl__.startAbilityByType(type, wantParam, abilityStartCallback);
   }
 
   connectServiceExtensionAbility(want, options) {
-    console.log('connectServiceExtensionAbility');
+    hilog.sLogI(domainID, TAG, 'connectServiceExtensionAbility');
     return this.__context_impl__.connectServiceExtensionAbility(want, options);
   }
 
   disconnectServiceExtensionAbility(connection, callback) {
-      console.log('disconnectServiceExtensionAbility');
+      hilog.sLogI(domainID, TAG, 'disconnectServiceExtensionAbility');
       return this.__context_impl__.disconnectServiceExtensionAbility(connection, callback);
   }
 }

frameworks/js/napi/wantagent/BUILD.gn

@@ -18,6 +18,7 @@ ohos_shared_library("wantagent") {
   include_dirs = [
     "${ability_runtime_services_path}/common/include",
     "${ability_runtime_path}/interfaces/kits/native/appkit/ability_runtime",
+    "${ability_runtime_services_path}/abilitymgr/include/utils",
     "${ability_runtime_services_path}/abilitymgr/include",
     "./",
   ]
@@ -33,6 +34,7 @@ ohos_shared_library("wantagent") {
     "${ability_runtime_innerkits_path}/runtime:runtime",
     "${ability_runtime_innerkits_path}/wantagent:wantagent_innerkits",
     "${ability_runtime_napi_path}/inner/napi_common:napi_common",
+    "${ability_runtime_native_path}/ability/native:ability_business_error",
     "${ability_runtime_native_path}/ability/native:abilitykit_native",
     "${ability_runtime_native_path}/appkit:app_context",
   ]

frameworks/js/napi/wantagent/ability_want_agent/BUILD.gn

@@ -18,6 +18,7 @@ ohos_shared_library("wantagent_napi") {
   include_dirs = [
     "${ability_runtime_services_path}/common/include",
     "${ability_runtime_path}/interfaces/kits/native/appkit/ability_runtime",
+    "${ability_runtime_services_path}/abilitymgr/include/utils",
     "${ability_runtime_services_path}/abilitymgr/include",
     "./",
     "../",
@@ -34,6 +35,7 @@ ohos_shared_library("wantagent_napi") {
     "${ability_runtime_innerkits_path}/runtime:runtime",
     "${ability_runtime_innerkits_path}/wantagent:wantagent_innerkits",
     "${ability_runtime_napi_path}/inner/napi_common:napi_common",
+    "${ability_runtime_native_path}/ability/native:ability_business_error",
     "${ability_runtime_native_path}/ability/native:abilitykit_native",
     "${ability_runtime_native_path}/appkit:app_context",
   ]

frameworks/js/napi/wantagent/napi_want_agent.cpp

@@ -160,7 +160,7 @@ auto OnSendFinishedUvAfterWorkCallback = [](uv_work_t* work, int status) {
     napi_set_named_property(dataWorkerData->env, objValueSecond, "want",
         CreateJsWant(dataWorkerData->env, dataWorkerData->want));
     napi_set_named_property(dataWorkerData->env, objValueSecond, "finalCode",
-        CreateJsValue(dataWorkerData->env, dataWorkerData->resultCode));
+        CreateJsValue(dataWorkerData->env, GetJsErrorCodeByNativeError(dataWorkerData->resultCode)));
     napi_set_named_property(dataWorkerData->env, objValueSecond, "finalData",
         CreateJsValue(dataWorkerData->env, dataWorkerData->resultData));
     napi_set_named_property(dataWorkerData->env, objValueSecond, "extraInfo",

frameworks/native/ability/ability_runtime/ability_context_impl.cpp

@@ -677,7 +677,7 @@ void AbilityContextImpl::RegisterAbilityCallback(std::weak_ptr<AppExecFwk::IAbil
     abilityCallback_ = abilityCallback;
 }
 
-ErrCode AbilityContextImpl::RequestDialogService(napi_env env, AAFwk::Want &want, RequestDialogResultTask &&task)
+void AbilityContextImpl::SetWindowRectangleParams(AAFwk::Want &want)
 {
     want.SetParam(RequestConstants::REQUEST_TOKEN_KEY, token_);
 #ifdef SUPPORT_SCREEN
@@ -691,6 +691,11 @@ ErrCode AbilityContextImpl::RequestDialogService(napi_env env, AAFwk::Want &want
     want.SetParam(RequestConstants::WINDOW_RECTANGLE_WIDTH_KEY, width);
     want.SetParam(RequestConstants::WINDOW_RECTANGLE_HEIGHT_KEY, height);
 #endif // SUPPORT_SCREEN
+}
+
+ErrCode AbilityContextImpl::RequestDialogService(napi_env env, AAFwk::Want &want, RequestDialogResultTask &&task)
+{
+    SetWindowRectangleParams(want);
     auto resultTask =
         [env, outTask = std::move(task)](int32_t resultCode, const AAFwk::Want &resultWant) {
         auto retData = new (std::nothrow) RequestResult();
@@ -740,17 +745,7 @@ ErrCode AbilityContextImpl::RequestDialogService(napi_env env, AAFwk::Want &want
 
 ErrCode AbilityContextImpl::RequestDialogService(AAFwk::Want &want, RequestDialogResultTask &&task)
 {
-    want.SetParam(RequestConstants::REQUEST_TOKEN_KEY, token_);
-    int32_t left;
-    int32_t top;
-    int32_t width;
-    int32_t height;
-    GetWindowRect(left, top, width, height);
-    want.SetParam(RequestConstants::WINDOW_RECTANGLE_LEFT_KEY, left);
-    want.SetParam(RequestConstants::WINDOW_RECTANGLE_TOP_KEY, top);
-    want.SetParam(RequestConstants::WINDOW_RECTANGLE_WIDTH_KEY, width);
-    want.SetParam(RequestConstants::WINDOW_RECTANGLE_HEIGHT_KEY, height);
-
+    SetWindowRectangleParams(want);
     sptr<IRemoteObject> remoteObject = sptr<DialogRequestCallbackImpl>::MakeSptr(std::move(task));
     want.SetParam(RequestConstants::REQUEST_CALLBACK_KEY, remoteObject);
 
@@ -772,6 +767,12 @@ void AbilityContextImpl::RequestDialogResultJSThreadWorker(uv_work_t* work, int
         TAG_LOGE(AAFwkTag::CONTEXT, "null work");
         return;
     }
+    if (work->data == nullptr) {
+        TAG_LOGE(AAFwkTag::CONTEXT, "null work data");
+        delete work;
+        work = nullptr;
+        return;
+    }
     RequestResult* retCB = static_cast<RequestResult*>(work->data);
     if (retCB == nullptr) {
         TAG_LOGE(AAFwkTag::CONTEXT, "null retCB");

frameworks/native/ability/native/BUILD.gn

@@ -34,6 +34,7 @@ config("ability_config") {
     "${ability_runtime_path}/interfaces/kits/native/appkit/app",
     "${ability_runtime_innerkits_path}/app_manager/include/appmgr",
     "${ability_runtime_innerkits_path}/uri/include",
+    "${ability_runtime_services_path}/abilitymgr/include/utils",
     "${ability_runtime_services_path}/abilitymgr/include",
     "${ability_runtime_path}/interfaces/kits/native/appkit/ability_runtime/app",
     "${ability_runtime_innerkits_path}/ability_manager/include/continuation",
@@ -130,6 +131,7 @@ ohos_shared_library("abilitykit_utils") {
     "${ability_runtime_path}/interfaces/kits/native/appkit/ability_runtime/app",
     "${ability_runtime_innerkits_path}/ability_manager/include",
     "${ability_runtime_innerkits_path}/wantagent/include",
+    "${ability_runtime_services_path}/abilitymgr/include/utils",
     "${ability_runtime_services_path}/abilitymgr/include",
     "${ability_runtime_services_path}/common/include",
   ]
@@ -205,6 +207,7 @@ ohos_shared_library("configuration_helper") {
     "${ability_runtime_path}/interfaces/kits/native/appkit/ability_runtime/app",
     "${ability_runtime_innerkits_path}/ability_manager/include",
     "${ability_runtime_innerkits_path}/wantagent/include",
+    "${ability_runtime_services_path}/abilitymgr/include/utils",
     "${ability_runtime_services_path}/abilitymgr/include",
     "${ability_runtime_services_path}/common/include",
   ]
@@ -570,6 +573,7 @@ config("uiability_config") {
     "${ability_runtime_path}/interfaces/kits/native/ability/native/recovery/",
     "${ability_runtime_path}/interfaces/kits/native/appkit/ability_runtime/app",
     "${ability_runtime_path}/interfaces/kits/native/appkit/app",
+    "${ability_runtime_services_path}/abilitymgr/include/utils",
     "${ability_runtime_services_path}/abilitymgr/include",
   ]
 
@@ -1062,6 +1066,7 @@ ohos_shared_library("ui_service_extension_module") {
     "${ability_runtime_path}/interfaces/kits/native/ability/native/recovery/",
     "${ability_runtime_innerkits_path}/app_manager/include/appmgr",
     "${ability_runtime_innerkits_path}/uri/include",
+    "${ability_runtime_services_path}/abilitymgr/include/utils",
     "${ability_runtime_services_path}/abilitymgr/include",
     "${ability_runtime_innerkits_path}/ability_manager/include/continuation",
     "${ability_runtime_innerkits_path}/ability_manager/include",
@@ -1715,6 +1720,7 @@ config("embedded_ui_extension_module_config") {
     "${ability_runtime_path}/interfaces/kits/native/appkit/app",
     "${ability_runtime_innerkits_path}/app_manager/include/appmgr",
     "${ability_runtime_innerkits_path}/uri/include",
+    "${ability_runtime_services_path}/abilitymgr/include/utils",
     "${ability_runtime_services_path}/abilitymgr/include",
     "${ability_runtime_path}/interfaces/kits/native/appkit/ability_runtime/app",
     "${ability_runtime_path}/interfaces/kits/native/appkit/app",

frameworks/native/ability/native/ability.cpp

@@ -870,7 +870,7 @@ void Ability::PostTask(std::function<void()> task, long delayTime)
 
 int32_t Ability::OnContinue(WantParams &wantParams)
 {
-    return ContinuationManager::OnContinueResult::REJECT;
+    return ContinuationManager::OnContinueResult::ON_CONTINUE_ERR;
 }
 
 void Ability::ContinueAbilityWithStack(const std::string &deviceId, uint32_t versionCode)

frameworks/native/ability/native/ability_context.cpp

@@ -132,7 +132,7 @@ std::string AbilityContext::GetCallingBundle()
     return callingBundleName_;
 }
 
-std::shared_ptr<ElementName> AbilityContext::GetElementName()
+std::shared_ptr<AppExecFwk::ElementName> AbilityContext::GetElementName()
 {
     TAG_LOGD(AAFwkTag::CONTEXT, "called");
     std::shared_ptr<AbilityInfo> info = GetAbilityInfo();
@@ -141,11 +141,8 @@ std::shared_ptr<ElementName> AbilityContext::GetElementName()
         return nullptr;
     }
 
-    std::shared_ptr<ElementName> elementName = std::make_shared<ElementName>();
-    elementName->SetAbilityName(info->name);
-    elementName->SetBundleName(info->bundleName);
-    elementName->SetDeviceID(info->deviceId);
-    elementName->SetModuleName(info->moduleName);
+    std::shared_ptr<ElementName> elementName =
+        std::make_shared<ElementName>(info->deviceId, info->bundleName, info->name, info->moduleName);
     TAG_LOGD(AAFwkTag::CONTEXT, "end");
     return elementName;
 }
@@ -153,11 +150,8 @@ std::shared_ptr<ElementName> AbilityContext::GetElementName()
 std::shared_ptr<ElementName> AbilityContext::GetCallingAbility()
 {
     TAG_LOGD(AAFwkTag::CONTEXT, "called");
-    std::shared_ptr<ElementName> elementName = std::make_shared<ElementName>();
-    elementName->SetAbilityName(callingAbilityName_);
-    elementName->SetBundleName(callingBundleName_);
-    elementName->SetDeviceID(callingDeviceId_);
-    elementName->SetModuleName(callingModuleName_);
+    std::shared_ptr<ElementName> elementName = std::make_shared<ElementName>(
+            callingDeviceId_, callingBundleName_, callingAbilityName_, callingModuleName_);
     TAG_LOGD(AAFwkTag::CONTEXT, "end");
     return elementName;
 }

frameworks/native/ability/native/ability_impl.cpp

@@ -640,6 +640,7 @@ void AbilityImpl::WindowLifeCycleImpl::AfterForeground()
             AbilityLifeCycleState::ABILITY_STATE_FOREGROUND_NEW, restoreData);
         if (ret == ERR_OK) {
             FreezeUtil::GetInstance().DeleteLifecycleEvent(flow);
+            FreezeUtil::GetInstance().DeleteAppLifecycleEvent(0);
         }
     }
 }
@@ -662,6 +663,7 @@ void AbilityImpl::WindowLifeCycleImpl::AfterBackground()
         AbilityLifeCycleState::ABILITY_STATE_BACKGROUND_NEW, restoreData);
     if (ret == ERR_OK) {
         FreezeUtil::GetInstance().DeleteLifecycleEvent(flow);
+        FreezeUtil::GetInstance().DeleteAppLifecycleEvent(0);
     }
 }
 

frameworks/native/ability/native/ability_runtime/cj_ability_object.cpp

@@ -210,7 +210,7 @@ int32_t CJAbilityObject::OnContinue(AAFwk::WantParams& wantParams) const
 {
     if (g_cjAbilityFuncs == nullptr) {
         TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityFunc");
-        return ContinuationManager::OnContinueResult::REJECT;
+        return ContinuationManager::OnContinueResult::ON_CONTINUE_ERR;
     }
     return 0;
 }

frameworks/native/ability/native/ability_runtime/cj_ui_ability.cpp

@@ -797,11 +797,12 @@ bool CJUIAbility::GetInsightIntentExecutorInfo(const Want &want,
 }
 #endif
 #endif
-int32_t CJUIAbility::OnContinue(WantParams &wantParams)
+int32_t CJUIAbility::OnContinue(WantParams &wantParams, bool &isAsyncOnContinue,
+    const AppExecFwk::AbilityInfo &abilityInfo)
 {
     if (!cjAbilityObj_) {
         TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj_");
-        return AppExecFwk::ContinuationManagerStage::OnContinueResult::REJECT;
+        return AppExecFwk::ContinuationManagerStage::OnContinueResult::ON_CONTINUE_ERR;
     }
     auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
     if (applicationContext != nullptr) {

frameworks/native/ability/native/ability_runtime/js_ability.cpp

@@ -754,19 +754,19 @@ int32_t JsAbility::OnContinue(WantParams &wantParams)
     auto env = jsRuntime_.GetNapiEnv();
     if (jsAbilityObj_ == nullptr) {
         TAG_LOGE(AAFwkTag::ABILITY, "AbilityStage object");
-        return AppExecFwk::ContinuationManager::OnContinueResult::REJECT;
+        return AppExecFwk::ContinuationManager::OnContinueResult::ON_CONTINUE_ERR;
     }
     napi_value obj = jsAbilityObj_->GetNapiValue();
     if (!CheckTypeForNapiValue(env, obj, napi_object)) {
         TAG_LOGE(AAFwkTag::ABILITY, "Ability object");
-        return AppExecFwk::ContinuationManager::OnContinueResult::REJECT;
+        return AppExecFwk::ContinuationManager::OnContinueResult::ON_CONTINUE_ERR;
     }
 
     napi_value methodOnCreate = nullptr;
     napi_get_named_property(env, obj, "onContinue", &methodOnCreate);
     if (methodOnCreate == nullptr) {
         TAG_LOGE(AAFwkTag::ABILITY, "get 'onContinue'");
-        return AppExecFwk::ContinuationManager::OnContinueResult::REJECT;
+        return AppExecFwk::ContinuationManager::OnContinueResult::ON_CONTINUE_ERR;
     }
 
     napi_value jsWantParams = OHOS::AppExecFwk::WrapWantParams(env, wantParams);
@@ -778,7 +778,7 @@ int32_t JsAbility::OnContinue(WantParams &wantParams)
     int32_t numberResult = 0;
     if (!ConvertFromJsValue(env, result, numberResult)) {
         TAG_LOGE(AAFwkTag::ABILITY, "'onContinue' not implemented");
-        return AppExecFwk::ContinuationManager::OnContinueResult::REJECT;
+        return AppExecFwk::ContinuationManager::OnContinueResult::ON_CONTINUE_ERR;
     }
 
     auto applicationContext = AbilityRuntime::Context::GetApplicationContext();

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

@@ -2046,6 +2046,58 @@ napi_value CreateJsAbilityContext(napi_env env, std::shared_ptr<AbilityContext>
     return object;
 }
 
+napi_value AttachJsUIAbilityContext(napi_env env, void *value, void *hint)
+{
+    TAG_LOGD(AAFwkTag::CONTEXT, "attach uiability context");
+    if (env == nullptr || value == nullptr) {
+        TAG_LOGW(AAFwkTag::CONTEXT, "invalid params");
+        return nullptr;
+    }
+    auto ptr = reinterpret_cast<std::weak_ptr<AbilityContext> *>(value)->lock();
+    if (ptr == nullptr) {
+        TAG_LOGW(AAFwkTag::CONTEXT, "invalid context");
+        return nullptr;
+    }
+
+    auto object = CreateJsAbilityContext(env, ptr);
+    if (object == nullptr) {
+        TAG_LOGW(AAFwkTag::CONTEXT, "null ability object");
+        return nullptr;
+    }
+    auto systemModule = JsRuntime::LoadSystemModuleByEngine(env, "application.AbilityContext", &object, 1);
+    if (systemModule == nullptr) {
+        TAG_LOGW(AAFwkTag::CONTEXT, "load uiability context failed");
+        return nullptr;
+    }
+    auto contextObj = systemModule->GetNapiValue();
+    if (!CheckTypeForNapiValue(env, contextObj, napi_object)) {
+        TAG_LOGW(AAFwkTag::CONTEXT, "not napi object");
+        return nullptr;
+    }
+
+    auto status = napi_coerce_to_native_binding_object(
+        env, contextObj, DetachCallbackFunc, AttachJsUIAbilityContext, value, nullptr);
+    if (status != napi_ok) {
+        TAG_LOGW(AAFwkTag::CONTEXT, "coerce ability context failed: %{public}d", status);
+        return nullptr;
+    }
+
+    auto workContext = new (std::nothrow) std::weak_ptr<AbilityContext>(ptr);
+    status = napi_wrap(env, contextObj, workContext,
+        [](napi_env, void *data, void*) {
+            TAG_LOGD(AAFwkTag::CONTEXT, "finalizer for weak_ptr ui ability context");
+            delete static_cast<std::weak_ptr<AbilityContext> *>(data);
+        },
+        nullptr, nullptr);
+    if (status != napi_ok) {
+        TAG_LOGW(AAFwkTag::CONTEXT, "wrap ability context failed: %{public}d", status);
+        delete workContext;
+        return nullptr;
+    }
+
+    return contextObj;
+}
+
 JSAbilityConnection::JSAbilityConnection(napi_env env) : env_(env) {}
 
 JSAbilityConnection::~JSAbilityConnection()

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

@@ -20,6 +20,7 @@
 
 #include "ability_business_error.h"
 #include "ability_delegator_registry.h"
+#include "ability_manager_client.h"
 #include "ability_recovery.h"
 #include "ability_start_setting.h"
 #include "app_recovery.h"
@@ -211,15 +212,23 @@ void JsUIAbility::Init(std::shared_ptr<AppExecFwk::AbilityLocalRecord> record,
     SetAbilityContext(abilityInfo, record->GetWant(), moduleName, srcPath);
 }
 
+void JsUIAbility::UpdateAbilityObj(std::shared_ptr<AbilityInfo> abilityInfo,
+    const std::string &moduleName, const std::string &srcPath)
+{
+    std::string key = moduleName + "::" + srcPath;
+    std::unique_ptr<NativeReference> moduleObj = nullptr;
+    jsAbilityObj_ = jsRuntime_.PopPreloadObj(key, moduleObj) ? std::move(moduleObj) : jsRuntime_.LoadModule(
+        moduleName, srcPath, abilityInfo->hapPath, abilityInfo->compileMode == AppExecFwk::CompileMode::ES_MODULE,
+        false, abilityInfo->srcEntrance);
+}
+
 void JsUIAbility::SetAbilityContext(std::shared_ptr<AbilityInfo> abilityInfo,
     std::shared_ptr<AAFwk::Want> want, const std::string &moduleName, const std::string &srcPath)
 {
     TAG_LOGI(AAFwkTag::UIABILITY, "called");
     HandleScope handleScope(jsRuntime_);
     auto env = jsRuntime_.GetNapiEnv();
-    jsAbilityObj_ = jsRuntime_.LoadModule(
-        moduleName, srcPath, abilityInfo->hapPath, abilityInfo->compileMode == AppExecFwk::CompileMode::ES_MODULE,
-        false, abilityInfo->srcEntrance);
+    UpdateAbilityObj(abilityInfo, moduleName, srcPath);
     if (jsAbilityObj_ == nullptr || abilityContext_ == nullptr || want == nullptr) {
         TAG_LOGE(AAFwkTag::UIABILITY, "null jsAbilityObj_ or abilityContext_ or want");
         return;
@@ -256,10 +265,11 @@ void JsUIAbility::SetAbilityContext(std::shared_ptr<AbilityInfo> abilityInfo,
         abilityRecovery_->SetJsAbility(reinterpret_cast<uintptr_t>(workContext));
     }
     napi_wrap(env, contextObj, workContext,
-        [](napi_env, void *data, void *) {
+        [](napi_env, void *data, void *hint) {
             TAG_LOGD(AAFwkTag::UIABILITY, "finalizer for weak_ptr ability context is called");
             delete static_cast<std::weak_ptr<AbilityRuntime::AbilityContext> *>(data);
-        }, nullptr, nullptr);
+            delete static_cast<std::weak_ptr<int32_t> *>(hint);
+        }, workScreenMode, nullptr);
     TAG_LOGI(AAFwkTag::UIABILITY, "End");
 }
 
@@ -841,7 +851,7 @@ void JsUIAbility::DoOnForegroundForSceneIsNull(const Want &want)
             displayId = strtol(strDisplayId.c_str(), nullptr, BASE_DISPLAY_ID_NUM);
             TAG_LOGD(AAFwkTag::UIABILITY, "displayId: %{public}d", displayId);
         } else {
-            TAG_LOGE(AAFwkTag::UIABILITY, "formatRegex: [%{public}s] failed", strDisplayId.c_str());
+            TAG_LOGW(AAFwkTag::UIABILITY, "formatRegex: [%{public}s] failed", strDisplayId.c_str());
         }
     }
     auto option = GetWindowOption(want);
@@ -857,6 +867,9 @@ void JsUIAbility::DoOnForegroundForSceneIsNull(const Want &want)
     }
     if (ret != Rosen::WMError::WM_OK) {
         TAG_LOGE(AAFwkTag::UIABILITY, "init window scene failed");
+        FreezeUtil::LifecycleFlow flow = { AbilityContext::token_, FreezeUtil::TimeoutState::FOREGROUND };
+        FreezeUtil::GetInstance().AppendLifecycleEvent(flow,
+            std::string("ERROR JsUIAbility::DoOnForegroundForSceneIsNull: ") + std::to_string(static_cast<int>(ret)));
         return;
     }
 
@@ -895,8 +908,12 @@ void JsUIAbility::RequestFocus(const Want &want)
 void JsUIAbility::ContinuationRestore(const Want &want)
 {
     TAG_LOGD(AAFwkTag::UIABILITY, "called");
-    if (!IsRestoredInContinuation() || scene_ == nullptr) {
-        TAG_LOGE(AAFwkTag::UIABILITY, "is not in continuation or null scene_");
+    if (!IsRestoredInContinuation()) {
+        TAG_LOGW(AAFwkTag::UIABILITY, "not in continuation");
+        return;
+    }
+    if (scene_ == nullptr) {
+        TAG_LOGE(AAFwkTag::UIABILITY, "null scene_");
         return;
     }
     RestorePageStack(want);
@@ -1067,41 +1084,94 @@ bool JsUIAbility::GetInsightIntentExecutorInfo(const Want &want,
 }
 #endif
 
-int32_t JsUIAbility::OnContinue(WantParams &wantParams)
+int32_t JsUIAbility::OnContinue(WantParams &wantParams, bool &isAsyncOnContinue,
+    const AppExecFwk::AbilityInfo &abilityInfo)
 {
     TAG_LOGI(AAFwkTag::UIABILITY, "called");
     HandleScope handleScope(jsRuntime_);
     auto env = jsRuntime_.GetNapiEnv();
     if (jsAbilityObj_ == nullptr) {
         TAG_LOGE(AAFwkTag::UIABILITY, "null jsAbilityObj_");
-        return AppExecFwk::ContinuationManagerStage::OnContinueResult::REJECT;
+        return AppExecFwk::ContinuationManagerStage::OnContinueResult::ON_CONTINUE_ERR;
     }
     napi_value obj = jsAbilityObj_->GetNapiValue();
     if (!CheckTypeForNapiValue(env, obj, napi_object)) {
         TAG_LOGE(AAFwkTag::UIABILITY, "failed get ability");
-        return AppExecFwk::ContinuationManagerStage::OnContinueResult::REJECT;
+        return AppExecFwk::ContinuationManagerStage::OnContinueResult::ON_CONTINUE_ERR;
     }
-
     auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
     if (applicationContext != nullptr) {
         applicationContext->DispatchOnAbilityWillContinue(jsAbilityObj_);
     }
-
     napi_value jsWantParams = OHOS::AppExecFwk::WrapWantParams(env, wantParams);
     napi_value result = CallObjectMethod("onContinue", &jsWantParams, 1, true);
     int32_t onContinueRes = 0;
     if (!CheckPromise(result)) {
-        if (!ConvertFromJsValue(env, result, onContinueRes)) {
-            TAG_LOGE(AAFwkTag::UIABILITY, "'onContinue' is not implemented");
-            return AppExecFwk::ContinuationManagerStage::OnContinueResult::REJECT;
-        }
-    } else {
-        if (!CallPromise(result, onContinueRes)) {
-            TAG_LOGE(AAFwkTag::UIABILITY, "call promise failed");
-            return AppExecFwk::ContinuationManagerStage::OnContinueResult::REJECT;
+        return OnContinueSyncCB(result, wantParams, jsWantParams);
+    }
+    auto *callbackInfo = AppExecFwk::AbilityTransactionCallbackInfo<int32_t>::Create();
+    if (callbackInfo == nullptr) {
+        TAG_LOGE(AAFwkTag::UIABILITY, "create AbilityTransactionCallbackInfo failed");
+        return OnContinueSyncCB(result, wantParams, jsWantParams);
+    }
+    std::weak_ptr<UIAbility> weakPtr = shared_from_this();
+    auto asyncCallback = [thisJsWantParams = jsWantParams, abilityWeakPtr = weakPtr, abilityInfo](int32_t status) {
+        auto ability = abilityWeakPtr.lock();
+        if (ability == nullptr) {
+            TAG_LOGE(AAFwkTag::UIABILITY, "null ability");
+            return;
         }
+        ability->OnContinueAsyncCB(thisJsWantParams, status, abilityInfo);
+    };
+
+    callbackInfo->Push(asyncCallback);
+    if (!CallPromise(result, callbackInfo)) {
+        TAG_LOGE(AAFwkTag::UIABILITY, "call promise failed");
+        return OnContinueSyncCB(result, wantParams, jsWantParams);
+    }
+    isAsyncOnContinue = true;
+    TAG_LOGI(AAFwkTag::UIABILITY, "end");
+    return onContinueRes;
+}
+
+int32_t JsUIAbility::OnContinueAsyncCB(napi_value jsWantParams, int32_t status,
+    const AppExecFwk::AbilityInfo &abilityInfo)
+{
+    TAG_LOGI(AAFwkTag::UIABILITY, "call");
+    HandleScope handleScope(jsRuntime_);
+    auto env = jsRuntime_.GetNapiEnv();
+    WantParams wantParams;
+    OHOS::AppExecFwk::UnwrapWantParams(env, jsWantParams, wantParams);
+    auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
+    if (applicationContext != nullptr) {
+        applicationContext->DispatchOnAbilityContinue(jsAbilityObj_);
+    }
+
+    Want want;
+    want.SetParams(wantParams);
+    want.AddFlags(want.FLAG_ABILITY_CONTINUATION);
+    want.SetElementName(abilityInfo.deviceId, abilityInfo.bundleName, abilityInfo.name,
+        abilityInfo.moduleName);
+    int result = AAFwk::AbilityManagerClient::GetInstance()->StartContinuation(want, token_, status);
+    if (result != ERR_OK) {
+        TAG_LOGE(AAFwkTag::CONTINUATION, "StartContinuation failed, result: %{public}d", result);
+    }
+    TAG_LOGI(AAFwkTag::UIABILITY, "end");
+    return result;
+}
+
+int32_t JsUIAbility::OnContinueSyncCB(napi_value result, WantParams &wantParams, napi_value jsWantParams)
+{
+    TAG_LOGI(AAFwkTag::UIABILITY, "call");
+    HandleScope handleScope(jsRuntime_);
+    auto env = jsRuntime_.GetNapiEnv();
+    int32_t onContinueRes = 0;
+    if (!ConvertFromJsValue(env, result, onContinueRes)) {
+        TAG_LOGE(AAFwkTag::UIABILITY, "'onContinue' is not implemented");
+        return AppExecFwk::ContinuationManagerStage::OnContinueResult::ON_CONTINUE_ERR;
     }
     OHOS::AppExecFwk::UnwrapWantParams(env, jsWantParams, wantParams);
+    auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
     if (applicationContext != nullptr) {
         applicationContext->DispatchOnAbilityContinue(jsAbilityObj_);
     }
@@ -1421,8 +1491,9 @@ bool JsUIAbility::CallPromise(napi_value result, AppExecFwk::AbilityTransactionC
     return true;
 }
 
-bool JsUIAbility::CallPromise(napi_value result, int32_t &onContinueRes)
+bool JsUIAbility::CallPromise(napi_value result, AppExecFwk::AbilityTransactionCallbackInfo<int32_t> *callbackInfo)
 {
+    TAG_LOGI(AAFwkTag::UIABILITY, "called");
     auto env = jsRuntime_.GetNapiEnv();
     if (!CheckTypeForNapiValue(env, result, napi_object)) {
         TAG_LOGE(AAFwkTag::UIABILITY, "convert native value to NativeObject error");
@@ -1440,28 +1511,13 @@ bool JsUIAbility::CallPromise(napi_value result, int32_t &onContinueRes)
         TAG_LOGE(AAFwkTag::UIABILITY, "property then is not callable");
         return false;
     }
-
-    std::weak_ptr<UIAbility> weakPtr = shared_from_this();
-    auto asyncCallback = [abilityWeakPtr = weakPtr, this, &onContinueRes](int32_t &result) {
-        auto ability = abilityWeakPtr.lock();
-        if (ability == nullptr) {
-            TAG_LOGE(AAFwkTag::UIABILITY, "null ability");
-            return;
-        }
-        onContinueRes = result;
-    };
-    auto *callbackInfo = AppExecFwk::AbilityTransactionCallbackInfo<int32_t>::Create();
-    if (callbackInfo != nullptr) {
-        callbackInfo->Push(asyncCallback);
-    }
-
     HandleScope handleScope(jsRuntime_);
     napi_value promiseCallback = nullptr;
     napi_create_function(env, nullptr, NAPI_AUTO_LENGTH, OnContinuePromiseCallback,
         callbackInfo, &promiseCallback);
     napi_value argv[1] = { promiseCallback };
     napi_call_function(env, result, then, 1, argv, nullptr);
-    TAG_LOGD(AAFwkTag::UIABILITY, "end");
+    TAG_LOGI(AAFwkTag::UIABILITY, "end");
     return true;
 }
 
@@ -1611,5 +1667,24 @@ bool JsUIAbility::BackPressDefaultValue()
 {
     return CheckSatisfyTargetAPIVersion(API12) ? true : false;
 }
+
+void JsUIAbility::OnAfterFocusedCommon(bool isFocused)
+{
+    auto abilityContext = GetAbilityContext();
+    if (abilityContext == nullptr) {
+        TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext");
+        return;
+    }
+    auto applicationContext = abilityContext->GetApplicationContext();
+    if (applicationContext == nullptr || applicationContext->IsAbilityLifecycleCallbackEmpty()) {
+        TAG_LOGD(AAFwkTag::UIABILITY, "null applicationContext or lifecycleCallback");
+        return;
+    }
+    if (isFocused) {
+        applicationContext->DispatchWindowStageFocus(GetJsAbility(), GetJsWindowStage());
+    } else {
+        applicationContext->DispatchWindowStageUnfocus(GetJsAbility(), GetJsWindowStage());
+    }
+}
 } // namespace AbilityRuntime
 } // namespace OHOS

frameworks/native/ability/native/configuration_utils.cpp

@@ -70,6 +70,7 @@ void ConfigurationUtils::GetGlobalConfig(const Configuration &configuration,
     resourceConfig.SetMcc(configuration.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_MCC));
     resourceConfig.SetMnc(configuration.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_MNC));
     resourceConfig.SetThemeId(configuration.GetItem(AAFwk::GlobalConfigurationKey::THEME_ID));
+    resourceConfig.SetThemeIcon(configuration.GetItem(AAFwk::GlobalConfigurationKey::THEME_ICON));
 }
 
 #ifdef SUPPORT_GRAPHICS

frameworks/native/ability/native/continuation/distributed/continuation_handler_stage.cpp

@@ -37,7 +37,7 @@ ContinuationHandlerStage::ContinuationHandlerStage(
 bool ContinuationHandlerStage::HandleStartContinuationWithStack(
     const sptr<IRemoteObject> &token, const std::string &deviceId, uint32_t versionCode)
 {
-    TAG_LOGD(AAFwkTag::CONTINUATION, "Begin");
+    TAG_LOGI(AAFwkTag::CONTINUATION, "Begin");
     if (token == nullptr) {
         TAG_LOGE(AAFwkTag::CONTINUATION, "Token is null");
         return false;
@@ -52,7 +52,7 @@ bool ContinuationHandlerStage::HandleStartContinuationWithStack(
     std::shared_ptr<ContinuationManagerStage> continuationManagerTmp = nullptr;
     continuationManagerTmp = continuationManager_.lock();
     if (continuationManagerTmp == nullptr) {
-        TAG_LOGE(AAFwkTag::CONTINUATION, "ContinuationManagerTmp is nullptr");
+        TAG_LOGE(AAFwkTag::CONTINUATION, "continuationManagerTmp is nullptr");
         return false;
     }
 
@@ -61,13 +61,22 @@ bool ContinuationHandlerStage::HandleStartContinuationWithStack(
     want.SetParam(VERSION_CODE_KEY, static_cast<int32_t>(versionCode));
     want.SetParam("targetDevice", deviceId);
     WantParams wantParams = want.GetParams();
-    int32_t status = continuationManagerTmp->OnContinue(wantParams);
+
+    bool isAsyncOnContinue = false;
+    AbilityInfo abilityInfo;
+    abilityInfo.deviceId = deviceId;
+    abilityInfo.bundleName = abilityInfo_->bundleName;
+    abilityInfo.name = abilityInfo_->name;
+    abilityInfo.moduleName = abilityInfo_->moduleName;
+    int32_t status = continuationManagerTmp->OnContinue(wantParams, isAsyncOnContinue, abilityInfo);
     if (status != ERR_OK) {
         TAG_LOGE(AAFwkTag::CONTINUATION,
             "OnContinue failed, BundleName = %{public}s, ClassName= %{public}s, status: %{public}d",
             abilityInfo_->bundleName.c_str(), abilityInfo_->name.c_str(), status);
     }
-
+    if (isAsyncOnContinue) {
+        return true;
+    }
     want.SetParams(wantParams);
     want.AddFlags(want.FLAG_ABILITY_CONTINUATION);
     want.SetElementName(deviceId, abilityInfo_->bundleName, abilityInfo_->name, abilityInfo_->moduleName);

frameworks/native/ability/native/continuation/distributed/continuation_manager.cpp

@@ -36,6 +36,7 @@ const std::string SUPPORT_CONTINUE_PAGE_STACK_PROPERTY_NAME = "ohos.extra.param.
 const int32_t CONTINUE_ABILITY_REJECTED = 29360197;
 const int32_t CONTINUE_SAVE_DATA_FAILED = 29360198;
 const int32_t CONTINUE_ON_CONTINUE_FAILED = 29360199;
+const int32_t CONTINUE_ON_CONTINUE_HANDLE_FAILED = 29360300;
 const int32_t CONTINUE_ON_CONTINUE_MISMATCH = 29360204;
 #ifdef SUPPORT_GRAPHICS
 const int32_t CONTINUE_GET_CONTENT_FAILED = 29360200;
@@ -158,25 +159,31 @@ int32_t ContinuationManager::OnContinueAndGetContent(WantParams &wantParams)
     }
 
     int32_t status = ability->OnContinue(wantParams);
-    if (status != OnContinueResult::AGREE) {
-        if (status == OnContinueResult::MISMATCH) {
+    switch (status) {
+        case OnContinueResult::AGREE:
+#ifdef SUPPORT_GRAPHICS
+            if (IsContinuePageStack(wantParams)) {
+                bool ret = GetContentInfo(wantParams);
+                if (!ret) {
+                    TAG_LOGE(AAFwkTag::CONTINUATION, "GetContentInfo failed");
+                    return CONTINUE_GET_CONTENT_FAILED;
+                }
+            }
+#endif
+            return ERR_OK;
+        case OnContinueResult::REJECT:
+            TAG_LOGE(AAFwkTag::CONTINUATION, "app reject");
+            return CONTINUE_ON_CONTINUE_FAILED;
+        case OnContinueResult::MISMATCH:
             TAG_LOGE(AAFwkTag::CONTINUATION, "version mismatch");
             return CONTINUE_ON_CONTINUE_MISMATCH;
-        }
-        TAG_LOGE(AAFwkTag::CONTINUATION, "OnContinue failed");
-        return CONTINUE_ON_CONTINUE_FAILED;
+        case OnContinueResult::ON_CONTINUE_ERR:
+            TAG_LOGE(AAFwkTag::CONTINUATION, "OnContinue handle failed");
+            return CONTINUE_ON_CONTINUE_HANDLE_FAILED;
+        default:
+            TAG_LOGE(AAFwkTag::CONTINUATION, "invalid status");
+            return CONTINUE_ON_CONTINUE_HANDLE_FAILED;
     }
-
-#ifdef SUPPORT_GRAPHICS
-    if (IsContinuePageStack(wantParams)) {
-        bool ret = GetContentInfo(wantParams);
-        if (!ret) {
-            TAG_LOGE(AAFwkTag::CONTINUATION, "GetContentInfo failed");
-            return CONTINUE_GET_CONTENT_FAILED;
-        }
-    }
-#endif
-    return ERR_OK;
 }
 
 int32_t ContinuationManager::OnContinue(WantParams &wantParams)

frameworks/native/ability/native/continuation/distributed/continuation_manager_stage.cpp

@@ -37,6 +37,7 @@ const std::string SUPPORT_CONTINUE_PAGE_STACK_PROPERTY_NAME = "ohos.extra.param.
 const int32_t CONTINUE_ABILITY_REJECTED = 29360197;
 const int32_t CONTINUE_SAVE_DATA_FAILED = 29360198;
 const int32_t CONTINUE_ON_CONTINUE_FAILED = 29360199;
+const int32_t CONTINUE_ON_CONTINUE_HANDLE_FAILED = 29360300;
 const int32_t CONTINUE_ON_CONTINUE_MISMATCH = 29360204;
 #ifdef SUPPORT_GRAPHICS
 const int32_t CONTINUE_GET_CONTENT_FAILED = 29360200;
@@ -156,7 +157,8 @@ bool ContinuationManagerStage::IsContinuePageStack(const WantParams &wantParams)
     return true;
 }
 
-int32_t ContinuationManagerStage::OnContinueAndGetContent(WantParams &wantParams)
+int32_t ContinuationManagerStage::OnContinueAndGetContent(WantParams &wantParams, bool &isAsyncOnContinue,
+    const AbilityInfo &abilityInfo)
 {
     TAG_LOGD(AAFwkTag::CONTINUATION, "Begin");
     std::shared_ptr<AbilityRuntime::UIAbility> ability = ability_.lock();
@@ -165,29 +167,36 @@ int32_t ContinuationManagerStage::OnContinueAndGetContent(WantParams &wantParams
         return ERR_INVALID_VALUE;
     }
 
-    int32_t status = ability->OnContinue(wantParams);
-    if (status != OnContinueResult::AGREE) {
-        if (status == OnContinueResult::MISMATCH) {
+    int32_t status = ability->OnContinue(wantParams, isAsyncOnContinue, abilityInfo);
+    switch (status) {
+        case OnContinueResult::AGREE:
+#ifdef SUPPORT_GRAPHICS
+            if (IsContinuePageStack(wantParams)) {
+            bool ret = GetContentInfo(wantParams);
+                if (!ret) {
+                    TAG_LOGE(AAFwkTag::CONTINUATION, "GetContentInfo failed");
+                    return CONTINUE_GET_CONTENT_FAILED;
+                }
+            }
+#endif
+            return ERR_OK;
+        case OnContinueResult::REJECT:
+            TAG_LOGE(AAFwkTag::CONTINUATION, "app reject");
+            return CONTINUE_ON_CONTINUE_FAILED;
+        case OnContinueResult::MISMATCH:
             TAG_LOGE(AAFwkTag::CONTINUATION, "OnContinue version mismatch.");
             return CONTINUE_ON_CONTINUE_MISMATCH;
-        }
-        TAG_LOGE(AAFwkTag::CONTINUATION, "OnContinue failed");
-        return CONTINUE_ON_CONTINUE_FAILED;
+        case OnContinueResult::ON_CONTINUE_ERR:
+            TAG_LOGE(AAFwkTag::CONTINUATION, "OnContinue handle failed");
+            return CONTINUE_ON_CONTINUE_HANDLE_FAILED;
+        default:
+            TAG_LOGE(AAFwkTag::CONTINUATION, "invalid status");
+            return CONTINUE_ON_CONTINUE_HANDLE_FAILED;
     }
-
-#ifdef SUPPORT_GRAPHICS
-    if (IsContinuePageStack(wantParams)) {
-        bool ret = GetContentInfo(wantParams);
-        if (!ret) {
-            TAG_LOGE(AAFwkTag::CONTINUATION, "GetContentInfo failed");
-            return CONTINUE_GET_CONTENT_FAILED;
-        }
-    }
-#endif
-    return ERR_OK;
 }
 
-int32_t ContinuationManagerStage::OnContinue(WantParams &wantParams)
+int32_t ContinuationManagerStage::OnContinue(WantParams &wantParams, bool &isAsyncOnContinue,
+    const AbilityInfo &tmpAbilityInfo)
 {
     TAG_LOGD(AAFwkTag::CONTINUATION, "Begin");
     auto ability = ability_.lock();
@@ -201,7 +210,7 @@ int32_t ContinuationManagerStage::OnContinue(WantParams &wantParams)
     if (!stageBased) {
         return OnStartAndSaveData(wantParams);
     }
-    return OnContinueAndGetContent(wantParams);
+    return OnContinueAndGetContent(wantParams, isAsyncOnContinue, tmpAbilityInfo);
 }
 
 #ifdef SUPPORT_SCREEN

frameworks/native/ability/native/distributed_ability_runtime/distributed_client.cpp

@@ -267,7 +267,7 @@ int32_t DistributedClient::RegisterMissionListener(const std::u16string& devId,
 }
 
 int32_t DistributedClient::RegisterOnListener(const std::string& type,
-    const sptr<IRemoteObject>& obj)
+    const sptr<IRemoteObject>& obj, int32_t callingUid)
 {
     sptr<IRemoteObject> remote = GetDmsProxy();
     if (remote == nullptr) {
@@ -281,11 +281,12 @@ int32_t DistributedClient::RegisterOnListener(const std::string& type,
     }
     PARCEL_WRITE_HELPER(data, String, type);
     PARCEL_WRITE_HELPER(data, RemoteObject, obj);
+    PARCEL_WRITE_HELPER(data, Int32, callingUid);
     PARCEL_TRANSACT_SYNC_RET_INT(remote, REGISTER_ON_LISTENER, data, reply);
 }
 
 int32_t DistributedClient::RegisterOffListener(const std::string& type,
-    const sptr<IRemoteObject>& obj)
+    const sptr<IRemoteObject>& obj, int32_t callingUid)
 {
     sptr<IRemoteObject> remote = GetDmsProxy();
     if (remote == nullptr) {
@@ -300,6 +301,7 @@ int32_t DistributedClient::RegisterOffListener(const std::string& type,
     }
     PARCEL_WRITE_HELPER(data, String, type);
     PARCEL_WRITE_HELPER(data, RemoteObject, obj);
+    PARCEL_WRITE_HELPER(data, Int32, callingUid);
     PARCEL_TRANSACT_SYNC_RET_INT(remote, REGISTER_OFF_LISTENER, data, reply);
 }
 

frameworks/native/ability/native/extension_ability_thread.cpp

@@ -19,6 +19,7 @@
 #include "ability_handler.h"
 #include "ability_loader.h"
 #include "ability_manager_client.h"
+#include "freeze_util.h"
 #include "hilog_tag_wrapper.h"
 #include "hitrace_meter.h"
 #include "ui_extension_utils.h"
@@ -51,6 +52,7 @@ constexpr static char ENTERPRISE_ADMIN_EXTENSION[] = "EnterpriseAdminExtension";
 constexpr static char INPUTMETHOD_EXTENSION[] = "InputMethodExtensionAbility";
 constexpr static char APP_ACCOUNT_AUTHORIZATION_EXTENSION[] = "AppAccountAuthorizationExtension";
 constexpr static char FENCE_EXTENSION[] = "FenceExtension";
+constexpr static char CALLER_INFO_QUERY_EXTENSION[] = "CallerInfoQueryExtension";
 }
 
 const std::map<AppExecFwk::ExtensionAbilityType, std::string> UI_EXTENSION_NAME_MAP = {
@@ -156,6 +158,9 @@ void ExtensionAbilityThread::CreateExtensionAbilityName(
     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::FENCE) {
         abilityName = FENCE_EXTENSION;
     }
+    if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::CALLER_INFO_QUERY) {
+        abilityName = CALLER_INFO_QUERY_EXTENSION;
+    }
 #ifdef SUPPORT_GRAPHICS
     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::SYSDIALOG_USERAUTH) {
         abilityName = USER_AUTH_EXTENSION;
@@ -263,6 +268,7 @@ void ExtensionAbilityThread::HandleAttachInner(const std::shared_ptr<AppExecFwk:
     if (err != ERR_OK) {
         TAG_LOGE(AAFwkTag::EXT, "Attach err: %{public}d", err);
     }
+    FreezeUtil::GetInstance().DeleteAppLifecycleEvent(0);
 }
 
 void ExtensionAbilityThread::HandleExtensionTransaction(

frameworks/native/ability/native/fa_ability_thread.cpp

@@ -74,6 +74,7 @@ constexpr static char FILEACCESS_EXT_ABILITY[] = "FileAccessExtension";
 constexpr static char ENTERPRISE_ADMIN_EXTENSION[] = "EnterpriseAdminExtension";
 constexpr static char INPUTMETHOD_EXTENSION[] = "InputMethodExtensionAbility";
 constexpr static char APP_ACCOUNT_AUTHORIZATION_EXTENSION[] = "AppAccountAuthorizationExtension";
+constexpr static char CALLER_INFO_QUERY_EXTENSION[] = "CallerInfoQueryExtension";
 #ifdef WITH_DLP
 constexpr static char DLP_PARAMS_SANDBOX[] = "ohos.dlp.params.sandbox";
 #endif // WITH_DLP
@@ -188,6 +189,9 @@ void FAAbilityThread::CreateExtensionAbilityName(const std::shared_ptr<AppExecFw
     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::APP_ACCOUNT_AUTHORIZATION) {
         abilityName = APP_ACCOUNT_AUTHORIZATION_EXTENSION;
     }
+    if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::CALLER_INFO_QUERY) {
+        abilityName = CALLER_INFO_QUERY_EXTENSION;
+    }
     CreateExtensionAbilityNameSupportGraphics(abilityInfo, abilityName);
     TAG_LOGD(AAFwkTag::FA, "extension abilityName: %{public}s", abilityName.c_str());
 }
@@ -320,6 +324,7 @@ void FAAbilityThread::AttachInner(const std::shared_ptr<AppExecFwk::OHOSApplicat
         return;
     }
     FreezeUtil::GetInstance().DeleteLifecycleEvent(flow);
+    FreezeUtil::GetInstance().DeleteAppLifecycleEvent(0);
 }
 
 void FAAbilityThread::AttachExtension(const std::shared_ptr<AppExecFwk::OHOSApplication> &application,

frameworks/native/ability/native/js_service_extension_context.cpp

@@ -197,7 +197,8 @@ private:
         context->ClearFailedCallConnection(callback);
     }
 
-    void AddFreeInstallObserver(napi_env env, const AAFwk::Want &want, napi_value callback, napi_value* result)
+    void AddFreeInstallObserver(napi_env env, const AAFwk::Want &want, napi_value callback,
+        napi_value* result, bool isOpenLink = false)
     {
         // adapter free install async return install and start result
         int ret = 0;
@@ -213,14 +214,19 @@ private:
 
         if (ret != ERR_OK) {
             TAG_LOGE(AAFwkTag::SERVICE_EXT, "AddFreeInstallObserver failed");
-        } else {
-            // build a callback observer with last param
+            return;
+        }
+        std::string startTime = want.GetStringParam(Want::PARAM_RESV_START_TIME);
+        // build a callback observer with last param
+        if (!isOpenLink) {
+            TAG_LOGI(AAFwkTag::SERVICE_EXT, "AddJsObserverObject");
             std::string bundleName = want.GetElement().GetBundleName();
             std::string abilityName = want.GetElement().GetAbilityName();
-            std::string startTime = want.GetStringParam(Want::PARAM_RESV_START_TIME);
             freeInstallObserver_->AddJsObserverObject(
                 bundleName, abilityName, startTime, callback, result);
         }
+        std::string url = want.GetUriString();
+        freeInstallObserver_->AddJsObserverObject(startTime, url, callback, result);
     }
 
     napi_value OnStartAbility(napi_env env, NapiCallbackInfo& info, bool isStartRecent = false)
@@ -332,8 +338,17 @@ private:
         }
 
         want.SetUri(linkValue);
-        auto innerErrorCode = std::make_shared<int>(ERR_OK);
+        std::string startTime = std::to_string(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::
+            system_clock::now().time_since_epoch()).count());
+        want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
 
+        return OnOpenLinkInner(env, want, startTime, linkValue);
+    }
+
+    napi_value OnOpenLinkInner(napi_env env, const AAFwk::Want& want,
+        const std::string& startTime, const std::string& url)
+    {
+        auto innerErrorCode = std::make_shared<int>(ERR_OK);
         NapiAsyncTask::ExecuteCallback execute = [weak = context_, want, innerErrorCode]() {
             auto context = weak.lock();
             if (!context) {
@@ -341,23 +356,35 @@ private:
                 *innerErrorCode = static_cast<int>(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT);
                 return;
             }
-            *innerErrorCode = context->StartAbilityWithAccount(want, -1);
+            *innerErrorCode = context->OpenLink(want, -1);
         };
 
-        NapiAsyncTask::CompleteCallback complete = [innerErrorCode](napi_env env, NapiAsyncTask& task, int32_t status) {
+        NapiAsyncTask::CompleteCallback complete = [innerErrorCode, startTime, url,
+            freeInstallObserver = freeInstallObserver_](
+            napi_env env, NapiAsyncTask& task, int32_t status) {
             if (*innerErrorCode == 0) {
                 TAG_LOGI(AAFwkTag::SERVICE_EXT, "OpenLink success");
-                task.ResolveWithNoError(env, CreateJsUndefined(env));
-            } else {
-                TAG_LOGI(AAFwkTag::SERVICE_EXT, "OpenLink failed");
-                task.Reject(env, CreateJsErrorByNativeErr(env, *innerErrorCode));
+                return;
             }
+            if (freeInstallObserver == nullptr) {
+                TAG_LOGE(AAFwkTag::SERVICE_EXT, "freeInstallObserver_ is nullptr");
+                task.Reject(env, CreateJsErrorByNativeErr(env, *innerErrorCode));
+                return;
+            }
+            if (*innerErrorCode == AAFwk::ERR_OPEN_LINK_START_ABILITY_DEFAULT_OK) {
+                TAG_LOGI(AAFwkTag::SERVICE_EXT, "start ability by default succeeded");
+                freeInstallObserver->OnInstallFinishedByUrl(startTime, url, ERR_OK);
+                return;
+            }
+            TAG_LOGI(AAFwkTag::SERVICE_EXT, "OpenLink failed");
+            freeInstallObserver->OnInstallFinishedByUrl(startTime, url, *innerErrorCode);
         };
 
         napi_value result = nullptr;
+        AddFreeInstallObserver(env, want, nullptr, &result, true);
         NapiAsyncTask::ScheduleHighQos("JSServiceExtensionContext::OnOpenLink", env,
-            CreateAsyncTaskWithLastParam(env, nullptr, std::move(execute), std::move(complete), &result));
-
+            CreateAsyncTaskWithLastParam(env, nullptr, std::move(execute), std::move(complete), nullptr));
+        
         return result;
     }
 

frameworks/native/ability/native/new_ability_impl.cpp

@@ -79,6 +79,7 @@ void NewAbilityImpl::AbilityTransactionCallback(const AbilityLifeCycleState &sta
     if (ret == ERR_OK && state == AAFwk::ABILITY_STATE_FOREGROUND_NEW) {
         FreezeUtil::LifecycleFlow flow = { token_, FreezeUtil::TimeoutState::FOREGROUND };
         FreezeUtil::GetInstance().DeleteLifecycleEvent(flow);
+        FreezeUtil::GetInstance().DeleteAppLifecycleEvent(0);
     }
 }
 

frameworks/native/ability/native/resource_config_helper.cpp

@@ -67,6 +67,10 @@ void ResourceConfigHelper::SetThemeId(std::string themeId)
 {
     themeId_ = themeId;
 }
+void ResourceConfigHelper::SetThemeIcon(std::string themeIcon)
+{
+    themeIcon_ = themeIcon;
+}
 
 void ResourceConfigHelper::UpdateResConfig(
     const AppExecFwk::Configuration &configuration, std::shared_ptr<Global::Resource::ResourceManager> resourceManager)
@@ -147,6 +151,7 @@ void ResourceConfigHelper::UpdateResConfig(std::unique_ptr<Global::Resource::Res
             TAG_LOGD(AAFwkTag::ABILITY, "set themeId: %{public}u", resConfig->GetThemeId());
         }
     }
+    resConfig->SetThemeIcon(!themeIcon_.empty());
 }
 
 bool ResourceConfigHelper::ConvertStringToUint32(std::string source, uint32_t &result)

frameworks/native/ability/native/ui_ability.cpp

@@ -441,9 +441,17 @@ AppExecFwk::AbilityLifecycleExecutor::LifecycleState UIAbility::GetState()
     return static_cast<AppExecFwk::AbilityLifecycleExecutor::LifecycleState>(abilityLifecycleExecutor_->GetState());
 }
 
-int32_t UIAbility::OnContinue(AAFwk::WantParams &wantParams)
+int32_t UIAbility::OnContinueAsyncCB(napi_value jsWantParams, int32_t status,
+    const AppExecFwk::AbilityInfo &abilityInfo)
 {
-    return AppExecFwk::ContinuationManagerStage::OnContinueResult::REJECT;
+    TAG_LOGD(AAFwkTag::UIABILITY, "called");
+    return ERR_OK;
+}
+
+int32_t UIAbility::OnContinue(AAFwk::WantParams &wantParams, bool &isAsyncOnContinue,
+    const AppExecFwk::AbilityInfo &abilityInfo)
+{
+    return AppExecFwk::ContinuationManagerStage::OnContinueResult::ON_CONTINUE_ERR;
 }
 
 void UIAbility::ContinueAbilityWithStack(const std::string &deviceId, uint32_t versionCode)

frameworks/native/ability/native/ui_ability_impl.cpp

@@ -21,7 +21,6 @@
 #include "freeze_util.h"
 #include "hilog_tag_wrapper.h"
 #include "hitrace_meter.h"
-#include "js_ui_ability.h"
 #include "ohos_application.h"
 #include "process_options.h"
 #ifdef SUPPORT_SCREEN
@@ -179,6 +178,12 @@ void UIAbilityImpl::HandleAbilityTransaction(
             AAFwk::AbilityManagerClient::GetInstance()->AbilityTransitionDone(
                 token_, targetState.state, GetRestoreData());
         }
+        if (ability_ != nullptr && targetState.state == AAFwk::ABILITY_STATE_BACKGROUND_NEW) {
+            TAG_LOGW(AAFwkTag::UIABILITY, "OnBackground is called when current state is already background");
+            Background();
+            AAFwk::AbilityManagerClient::GetInstance()->AbilityTransitionDone(
+                token_, targetState.state, GetRestoreData());
+        }
         TAG_LOGE(AAFwkTag::UIABILITY, "Org lifeCycleState equals to dst lifeCycleState");
         return;
     }
@@ -213,14 +218,15 @@ void UIAbilityImpl::AbilityTransactionCallback(const AAFwk::AbilityLifeCycleStat
 {
     TAG_LOGD(AAFwkTag::UIABILITY, "called");
     FreezeUtil::LifecycleFlow flow = { token_, FreezeUtil::TimeoutState::FOREGROUND };
-    std::string entry = "AbilityManagerClient::AbilityTransitionDone; the transaction start.";
-    FreezeUtil::GetInstance().AddLifecycleEvent(flow, entry);
     if (state == AAFwk::ABILITY_STATE_FOREGROUND_NEW) {
         lifecycleState_ = AAFwk::ABILITY_STATE_FOREGROUND_NEW;
+        std::string entry = "AbilityManagerClient::AbilityTransitionDone; the transaction start.";
+        FreezeUtil::GetInstance().AddLifecycleEvent(flow, entry);
     }
     auto ret = AAFwk::AbilityManagerClient::GetInstance()->AbilityTransitionDone(token_, state, GetRestoreData());
     if (ret == ERR_OK && state == AAFwk::ABILITY_STATE_FOREGROUND_NEW) {
         FreezeUtil::GetInstance().DeleteLifecycleEvent(flow);
+        FreezeUtil::GetInstance().DeleteAppLifecycleEvent(0);
     }
 }
 
@@ -395,23 +401,7 @@ void UIAbilityImpl::AfterFocusedCommon(bool isFocused)
             return;
         }
 
-        auto abilityContext = impl->ability_->GetAbilityContext();
-        if (abilityContext == nullptr) {
-            TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext");
-            return;
-        }
         impl->ability_->OnAfterFocusedCommon(focuseMode);
-        auto applicationContext = abilityContext->GetApplicationContext();
-        if (applicationContext == nullptr || applicationContext->IsAbilityLifecycleCallbackEmpty()) {
-            TAG_LOGE(AAFwkTag::UIABILITY, "null applicationContext or lifecycleCallback");
-            return;
-        }
-        auto &jsAbility = static_cast<JsUIAbility &>(*(impl->ability_));
-        if (focuseMode) {
-            applicationContext->DispatchWindowStageFocus(jsAbility.GetJsAbility(), jsAbility.GetJsWindowStage());
-        } else {
-            applicationContext->DispatchWindowStageUnfocus(jsAbility.GetJsAbility(), jsAbility.GetJsWindowStage());
-        }
     };
 
     if (handler_) {
@@ -455,6 +445,7 @@ void UIAbilityImpl::WindowLifeCycleImpl::AfterForeground()
             token_, AAFwk::AbilityLifeCycleState::ABILITY_STATE_FOREGROUND_NEW, restoreData);
         if (ret == ERR_OK) {
             FreezeUtil::GetInstance().DeleteLifecycleEvent(flow);
+            FreezeUtil::GetInstance().DeleteAppLifecycleEvent(0);
         }
     }
 }
@@ -472,6 +463,7 @@ void UIAbilityImpl::WindowLifeCycleImpl::AfterBackground()
         token_, AAFwk::AbilityLifeCycleState::ABILITY_STATE_BACKGROUND_NEW, restoreData);
     if (ret == ERR_OK) {
         FreezeUtil::GetInstance().DeleteLifecycleEvent(flow);
+        FreezeUtil::GetInstance().DeleteAppLifecycleEvent(0);
     }
 }
 
@@ -498,6 +490,9 @@ void UIAbilityImpl::WindowLifeCycleImpl::AfterUnfocused()
 void UIAbilityImpl::WindowLifeCycleImpl::ForegroundFailed(int32_t type)
 {
     TAG_LOGE(AAFwkTag::UIABILITY, "scb call, ForegroundFailed");
+    FreezeUtil::LifecycleFlow flow = { token_, FreezeUtil::TimeoutState::FOREGROUND };
+    std::string entry = "ERROR UIAbilityImpl::WindowLifeCycleImpl::ForegroundFailed; GoForeground failed.";
+    FreezeUtil::GetInstance().AppendLifecycleEvent(flow, entry);
     AppExecFwk::PacMap restoreData;
     switch (type) {
         case static_cast<int32_t>(OHOS::Rosen::WMError::WM_ERROR_INVALID_OPERATION): {
@@ -604,7 +599,7 @@ bool UIAbilityImpl::AbilityTransaction(const AAFwk::Want &want, const AAFwk::Lif
                 Background();
             } else {
                 TAG_LOGD(AAFwkTag::UIABILITY, "handleExecuteInsightIntentBackground");
-                HandleExecuteInsightIntentBackground(want);
+                ret = HandleExecuteInsightIntentBackground(want);
             }
 #endif
             break;
@@ -770,7 +765,7 @@ void UIAbilityImpl::PostForegroundInsightIntent()
     }
 }
 
-void UIAbilityImpl::HandleExecuteInsightIntentBackground(const AAFwk::Want &want, bool onlyExecuteIntent)
+bool UIAbilityImpl::HandleExecuteInsightIntentBackground(const AAFwk::Want &want, bool onlyExecuteIntent)
 {
     TAG_LOGI(AAFwkTag::UIABILITY, "called");
     auto executeParam = std::make_shared<InsightIntentExecuteParam>();
@@ -778,7 +773,7 @@ void UIAbilityImpl::HandleExecuteInsightIntentBackground(const AAFwk::Want &want
     if (!ret && !onlyExecuteIntent) {
         TAG_LOGE(AAFwkTag::UIABILITY, "invalid params");
         Background();
-        return;
+        return true;
     }
 
     TAG_LOGD(AAFwkTag::UIABILITY,
@@ -792,14 +787,16 @@ void UIAbilityImpl::HandleExecuteInsightIntentBackground(const AAFwk::Want &want
     if (intentCb == nullptr && !onlyExecuteIntent) {
         TAG_LOGE(AAFwkTag::UIABILITY, "create async callback failed");
         Background();
-        return;
+        return true;
     }
     TAG_LOGD(AAFwkTag::UIABILITY, "lifecycleState_: %{public}d", lifecycleState_);
     if (lifecycleState_ == AAFwk::ABILITY_STATE_INITIAL
         || lifecycleState_ == AAFwk::ABILITY_STATE_STARTED_NEW) {
         ExecuteInsightIntentBackgroundByColdBoot(want, executeParam, std::move(intentCb));
+        return false;
     } else {
         ExecuteInsightIntentBackgroundAlreadyStart(want, executeParam, std::move(intentCb));
+        return true;
     }
 }
 
@@ -818,6 +815,7 @@ void UIAbilityImpl::ExecuteInsightIntentBackgroundByColdBoot(const Want &want,
             }
             abilityImpl->Background();
             abilityImpl->ExecuteInsightIntentDone(intentId, result);
+            abilityImpl->AbilityTransactionCallback(AAFwk::ABILITY_STATE_BACKGROUND_NEW);
         };
     callback->Push(asyncCallback);
 

frameworks/native/ability/native/ui_ability_thread.cpp

@@ -172,10 +172,13 @@ void UIAbilityThread::AttachInner(const std::shared_ptr<AppExecFwk::OHOSApplicat
     FreezeUtil::GetInstance().AddLifecycleEvent(flow, entry);
     ErrCode err = AbilityManagerClient::GetInstance()->AttachAbilityThread(this, token_);
     if (err != ERR_OK) {
+        entry = std::string("AbilityThread::Attach failed ipc error: ") + std::to_string(err);
+        FreezeUtil::GetInstance().AddLifecycleEvent(flow, entry);
         TAG_LOGE(AAFwkTag::UIABILITY, "err: %{public}d", err);
         return;
     }
     FreezeUtil::GetInstance().DeleteLifecycleEvent(flow);
+    FreezeUtil::GetInstance().DeleteAppLifecycleEvent(0);
 }
 
 void UIAbilityThread::Attach(const std::shared_ptr<AppExecFwk::OHOSApplication> &application,

frameworks/native/ability/native/ui_extension_ability/js_ui_extension.cpp

@@ -66,28 +66,14 @@ napi_value AttachUIExtensionContext(napi_env env, void *value, void *extValue)
         TAG_LOGE(AAFwkTag::UI_EXT, "invalid context");
         return nullptr;
     }
-    auto screenModePtr = reinterpret_cast<std::weak_ptr<int32_t> *>(extValue)->lock();
-    if (screenModePtr == nullptr) {
-        TAG_LOGE(AAFwkTag::UI_EXT, "Invalid screenModePtr");
+    napi_value object = JsUIExtensionContext::CreateJsUIExtensionContext(env, ptr);
+    auto contextRef = JsRuntime::LoadSystemModuleByEngine(env, "application.UIExtensionContext",
+        &object, 1);
+    if (contextRef == nullptr) {
+        TAG_LOGD(AAFwkTag::UI_EXT, "Failed to load module");
         return nullptr;
     }
-    napi_value contextObj = nullptr;
-    if (*screenModePtr == AAFwk::IDLE_SCREEN_MODE) {
-        auto uiExtObject = JsUIExtensionContext::CreateJsUIExtensionContext(env, ptr);
-        CHECK_POINTER_AND_RETURN(uiExtObject, nullptr);
-        auto contextRef = JsRuntime::LoadSystemModuleByEngine(env, "application.UIExtensionContext",
-            &uiExtObject, 1);
-        CHECK_POINTER_AND_RETURN(contextRef, nullptr);
-        contextObj = contextRef->GetNapiValue();
-    } else {
-        auto emUIObject = JsEmbeddableUIAbilityContext::CreateJsEmbeddableUIAbilityContext(env,
-            nullptr, ptr, *screenModePtr);
-        CHECK_POINTER_AND_RETURN(emUIObject, nullptr);
-        auto contextRef = JsRuntime::LoadSystemModuleByEngine(env, "application.EmbeddableUIAbilityContext",
-            &emUIObject, 1);
-        CHECK_POINTER_AND_RETURN(contextRef, nullptr);
-        contextObj = contextRef->GetNapiValue();
-    }
+    auto contextObj = contextRef->GetNapiValue();
     if (contextObj == nullptr) {
         TAG_LOGE(AAFwkTag::UI_EXT, "load context error");
         return nullptr;

frameworks/native/ability/native/ui_extension_ability/js_ui_extension_context.cpp

@@ -104,11 +104,7 @@ bool CheckConnectionParam(napi_env env, napi_value value, sptr<JSUIExtensionConn
     key.want = want;
     connection->SetConnectionId(key.id);
     g_connects.emplace(key, connection);
-    if (g_serialNumber < INT32_MAX) {
-        g_serialNumber++;
-    } else {
-        g_serialNumber = 0;
-    }
+    g_serialNumber = (g_serialNumber + 1) % INT32_MAX;
     TAG_LOGD(AAFwkTag::UI_EXT, "not find connection, create a new connection");
     return true;
 }

frameworks/native/ability/native/ui_service_extension_ability/ui_service_extension.cpp

@@ -91,7 +91,7 @@ sptr<Rosen::WindowOption> UIServiceExtension::GetWindowOption(
         }
         option->SetWindowType(Rosen::WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
         option->SetParentId(hostWindowId);
-        option->SetExtensionTag(true);
+        option->SetIsUIExtFirstSubWindow(true);
         option->SetSubWindowTitle(extensionWindowConfig->subWindowOptions.title);
         option->SetSubWindowDecorEnable(extensionWindowConfig->subWindowOptions.decorEnabled);
         if (extensionWindowConfig->subWindowOptions.isModal) {

frameworks/native/appkit/BUILD.gn

@@ -12,6 +12,7 @@
 # limitations under the License.
 
 import("//build/config/components/ets_frontend/es2abc_config.gni")
+import("//commonlibrary/memory_utils/purgeable_mem_config.gni")
 import("//build/ohos.gni")
 import("//build/templates/abc/ohos_abc.gni")
 import("//foundation/ability/ability_runtime/ability_runtime.gni")
@@ -87,6 +88,7 @@ ohos_shared_library("appkit_native") {
     "${ability_runtime_path}/interfaces/kits/native/ability/native",
     "${ability_runtime_path}/interfaces/kits/native/ability/native/recovery",
     "${ability_runtime_path}/utils/global/time/include",
+    "${ability_runtime_services_path}/abilitymgr/include/utils",
     "${ability_runtime_services_path}/abilitymgr/include",
     "${ability_runtime_napi_path}/inner/napi_common",
     "${ability_runtime_utils_path}/global/constant",
@@ -201,7 +203,6 @@ ohos_shared_library("appkit_native") {
     "napi:ace_napi",
     "preferences:native_preferences",
     "resource_management:global_resmgr",
-    "runtime_core:libarkbase_static",
     "safwk:system_ability_fwk",
     "samgr:samgr_proxy",
   ]
@@ -231,9 +232,6 @@ ohos_shared_library("appkit_native") {
     defines += [ "NWEB" ]
   }
 
-
-  memory_utils_purgeable_ashmem_enable = true
-  
   if (memory_utils_purgeable_ashmem_enable && defined(global_parts_info) &&
       defined(global_parts_info.resourceschedule_memmgr_override)) {
     defines += [ "IMAGE_PURGEABLE_PIXELMAP" ]

frameworks/native/appkit/ability_runtime/app/js_ability_stage.cpp

@@ -51,41 +51,6 @@ constexpr const char* CONFIG_ENTRY = "configEntry";
 constexpr const char *TASKPOOL = "taskPool";
 constexpr const char *TASKPOOL_LOWER = "taskpool";
 
-napi_value AttachAbilityStageContext(napi_env env, void *value, void *)
-{
-    TAG_LOGD(AAFwkTag::APPKIT, "AttachAbilityStageContext");
-    if (env == nullptr || value == nullptr) {
-        TAG_LOGW(AAFwkTag::APPKIT, "invalid parameter, env or value is nullptr");
-        return nullptr;
-    }
-    auto ptr = reinterpret_cast<std::weak_ptr<AbilityContext> *>(value)->lock();
-    if (ptr == nullptr) {
-        TAG_LOGW(AAFwkTag::APPKIT, "invalid context");
-        return nullptr;
-    }
-    napi_value object = CreateJsAbilityStageContext(env, ptr);
-    auto systemModule = JsRuntime::LoadSystemModuleByEngine(env, "application.AbilityStageContext", &object, 1);
-    if (systemModule == nullptr) {
-        TAG_LOGW(AAFwkTag::APPKIT, "invalid systemModule");
-        return nullptr;
-    }
-    auto contextObj = systemModule->GetNapiValue();
-    if (!CheckTypeForNapiValue(env, contextObj, napi_object)) {
-        TAG_LOGW(AAFwkTag::APPKIT, "LoadSystemModuleByEngine or ConvertNativeValueTo failed");
-        return nullptr;
-    }
-    napi_coerce_to_native_binding_object(
-        env, contextObj, DetachCallbackFunc, AttachAbilityStageContext, value, nullptr);
-    auto workContext = new (std::nothrow) std::weak_ptr<AbilityRuntime::Context>(ptr);
-    napi_wrap(env, contextObj, workContext,
-        [](napi_env, void *data, void *) {
-            TAG_LOGD(AAFwkTag::APPKIT, "Finalizer context is called");
-            delete static_cast<std::weak_ptr<AbilityRuntime::Context> *>(data);
-        },
-        nullptr, nullptr);
-    return contextObj;
-}
-
 bool JsAbilityStage::UseCommonChunk(const AppExecFwk::HapModuleInfo& hapModuleInfo)
 {
     for (auto &md: hapModuleInfo.metadata) {
@@ -121,9 +86,17 @@ std::shared_ptr<AbilityStage> JsAbilityStage::Create(
             srcPath.append(hapModuleInfo.srcPath);
             srcPath.append("/AbilityStage.abc");
         }
-        auto moduleObj = jsRuntime.LoadModule(moduleName, srcPath, hapModuleInfo.hapPath,
-            hapModuleInfo.compileMode == AppExecFwk::CompileMode::ES_MODULE, commonChunkFlag);
-        return std::make_shared<JsAbilityStage>(jsRuntime, std::move(moduleObj));
+        std::string key(moduleName);
+        key.append("::");
+        key.append(srcPath);
+        std::unique_ptr<NativeReference> moduleObj = nullptr;
+        if (jsRuntime.PopPreloadObj(key, moduleObj)) {
+            return std::make_shared<JsAbilityStage>(jsRuntime, std::move(moduleObj));
+        } else {
+            auto moduleObj = jsRuntime.LoadModule(moduleName, srcPath, hapModuleInfo.hapPath,
+                hapModuleInfo.compileMode == AppExecFwk::CompileMode::ES_MODULE, commonChunkFlag);
+            return std::make_shared<JsAbilityStage>(jsRuntime, std::move(moduleObj));
+        }
     }
 
     std::unique_ptr<NativeReference> moduleObj;

frameworks/native/appkit/ability_runtime/app/js_ability_stage_context.cpp

@@ -16,6 +16,7 @@
 #include "js_ability_stage_context.h"
 
 #include "ability_runtime/context/context.h"
+#include "ability_stage_context.h"
 #include "hilog_tag_wrapper.h"
 #include "js_context_utils.h"
 #include "js_data_struct_converter.h"
@@ -65,5 +66,57 @@ napi_value CreateJsAbilityStageContext(napi_env env, std::shared_ptr<AbilityRunt
     }
     return objValue;
 }
+
+napi_value AttachAbilityStageContext(napi_env env, void *value, void *hint)
+{
+    TAG_LOGD(AAFwkTag::APPKIT, "attach ability stage context");
+    if (env == nullptr || value == nullptr) {
+        TAG_LOGW(AAFwkTag::APPKIT, "invalid params");
+        return nullptr;
+    }
+    auto ptr = reinterpret_cast<std::weak_ptr<AbilityStageContext> *>(value)->lock();
+    if (ptr == nullptr) {
+        TAG_LOGW(AAFwkTag::APPKIT, "invalid context");
+        return nullptr;
+    }
+
+    auto object = CreateJsAbilityStageContext(env, ptr);
+    if (object == nullptr) {
+        TAG_LOGW(AAFwkTag::CONTEXT, "null ability stage object");
+        return nullptr;
+    }
+    auto systemModule = JsRuntime::LoadSystemModuleByEngine(env, "application.AbilityStageContext", &object, 1);
+    if (systemModule == nullptr) {
+        TAG_LOGW(AAFwkTag::APPKIT, "load ability stage context failed");
+        return nullptr;
+    }
+    auto contextObj = systemModule->GetNapiValue();
+    if (!CheckTypeForNapiValue(env, contextObj, napi_object)) {
+        TAG_LOGW(AAFwkTag::APPKIT, "not napi object");
+        return nullptr;
+    }
+
+    auto status = napi_coerce_to_native_binding_object(
+        env, contextObj, DetachCallbackFunc, AttachAbilityStageContext, value, nullptr);
+    if (status != napi_ok) {
+        TAG_LOGW(AAFwkTag::APPKIT, "coerce ability stage context failed: %{public}d", status);
+        return nullptr;
+    }
+
+    auto workContext = new (std::nothrow) std::weak_ptr<AbilityStageContext>(ptr);
+    status = napi_wrap(env, contextObj, workContext,
+        [](napi_env, void *data, void *) {
+            TAG_LOGD(AAFwkTag::CONTEXT, "finalizer for weak_ptr ability stage context");
+            delete static_cast<std::weak_ptr<AbilityStageContext> *>(data);
+        },
+        nullptr, nullptr);
+    if (status != napi_ok) {
+        TAG_LOGW(AAFwkTag::APPKIT, "wrap ability stage context failed: %{public}d", status);
+        delete workContext;
+        return nullptr;
+    }
+
+    return contextObj;
+}
 }  // namespace AbilityRuntime
 }  // namespace OHOS

frameworks/native/appkit/ability_runtime/context/context_impl.cpp

@@ -1019,13 +1019,15 @@ void ContextImpl::UpdateResConfig(std::shared_ptr<Global::Resource::ResourceMana
     }
 #endif
     resConfig->SetDeviceType(GetDeviceType());
-    std::string mcc = config_->GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_MCC);
-    std::string mnc = config_->GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_MNC);
-    try {
-        resConfig->SetMcc(static_cast<uint32_t>(std::stoi(mcc)));
-        resConfig->SetMnc(static_cast<uint32_t>(std::stoi(mnc)));
-    } catch (...) {
-        TAG_LOGD(AAFwkTag::APPKIT, "Set mcc,mnc failed mcc:%{public}s mnc:%{public}s", mcc.c_str(), mnc.c_str());
+    if (config_) {
+        std::string mcc = config_->GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_MCC);
+        std::string mnc = config_->GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_MNC);
+        try {
+            resConfig->SetMcc(static_cast<uint32_t>(std::stoi(mcc)));
+            resConfig->SetMnc(static_cast<uint32_t>(std::stoi(mnc)));
+        } catch (...) {
+            TAG_LOGD(AAFwkTag::APPKIT, "Set mcc,mnc failed mcc:%{public}s mnc:%{public}s", mcc.c_str(), mnc.c_str());
+        }
     }
     resourceManager->UpdateResConfig(*resConfig);
 }

frameworks/native/appkit/ability_runtime/service_extension_context.cpp

@@ -263,5 +263,12 @@ ErrCode ServiceExtensionContext::PreStartMission(const std::string& bundleName,
     }
     return err;
 }
+
+ErrCode ServiceExtensionContext::OpenLink(const AAFwk::Want& want, int requestCode)
+{
+    TAG_LOGD(AAFwkTag::UI_EXT, "called");
+    return AAFwk::AbilityManagerClient::GetInstance()->OpenLink(want, token_, -1, requestCode);
+}
+
 }  // namespace AbilityRuntime
 }  // namespace OHOS

frameworks/native/appkit/app/application_cleaner.cpp

@@ -79,19 +79,21 @@ void ApplicationCleaner::ClearTempData()
         TAG_LOGE(AAFwkTag::APPKIT, "Get root dir error");
         return;
     }
-    auto cleanTemp = [self = shared_from_this(), rootDir]() {
-        if (self == nullptr || self->context_ == nullptr) {
+    auto weakThis = weak_from_this();
+    auto cleanTemp = [weakThis, rootDir]() {
+        auto sharedThis = weakThis.lock();
+        if (sharedThis == nullptr || sharedThis->context_ == nullptr) {
             TAG_LOGE(AAFwkTag::APPKIT, "Invalid shared pointer");
             return;
         }
         std::vector<std::string> temps;
-        if (self->GetObsoleteBundleTempPath(rootDir, temps) != RESULT_OK) {
+        if (sharedThis->GetObsoleteBundleTempPath(rootDir, temps) != RESULT_OK) {
             TAG_LOGE(AAFwkTag::APPKIT, "Get bundle temp file list is false");
             return;
         }
 
         for (const auto &temp : temps) {
-            if (self->RemoveDir(temp) == false) {
+            if (sharedThis->RemoveDir(temp) == false) {
                 TAG_LOGE(AAFwkTag::APPKIT, "Clean bundle data dir failed, path: %{private}s", temp.c_str());
             }
         }

frameworks/native/appkit/app/assert_fault_task_thread.cpp

@@ -149,7 +149,6 @@ AAFwk::UserStatus AssertFaultTaskThread::HandleAssertCallback(const std::string
             TAG_LOGE(AAFwkTag::APPKIT, "Invalid client object");
             break;
         }
-
         std::unique_lock<std::mutex> lockAssertResult(assertResultMutex_);
         AAFwk::WantParams wantParams;
         wantParams.SetParam(ASSERT_FAULT_DETAIL, AAFwk::String::Box(exprStr));
@@ -158,7 +157,6 @@ AAFwk::UserStatus AssertFaultTaskThread::HandleAssertCallback(const std::string
             TAG_LOGE(AAFwkTag::APPKIT, "Request assert fault dialog failed");
             break;
         }
-
         assertResultCV_.wait(lockAssertResult);
         assertResult = assertFaultCallback->GetAssertResult();
     } while (false);
@@ -175,4 +173,4 @@ void AssertFaultTaskThread::NotifyReleaseLongWaiting()
     assertResultCV_.notify_one();
 }
 } // namespace AbilityRuntime
-} // namespace OHOS
+} // namespace OHOS

frameworks/native/appkit/app/context_container.cpp

@@ -213,7 +213,7 @@ std::string ContextContainer::GetAppType()
     }
 }
 
-void ContextContainer::SetPattern(int patternId)
+void ContextContainer::SetPattern(int32_t patternId)
 {
     if (baseContext_ != nullptr) {
         baseContext_->SetPattern(patternId);

frameworks/native/appkit/app/idle_time.cpp

@@ -132,17 +132,19 @@ bool IdleTime::GetNeedStop()
 
 IdleNotifyStatusCallback IdleTime::GetIdleNotifyFunc()
 {
-    IdleNotifyStatusCallback cb = [this](bool needStop) {
-        if (this->GetNeedStop() == needStop) {
+    auto weakThis = weak_from_this();
+    IdleNotifyStatusCallback cb = [weakThis](bool needStop) {
+        auto sharedThis = weakThis.lock();
+        if (sharedThis == nullptr || sharedThis->GetNeedStop() == needStop) {
             return;
         }
 
-        this->SetNeedStop(needStop);
+        sharedThis->SetNeedStop(needStop);
         if (needStop == false) {
-            this->Start();
+            sharedThis->Start();
         }
     };
     return cb;
 }
 } // AppExecFwk
-} // namespace OHOS
+} // namespace OHOS

frameworks/native/appkit/app/main_thread.cpp

@@ -413,6 +413,7 @@ std::shared_ptr<EventHandler> MainThread::GetMainHandler() const
 bool MainThread::ScheduleForegroundApplication()
 {
     HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
+    FreezeUtil::GetInstance().AddAppLifecycleEvent(0, "ScheduleForegroundApplication");
     TAG_LOGD(AAFwkTag::APPKIT, "called");
     wptr<MainThread> weak = this;
     auto task = [weak]() {
@@ -640,6 +641,7 @@ void MainThread::ScheduleLaunchApplication(const AppLaunchData &data, const Conf
 {
     HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
     TAG_LOGD(AAFwkTag::APPKIT, "called");
+    FreezeUtil::GetInstance().AddAppLifecycleEvent(0, "ScheduleLaunchApplication");
     wptr<MainThread> weak = this;
     auto task = [weak, data, config]() {
         auto appThread = weak.promote();
@@ -747,6 +749,8 @@ void MainThread::ScheduleLaunchAbility(const AbilityInfo &info, const sptr<IRemo
 void MainThread::ScheduleCleanAbility(const sptr<IRemoteObject> &token, bool isCacheProcess)
 {
     TAG_LOGD(AAFwkTag::APPKIT, "called, with isCacheProcess =%{public}d.", isCacheProcess);
+    FreezeUtil::GetInstance().DeleteAppLifecycleEvent(0);
+    FreezeUtil::GetInstance().DeleteLifecycleEvent(token);
     wptr<MainThread> weak = this;
     auto task = [weak, token, isCacheProcess]() {
         auto appThread = weak.promote();
@@ -1280,6 +1284,7 @@ CJUncaughtExceptionInfo MainThread::CreateCjExceptionInfo(const std::string &bun
 void MainThread::HandleLaunchApplication(const AppLaunchData &appLaunchData, const Configuration &config)
 {
     HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
+    FreezeUtil::GetInstance().AddAppLifecycleEvent(0, "HandleLaunchApplication:begin");
     if (!CheckForHandleLaunchApplication(appLaunchData)) {
         TAG_LOGE(AAFwkTag::APPKIT, "CheckForHandleLaunchApplication failed");
         return;
@@ -1338,7 +1343,9 @@ void MainThread::HandleLaunchApplication(const AppLaunchData &appLaunchData, con
         }
 #ifdef CJ_FRONTEND
         if (!entryHapModuleInfo.abilityInfos.empty()) {
-            isCJApp = AbilityRuntime::CJRuntime::IsCJAbility(entryHapModuleInfo.abilityInfos.front().srcEntrance);
+            auto srcEntrancenName = entryHapModuleInfo.abilityInfos.front().srcEntrance;
+            isCJApp = AbilityRuntime::CJRuntime::IsCJAbility(srcEntrancenName);
+            AbilityRuntime::CJRuntime::SetPackageName(srcEntrancenName);
         }
 #endif
         moduelJson = entryHapModuleInfo.isModuleJson;
@@ -1502,7 +1509,9 @@ void MainThread::HandleLaunchApplication(const AppLaunchData &appLaunchData, con
             };
             runtime->SetDeviceDisconnectCallback(cb);
         }
-
+        if (appLaunchData.IsNeedPreloadModule()) {
+            PreloadModule(entryHapModuleInfo, runtime);
+        }
         auto perfCmd = appLaunchData.GetPerfCmd();
 
         int32_t pid = -1;
@@ -1579,7 +1588,7 @@ void MainThread::HandleLaunchApplication(const AppLaunchData &appLaunchData, con
                 int result = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::FRAMEWORK, "PROCESS_KILL",
                     HiviewDFX::HiSysEvent::EventType::FAULT, "PID", pid, "PROCESS_NAME", processName,
                     "MSG", KILL_REASON);
-                TAG_LOGI(AAFwkTag::APPKIT, "hisysevent write result=%{public}d, send event [FRAMEWORK,PROCESS_KILL],"
+                TAG_LOGW(AAFwkTag::APPKIT, "hisysevent write result=%{public}d, send event [FRAMEWORK,PROCESS_KILL],"
                     " pid=%{public}d, processName=%{public}s, msg=%{public}s", result, pid, processName.c_str(),
                     KILL_REASON);
 
@@ -1725,6 +1734,7 @@ void MainThread::HandleLaunchApplication(const AppLaunchData &appLaunchData, con
         TAG_LOGE(AAFwkTag::APPKIT, "applicationImpl_->PerformAppReady failed");
         return;
     }
+    FreezeUtil::GetInstance().AddAppLifecycleEvent(0, "HandleLaunchApplication:end");
     // L1 needs to add corresponding interface
     ApplicationEnvImpl *pAppEvnIml = ApplicationEnvImpl::GetInstance();
 
@@ -1760,6 +1770,65 @@ void MainThread::HandleLaunchApplication(const AppLaunchData &appLaunchData, con
 #endif
 }
 
+void MainThread::ProcessMainAbility(const AbilityInfo &info, std::unique_ptr<AbilityRuntime::Runtime>& runtime)
+{
+    std::string srcPath(info.package);
+    if (!info.isModuleJson) {
+    /* temporary compatibility api8 + config.json */
+        srcPath.append("/assets/js/");
+        if (!info.srcPath.empty()) {
+            srcPath.append(info.srcPath);
+        }
+        srcPath.append("/").append(info.name).append(".abc");
+    } else {
+        if (info.srcEntrance.empty()) {
+            TAG_LOGE(AAFwkTag::UIABILITY, "empty srcEntrance");
+            return;
+        }
+        srcPath.append("/");
+        srcPath.append(info.srcEntrance);
+        srcPath.erase(srcPath.rfind("."));
+        srcPath.append(".abc");
+        TAG_LOGD(AAFwkTag::UIABILITY, "jsAbility srcPath: %{public}s", srcPath.c_str());
+    }
+
+    std::string moduleName(info.moduleName);
+    moduleName.append("::").append(info.name);
+    bool isEsmode = info.compileMode == AppExecFwk::CompileMode::ES_MODULE;
+    runtime->PreloadMainAbility(moduleName, srcPath, info.hapPath, isEsmode, info.srcEntrance);
+}
+
+void MainThread::PreloadModule(const AppExecFwk::HapModuleInfo &entryHapModuleInfo,
+    std::unique_ptr<AbilityRuntime::Runtime>& runtime)
+{
+    TAG_LOGI(AAFwkTag::APPKIT, "preload module %{public}s", entryHapModuleInfo.moduleName.c_str());
+    bool useCommonTrunk = false;
+    for (const auto &md : entryHapModuleInfo.metadata) {
+        if (md.name == "USE_COMMON_CHUNK") {
+            useCommonTrunk = md.value == "true";
+            break;
+        }
+    }
+    bool isEsmode = entryHapModuleInfo.compileMode == AppExecFwk::CompileMode::ES_MODULE;
+    std::string srcPath(entryHapModuleInfo.name);
+    std::string moduleName(entryHapModuleInfo.moduleName);
+    moduleName.append("::").append("AbilityStage");
+    srcPath.append("/assets/js/");
+    if (entryHapModuleInfo.srcPath.empty()) {
+        srcPath.append("AbilityStage.abc");
+    } else {
+        srcPath.append(entryHapModuleInfo.srcPath);
+        srcPath.append("/AbilityStage.abc");
+    }
+    runtime->PreloadModule(moduleName, srcPath, entryHapModuleInfo.hapPath, isEsmode, useCommonTrunk);
+    for (const auto &info : entryHapModuleInfo.abilityInfos) {
+        if (info.name == entryHapModuleInfo.mainAbility) {
+            ProcessMainAbility(info, runtime);
+            return;
+        }
+    }
+}
+
 #ifdef ABILITY_LIBRARY_LOADER
 void MainThread::CalcNativeLiabraryEntries(const BundleInfo &bundleInfo, std::string &nativeLibraryPath)
 {
@@ -1819,13 +1888,17 @@ void MainThread::LoadNativeLibrary(const BundleInfo &bundleInfo, std::string &na
         TAG_LOGW(AAFwkTag::APPKIT, "No native library");
         return;
     }
-
+    char resolvedPath[PATH_MAX] = {0};
     void *handleAbilityLib = nullptr;
     for (auto fileEntry : nativeFileEntries_) {
-        if (fileEntry.empty()) {
+        if (fileEntry.empty() || fileEntry.size() >= PATH_MAX) {
             continue;
         }
-        handleAbilityLib = dlopen(fileEntry.c_str(), RTLD_NOW | RTLD_GLOBAL);
+        if (realpath(fileEntry.c_str(), resolvedPath) == nullptr) {
+            TAG_LOGE(AAFwkTag::APPKIT, "Failed to get realpath, errno = %{public}d", errno);
+            continue;
+        }
+        handleAbilityLib = dlopen(resolvedPath, RTLD_NOW | RTLD_GLOBAL);
         if (handleAbilityLib == nullptr) {
             if (fileEntry.find("libformrender.z.so") == std::string::npos) {
                 TAG_LOGE(AAFwkTag::APPKIT, "fail to dlopen %{public}s, [%{public}s]",
@@ -1904,6 +1977,10 @@ void MainThread::HandleAbilityStage(const HapModuleInfo &abilityStage)
     wptr<MainThread> weak = this;
     auto callback = [weak]() {
         auto appThread = weak.promote();
+        if (appThread == nullptr) {
+            TAG_LOGE(AAFwkTag::APPKIT, "appThread is nullptr");
+            return;
+        }
         if (!appThread->appMgr_ || !appThread->applicationImpl_) {
             TAG_LOGE(AAFwkTag::APPKIT, "appMgr_ is nullptr");
             return;
@@ -2194,6 +2271,7 @@ void MainThread::HandleCleanAbility(const sptr<IRemoteObject> &token, bool isCac
 void MainThread::HandleForegroundApplication()
 {
     HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
+    FreezeUtil::GetInstance().AddAppLifecycleEvent(0, "HandleForegroundApplication");
     TAG_LOGI(AAFwkTag::APPKIT, "called");
     if ((application_ == nullptr) || (appMgr_ == nullptr)) {
         TAG_LOGE(AAFwkTag::APPKIT, "handleForegroundApplication error!");
@@ -2201,6 +2279,7 @@ void MainThread::HandleForegroundApplication()
     }
 
     if (!applicationImpl_->PerformForeground()) {
+        FreezeUtil::GetInstance().AddAppLifecycleEvent(0, "HandleForegroundApplication fail");
         TAG_LOGE(AAFwkTag::APPKIT, "applicationImpl_->PerformForeground() failed");
     }
 
@@ -2222,7 +2301,7 @@ void MainThread::HandleBackgroundApplication()
 {
     HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
     TAG_LOGI(AAFwkTag::APPKIT, "start");
-
+    FreezeUtil::GetInstance().AddAppLifecycleEvent(0, "HandleBackgroundApplication");
     if ((application_ == nullptr) || (appMgr_ == nullptr)) {
         TAG_LOGE(AAFwkTag::APPKIT, "error");
         return;

frameworks/native/appkit/app/ohos_application.cpp

@@ -189,7 +189,7 @@ void OHOSApplication::SetApplicationContext(
             TAG_LOGE(AAFwkTag::APPKIT, "application is nullptr.");
             return;
         }
-        applicationSptr->OnFontUpdated(config);
+        applicationSptr->OnUpdateConfigurationForAll(config);
     });
 }
 
@@ -264,8 +264,6 @@ void OHOSApplication::OnConfigurationUpdated(Configuration config, AbilityRuntim
 #endif
 
     abilityRuntimeContext_->DispatchConfigurationUpdated(*configuration_);
-    abilityRuntimeContext_->SetMcc(configuration_->GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_MCC));
-    abilityRuntimeContext_->SetMnc(configuration_->GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_MNC));
     abilityRuntimeContext_->SetConfiguration(configuration_);
 }
 
@@ -275,7 +273,7 @@ void OHOSApplication::OnConfigurationUpdated(Configuration config, AbilityRuntim
  *
  * @param config Indicates the new Configuration object.
  */
-void OHOSApplication::OnFontUpdated(Configuration config)
+void OHOSApplication::OnUpdateConfigurationForAll(Configuration config)
 {
 #ifdef SUPPORT_GRAPHICS
     // Notify Window
@@ -292,7 +290,7 @@ void OHOSApplication::OnFontUpdated(Configuration config)
  *
  * @param level Indicates the memory trim level, which shows the current memory usage status.
  */
-void OHOSApplication::OnMemoryLevel(int level)
+void OHOSApplication::OnMemoryLevel(int32_t level)
 {
     TAG_LOGD(AAFwkTag::APPKIT, "called");
     if (abilityRuntimeContext_ == nullptr) {
@@ -434,19 +432,34 @@ const std::function<void()> OHOSApplication::CreateAutoStartupCallback(
     const std::function<void(const std::shared_ptr<AbilityRuntime::Context>&)>& callback)
 {
     const std::shared_ptr<AbilityInfo> &abilityInfo = abilityRecord->GetAbilityInfo();
+    if (abilityInfo == nullptr) {
+        TAG_LOGE(AAFwkTag::APPKIT, "null abilityInfo");
+        return nullptr;
+    }
     if (!IsMainProcess(abilityInfo->bundleName, abilityInfo->applicationInfo.process)) {
         return nullptr;
     }
-    std::string moduleName = abilityInfo->moduleName;
     auto application = std::static_pointer_cast<OHOSApplication>(shared_from_this());
     std::weak_ptr<OHOSApplication> weak = application;
 
-    auto autoStartupCallback = [weak, abilityStage, abilityRecord, moduleName, callback]() {
+    auto autoStartupCallback = [weak, abilityStage, abilityRecord, callback]() {
         auto ohosApplication = weak.lock();
         if (ohosApplication == nullptr) {
             TAG_LOGE(AAFwkTag::APPKIT, "null ohosApplication");
             return;
         }
+        if (abilityRecord == nullptr) {
+            TAG_LOGE(AAFwkTag::APPKIT, "null abilityRecord");
+            return;
+        }
+
+        auto abilityInfo = abilityRecord->GetAbilityInfo();
+        if (abilityInfo == nullptr) {
+            TAG_LOGE(AAFwkTag::APPKIT, "null abilityInfo");
+            return;
+        }
+
+        std::string moduleName = abilityInfo->moduleName;
         ohosApplication->AutoStartupDone(abilityRecord, abilityStage, moduleName);
         if (callback == nullptr) {
             TAG_LOGE(AAFwkTag::APPKIT, "null callback");
@@ -464,6 +477,10 @@ const std::function<void()> OHOSApplication::CreateAutoStartupCallback(
     const std::function<void()>& callback)
 {
     auto applicationInfo = abilityRuntimeContext_->GetApplicationInfo();
+    if (applicationInfo == nullptr) {
+        TAG_LOGE(AAFwkTag::APPKIT, "null applicationInfo");
+        return nullptr;
+    }
     if (!IsMainProcess(hapModuleInfo.bundleName, applicationInfo->process)) {
         return nullptr;
     }
@@ -636,7 +653,7 @@ std::shared_ptr<AbilityRuntime::Context> OHOSApplication::GetAppContext() const
     return abilityRuntimeContext_;
 }
 
-const std::unique_ptr<AbilityRuntime::Runtime>& OHOSApplication::GetRuntime()
+const std::unique_ptr<AbilityRuntime::Runtime>& OHOSApplication::GetRuntime() const
 {
     return runtime_;
 }

frameworks/native/appkit/dfr/appfreeze_inner.cpp

@@ -25,7 +25,6 @@
 #include "freeze_util.h"
 #include "hilog_tag_wrapper.h"
 #include "hitrace_meter.h"
-#include "hisysevent.h"
 #include "parameter.h"
 #include "xcollie/watchdog.h"
 #include "time_util.h"
@@ -86,6 +85,62 @@ bool AppfreezeInner::IsHandleAppfreeze()
     return !isAppDebug_;
 }
 
+void AppfreezeInner::GetMainHandlerDump(std::string& msgContent)
+{
+    auto mainHandler = appMainHandler_.lock();
+    if (mainHandler == nullptr) {
+        msgContent += "mainHandler is destructed!";
+    } else {
+        MainHandlerDumper handlerDumper;
+        msgContent += "mainHandler dump is:\n";
+        mainHandler->Dump(handlerDumper);
+        msgContent += handlerDumper.GetDumpInfo();
+    }
+}
+
+void AppfreezeInner::ChangeFaultDateInfo(FaultData& faultData, const std::string& msgContent)
+{
+    faultData.errorObject.message += msgContent;
+    faultData.faultType = FaultDataType::APP_FREEZE;
+    faultData.notifyApp = false;
+    faultData.waitSaveState = false;
+    faultData.forceExit = false;
+    bool isExit = IsExitApp(faultData.errorObject.name);
+    if (isExit) {
+        faultData.forceExit = true;
+        faultData.waitSaveState = AppRecovery::GetInstance().IsEnabled();
+        AAFwk::ExitReason exitReason = {REASON_APP_FREEZE, "Kill Reason:" + faultData.errorObject.name};
+        AbilityManagerClient::GetInstance()->RecordAppExitReason(exitReason);
+    }
+    NotifyANR(faultData);
+    if (isExit) {
+        AppFreezeRecovery();
+    }
+}
+
+void AppfreezeInner::AppfreezeHandleOverReportCount(bool isSixSecondEvent)
+{
+    FaultData faultData;
+    faultData.errorObject.message =
+        "\nFault time:" + AbilityRuntime::TimeUtil::FormatTime("%Y/%m/%d-%H:%M:%S") + "\n";
+    faultData.errorObject.message += "App main thread is not response!";
+    faultData.faultType = FaultDataType::APP_FREEZE;
+    faultData.timeoutMarkers = "";
+    if (isSixSecondEvent) {
+        faultData.errorObject.name = AppFreezeType::THREAD_BLOCK_6S;
+    } else {
+        faultData.errorObject.name = AppFreezeType::THREAD_BLOCK_3S;
+    }
+    if (!IsHandleAppfreeze()) {
+        NotifyANR(faultData);
+        return;
+    }
+    std::string msgContent;
+    GetMainHandlerDump(msgContent);
+    ChangeFaultDateInfo(faultData, msgContent);
+    return;
+}
+
 int AppfreezeInner::AppfreezeHandle(const FaultData& faultData, bool onlyMainThread)
 {
     if (!IsHandleAppfreeze()) {
@@ -120,36 +175,12 @@ bool AppfreezeInner::IsExitApp(const std::string& name)
     return false;
 }
 
-void AppfreezeInner::SendProcessKillEvent(const std::string& killReason)
-{
-    auto applicationInfo = applicationInfo_.lock();
-    if (applicationInfo != nullptr) {
-        int32_t pid = static_cast<int32_t>(getpid());
-        std::string processName = applicationInfo->process;
-        int result = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::FRAMEWORK, "PROCESS_KILL",
-            HiviewDFX::HiSysEvent::EventType::FAULT, EVENT_PID, pid,
-            EVENT_PROCESS_NAME, processName, EVENT_MESSAGE, killReason);
-        TAG_LOGI(AAFwkTag::APPDFR, "result:%{public}d,"
-            " pid:%{public}d, processName:%{public}s, msg:%{public}s", result, pid, processName.c_str(),
-            killReason.c_str());
-    }
-}
-
 int AppfreezeInner::AcquireStack(const FaultData& info, bool onlyMainThread)
 {
     HITRACE_METER_FMT(HITRACE_TAG_APP, "AppfreezeInner::AcquireStack name:%s", info.errorObject.name.c_str());
     std::string stack = "";
     std::string msgContent;
-
-    auto mainHandler = appMainHandler_.lock();
-    if (mainHandler == nullptr) {
-        msgContent += "mainHandler is destructed!";
-    } else {
-        MainHandlerDumper handlerDumper;
-        msgContent += "mainHandler dump is:\n";
-        mainHandler->Dump(handlerDumper);
-        msgContent += handlerDumper.GetDumpInfo();
-    }
+    GetMainHandlerDump(msgContent);
 
     std::lock_guard<std::mutex> lock(handlingMutex_);
     for (auto it = handlinglist_.begin(); it != handlinglist_.end(); it = handlinglist_.erase(it)) {
@@ -159,29 +190,14 @@ int AppfreezeInner::AcquireStack(const FaultData& info, bool onlyMainThread)
         if (it->state != 0) {
             FreezeUtil::LifecycleFlow flow = { it->token, static_cast<FreezeUtil::TimeoutState>(it->state) };
             faultData.errorObject.message += "client:\n" +
-                FreezeUtil::GetInstance().GetLifecycleEvent(flow) + "\n";
+                FreezeUtil::GetInstance().GetLifecycleEvent(flow) + "\nclient app:\n" +
+                FreezeUtil::GetInstance().GetAppLifecycleEvent(0) + "\n";
         }
-        faultData.errorObject.message += msgContent;
         faultData.errorObject.stack = stack;
         faultData.errorObject.name = it->errorObject.name;
-        faultData.faultType = FaultDataType::APP_FREEZE;
         faultData.timeoutMarkers = it->timeoutMarkers;
-        faultData.notifyApp = false;
-        faultData.waitSaveState = false;
-        faultData.forceExit = false;
         faultData.eventId = it->eventId;
-        bool isExit = IsExitApp(it->errorObject.name);
-        if (isExit) {
-            faultData.forceExit = true;
-            faultData.waitSaveState = AppRecovery::GetInstance().IsEnabled();
-            AAFwk::ExitReason exitReason = {REASON_APP_FREEZE, "Kill Reason:" + faultData.errorObject.name};
-            AbilityManagerClient::GetInstance()->RecordAppExitReason(exitReason);
-            SendProcessKillEvent("Kill Reason:" + faultData.errorObject.name);
-        }
-        NotifyANR(faultData);
-        if (isExit) {
-            AppFreezeRecovery();
-        }
+        ChangeFaultDateInfo(faultData, msgContent);
     }
     return 0;
 }

frameworks/native/appkit/dfr/appfreeze_state.cpp

@@ -16,6 +16,7 @@
 #include "appfreeze_inner.h"
 #include "appfreeze_state.h"
 #include "hilog_tag_wrapper.h"
+#include "xcollie/watchdog.h"
 
 namespace OHOS {
 namespace AbilityRuntime {
@@ -35,6 +36,7 @@ void AppFreezeState::SetAppFreezeState(uint32_t flag)
     appFreezeStateFlag_ |= flag;
     if (appFreezeStateFlag_ > 0) {
         inner->SetAppDebug(true);
+        OHOS::HiviewDFX::Watchdog::GetInstance().SetAppDebug(true);
     }
     TAG_LOGD(AAFwkTag::APPDFR, "App state flag: %{public}u, SetAppDebug true", appFreezeStateFlag_);
 }
@@ -50,6 +52,7 @@ void AppFreezeState::CancelAppFreezeState(uint32_t flag)
     appFreezeStateFlag_ &= ~flag;
     if (appFreezeStateFlag_ == 0) {
         inner->SetAppDebug(false);
+        OHOS::HiviewDFX::Watchdog::GetInstance().SetAppDebug(false);
     }
     TAG_LOGD(AAFwkTag::APPDFR, "App state flag: %{public}u, SetAppDebug false", appFreezeStateFlag_);
 }

frameworks/native/appkit/dfr/watchdog.cpp

@@ -32,6 +32,7 @@ constexpr uint32_t CHECK_MAIN_THREAD_IS_ALIVE = 1;
 constexpr int RESET_RATIO = 2;
 
 constexpr int32_t BACKGROUND_REPORT_COUNT_MAX = 5;
+constexpr int32_t WATCHDOG_REPORT_COUNT_MAX = 5;
 #ifdef SUPPORT_ASAN
 constexpr uint32_t CHECK_INTERVAL_TIME = 45000;
 #else
@@ -107,6 +108,7 @@ void Watchdog::AllowReportEvent()
     needReport_.store(true);
     isSixSecondEvent_.store(false);
     backgroundReportCount_.store(0);
+    watchdogReportCount_.store(0);
 }
 
 bool Watchdog::IsReportEvent()
@@ -139,7 +141,19 @@ void Watchdog::Timer()
         return;
     }
     if (!needReport_) {
-        TAG_LOGE(AAFwkTag::APPDFR, "timeout, wait to recover");
+        watchdogReportCount_++;
+        TAG_LOGE(AAFwkTag::APPDFR, "timeout, wait to recover, wait count: %{public}d",
+            watchdogReportCount_.load());
+        if (watchdogReportCount_.load() >= WATCHDOG_REPORT_COUNT_MAX) {
+#ifndef APP_NO_RESPONSE_DIALOG
+            AppExecFwk::AppfreezeInner::GetInstance()->AppfreezeHandleOverReportCount(true);
+#endif
+            watchdogReportCount_.store(0);
+        } else if (watchdogReportCount_.load() >= (WATCHDOG_REPORT_COUNT_MAX - 1)) {
+#ifndef APP_NO_RESPONSE_DIALOG
+            AppExecFwk::AppfreezeInner::GetInstance()->AppfreezeHandleOverReportCount(false);
+#endif
+        }
         return;
     }
 

frameworks/native/runtime/cj_runtime.cpp

@@ -69,6 +69,8 @@ CJEnvMethods* CJEnv::LoadInstance()
 }
 AppLibPathVec CJRuntime::appLibPaths_;
 
+std::string CJRuntime::packageName_;
+
 std::unique_ptr<CJRuntime> CJRuntime::Create(const Options& options)
 {
     auto instance = std::make_unique<CJRuntime>();
@@ -152,10 +154,13 @@ bool CJRuntime::LoadCJAppLibrary(const AppLibPathVec& appLibPaths)
         return false;
     }
     void* handle = nullptr;
+    // According to the OHOS rule, the format of the SO name is as follows
+    auto targetSoName = "lib" + packageName_ + ".so";
+
     for (const auto& libPath : appLibPaths) {
         for (auto& itor : std::filesystem::directory_iterator(libPath)) {
             // According to the convention, the names of cj generated products must contain the following keywords
-            if (itor.path().string().find("ohos_app_cangjie") == std::string::npos) {
+            if (itor.path().string().find(targetSoName) == std::string::npos) {
                 continue;
             }
             handle = cjEnv->loadCJLibrary(itor.path().c_str());
@@ -171,6 +176,13 @@ bool CJRuntime::LoadCJAppLibrary(const AppLibPathVec& appLibPaths)
     return true;
 }
 
+void CJRuntime::SetPackageName(std::string srcEntryName)
+{
+    // According to the srcEntry rule in the Cangjie application,
+    // the last '.' The previous strings were all package names
+    packageName_ = srcEntryName.substr(0, srcEntryName.find_last_of("."));
+}
+
 void CJRuntime::SetSanitizerVersion(SanitizerKind kind)
 {
     auto cjEnv = OHOS::CJEnv::LoadInstance();

frameworks/native/runtime/js_runtime.cpp

@@ -1268,6 +1268,37 @@ void JsRuntime::PreloadSystemModule(const std::string& moduleName)
     napi_call_function(env, globalObj, refValue, 1, args, nullptr);
 }
 
+void JsRuntime::PreloadMainAbility(const std::string& moduleName, const std::string& srcPath,
+    const std::string& hapPath,  bool isEsMode, const std::string& srcEntrance)
+{
+    HandleScope handleScope(*this);
+    std::string key(moduleName);
+    key.append("::");
+    key.append(srcPath);
+    TAG_LOGD(AAFwkTag::JSRUNTIME, "PreloadMainAbility srcPath: %{public}s", srcPath.c_str());
+    preloadList_[key] = LoadModule(moduleName, srcPath, hapPath, isEsMode, false, srcEntrance);
+}
+
+void JsRuntime::PreloadModule(const std::string& moduleName, const std::string& srcPath,
+    const std::string& hapPath, bool isEsMode, bool useCommonTrunk)
+{
+    std::string key(moduleName);
+    key.append("::");
+    key.append(srcPath);
+    TAG_LOGD(AAFwkTag::JSRUNTIME, "PreloadModule srcPath: %{public}s", srcPath.c_str());
+    preloadList_[key] = LoadModule(moduleName, srcPath, hapPath, isEsMode, useCommonTrunk);
+}
+
+bool JsRuntime::PopPreloadObj(const std::string& key, std::unique_ptr<NativeReference>& obj)
+{
+    if (preloadList_.find(key) == preloadList_.end()) {
+        return false;
+    }
+    obj = std::move(preloadList_[key]);
+    preloadList_.erase(key);
+    return true;
+}
+
 NativeEngine& JsRuntime::GetNativeEngine() const
 {
     return *GetNativeEnginePointer();

frameworks/native/runtime/ohos_js_environment_impl.cpp

@@ -16,11 +16,11 @@
 #include "ohos_js_environment_impl.h"
 
 #include "console.h"
-#include "timer.h"
 #include "hilog_tag_wrapper.h"
 #include "js_utils.h"
 #include "js_worker.h"
 #include "ohos_loop_handler.h"
+#include "sys_timer.h"
 
 namespace OHOS {
 namespace AbilityRuntime {

frameworks/simulator/ability_simulator/BUILD.gn

@@ -119,6 +119,7 @@ ohos_shared_library("ability_simulator_inner") {
 
     if (ability_runtime_graphics) {
       external_deps += [
+        "ace_engine:ace_uicontent",
         "window_manager:previewer_window",
         "window_manager:previewer_window_napi",
       ]

frameworks/simulator/ability_simulator/src/simulator.cpp

@@ -25,8 +25,8 @@
 #include "ability_context.h"
 #include "ability_stage_context.h"
 #include "bundle_container.h"
-#include "timer.h"
 #include "console.h"
+#include "declarative_module_preloader.h"
 #include "hilog_tag_wrapper.h"
 #include "js_ability_context.h"
 #include "js_ability_stage_context.h"
@@ -42,6 +42,7 @@
 #include "native_engine/impl/ark/ark_native_engine.h"
 #include "resource_manager.h"
 #include "window_scene.h"
+#include "sys_timer.h"
 
 extern const char _binary_jsMockSystemPlugin_abc_start[];
 extern const char _binary_jsMockSystemPlugin_abc_end[];
@@ -55,6 +56,7 @@ constexpr size_t DEFAULT_GC_THREAD_NUM = 7;
 constexpr size_t DEFAULT_LONG_PAUSE_TIME = 40;
 
 constexpr char BUNDLE_INSTALL_PATH[] = "/data/storage/el1/bundle/";
+constexpr char MERGE_ABC_PATH[] = "/ets/modules.abc";
 const std::string PACKAGE_NAME = "packageName";
 const std::string BUNDLE_NAME = "bundleName";
 const std::string MODULE_NAME = "moduleName";
@@ -125,6 +127,7 @@ private:
     void LoadJsMock(const std::string &fileName);
     void ReportJsError(napi_value obj);
     std::string GetNativeStrFromJsTaggedObj(napi_value obj, const char* key);
+    void CreateStageContext();
 
     panda::ecmascript::EcmaVM *CreateJSVM();
     Options options_;
@@ -133,6 +136,7 @@ private:
     DebuggerTask debuggerTask_;
     napi_env nativeEngine_ = nullptr;
     TerminateCallback terminateCallback_;
+    bool isOhmUrl_ = false;
 
     int64_t currentId_ = 0;
     std::unordered_map<int64_t, std::shared_ptr<NativeReference>> abilities_;
@@ -243,7 +247,13 @@ void CallObjectMethod(napi_env env, napi_value obj, const char *name, napi_value
 
 napi_value SimulatorImpl::LoadScript(const std::string &srcPath)
 {
-    panda::Local<panda::ObjectRef> objRef = panda::JSNApi::GetExportObject(vm_, srcPath, "default");
+    panda::Local<panda::ObjectRef> objRef;
+    if (isOhmUrl_) {
+        objRef = panda::JSNApi::GetExportObjectFromOhmUrl(vm_, srcPath, "default");
+    } else {
+        objRef = panda::JSNApi::GetExportObject(vm_, srcPath, "default");
+    }
+
     if (objRef->IsNull()) {
         TAG_LOGE(AAFwkTag::ABILITY_SIM, "Get export object failed");
         return nullptr;
@@ -312,7 +322,7 @@ bool SimulatorImpl::ParseAbilityInfo(const std::string &abilitySrcPath, const st
         abilityInfo_ = AppExecFwk::BundleContainer::GetInstance().GetAbilityInfo(
             options_.moduleName, abilityNameFromPath);
     }
-    
+
     if (abilityInfo_ == nullptr) {
         TAG_LOGE(AAFwkTag::ABILITY_SIM, "ability info parse failed");
         return false;
@@ -332,14 +342,7 @@ int64_t SimulatorImpl::StartAbility(
         return -1;
     }
 
-    if (stageContext_ == nullptr) {
-        stageContext_ = std::make_shared<AbilityStageContext>();
-        stageContext_->SetOptions(options_);
-        stageContext_->SetConfiguration(options_.configuration);
-        stageContext_->SetApplicationInfo(appInfo_);
-        stageContext_->SetHapModuleInfo(moduleInfo_);
-    }
-
+    CreateStageContext();
     std::ifstream stream(options_.modulePath, std::ios::ate | std::ios::binary);
     if (!stream.is_open()) {
         TAG_LOGE(AAFwkTag::ABILITY_SIM, "open:%{public}s failed", options_.modulePath.c_str());
@@ -358,13 +361,24 @@ int64_t SimulatorImpl::StartAbility(
         return -1;
     }
 
-    abilityPath_ = BUNDLE_INSTALL_PATH + options_.moduleName + "/" + abilitySrcPath;
-    if (!reinterpret_cast<NativeEngine*>(nativeEngine_)->RunScriptBuffer(abilityPath_, buf, len, false)) {
-        TAG_LOGE(AAFwkTag::ABILITY_SIM, "run script:%{public}s failed", abilityPath_.c_str());
-        return -1;
+    isOhmUrl_ = panda::JSNApi::IsOhmUrl(abilitySrcPath);
+    napi_value instanceValue = nullptr;
+    if (isOhmUrl_) {
+        std::string srcFilename = "";
+        srcFilename = BUNDLE_INSTALL_PATH + options_.moduleName + MERGE_ABC_PATH;
+        if (!panda::JSNApi::ExecuteSecureWithOhmUrl(vm_, buf, len, srcFilename, abilitySrcPath)) {
+            return -1;
+        }
+        instanceValue = LoadScript(abilitySrcPath);
+    } else {
+        abilityPath_ = BUNDLE_INSTALL_PATH + options_.moduleName + "/" + abilitySrcPath;
+        if (!reinterpret_cast<NativeEngine*>(nativeEngine_)->RunScriptBuffer(abilityPath_, buf, len, false)) {
+            TAG_LOGE(AAFwkTag::ABILITY_SIM, "run script:%{public}s failed", abilityPath_.c_str());
+            return -1;
+        }
+        instanceValue = LoadScript(abilityPath_);
     }
 
-    napi_value instanceValue = LoadScript(abilityPath_);
     if (instanceValue == nullptr) {
         TAG_LOGE(AAFwkTag::ABILITY_SIM, "create object instance failed");
         return -1;
@@ -715,6 +729,7 @@ bool SimulatorImpl::OnInit()
         self->terminateCallback_(self->currentId_);
     };
     nativeEngine->RegisterNapiUncaughtExceptionHandler(uncaughtTask);
+    Ace::DeclarativeModulePreloader::Preload(*nativeEngine);
 
     napi_value globalObj;
     napi_get_global(env, &globalObj);
@@ -985,5 +1000,16 @@ void SimulatorImpl::ReportJsError(napi_value obj)
     summary += "Stacktrace:\n" + errorStack;
     TAG_LOGE(AAFwkTag::ABILITY_SIM, "summary:\n%{public}s", summary.c_str());
 }
+
+void SimulatorImpl::CreateStageContext()
+{
+    if (stageContext_ == nullptr) {
+        stageContext_ = std::make_shared<AbilityStageContext>();
+        stageContext_->SetOptions(options_);
+        stageContext_->SetConfiguration(options_.configuration);
+        stageContext_->SetApplicationInfo(appInfo_);
+        stageContext_->SetHapModuleInfo(moduleInfo_);
+    }
+}
 } // namespace AbilityRuntime
 } // namespace OHOS

interfaces/inner_api/ability_manager/BUILD.gn

@@ -129,6 +129,7 @@ ohos_shared_library("ability_manager") {
     ":process_options",
     ":start_window_option",
     "${ability_runtime_innerkits_path}/app_manager:app_manager",
+    "${ability_runtime_path}/utils/global/freeze:freeze_util",
     "${ability_runtime_services_path}/abilitymgr:wantagent_manager",
   ]
 
@@ -389,6 +390,7 @@ ohos_shared_library("ability_connect_callback_stub") {
   include_dirs = [
     "include/",
     "${ability_base_kits_path}/want/include",
+    "${ability_runtime_services_path}/abilitymgr/include/utils",
     "${ability_runtime_services_path}/abilitymgr/include",
     "${ability_runtime_services_path}/common/include",
   ]

interfaces/inner_api/ability_manager/include/process_options.h

@@ -51,6 +51,7 @@ public:
     static bool IsAttachToStatusBarMode(ProcessMode value);
     static bool IsValidProcessMode(ProcessMode value);
     static bool IsNoAttachmentMode(ProcessMode value);
+    static bool IsAttachToStatusBarItemMode(ProcessMode value);
 
     ProcessMode processMode = ProcessMode::UNSPECIFIED;
     StartupVisibility startupVisibility = StartupVisibility::UNSPECIFIED;

interfaces/inner_api/app_manager/include/appmgr/ams_mgr_interface.h

@@ -171,16 +171,19 @@ public:
      *
      * @param  bundleName, bundle name in Application record.
      * @param  userId, userId.
+     * @param  reason, caller function name.
      * @return ERR_OK, return back success, others fail.
      */
-    virtual int KillApplicationByUid(const std::string &bundleName, const int uid) = 0;
+    virtual int KillApplicationByUid(const std::string &bundleName, const int uid,
+        const std::string& reason = "KillApplicationByUid") = 0;
 
     /**
      * Kill the application self.
      *
      * @return Returns ERR_OK on success, others on failure.
      */
-    virtual int KillApplicationSelf(const bool clearPageStack = false)
+    virtual int KillApplicationSelf(const bool clearPageStack = false,
+        const std::string& reason = "KillApplicationSelf")
     {
         return ERR_OK;
     }

interfaces/inner_api/app_manager/include/appmgr/ams_mgr_proxy.h

@@ -162,11 +162,14 @@ public:
      *
      * @param  bundleName, bundle name in Application record.
      * @param  uid, uid.
+     * @param  reason, caller function name.
      * @return ERR_OK, return back success, others fail.
      */
-    virtual int32_t KillApplicationByUid(const std::string &bundleName, const int uid) override;
+    virtual int32_t KillApplicationByUid(const std::string &bundleName, const int uid,
+        const std::string& reason = "KillApplicationByUid") override;
 
-    virtual int KillApplicationSelf(const bool clearPageStack = false) override;
+    virtual int KillApplicationSelf(const bool clearPageStack = false,
+        const std::string& reason = "KillApplicationSelf") override;
 
     /**
      * Get application info by process id.

interfaces/inner_api/app_manager/include/appmgr/app_launch_data.h

@@ -256,6 +256,19 @@ public:
      */
     bool isNativeStart() const;
 
+    /**
+     * @brief Setting is need preload module.
+     *
+     * @param isNeedPreloadModule, is need preload module.
+     */
+    void SetIsNeedPreloadModule(bool isNeedPreloadModule);
+    /**
+     * @brief Obtains  is need preload module..
+     *
+     * @return Returns  is need preload module..
+     */
+    bool IsNeedPreloadModule() const;
+
 private:
     ApplicationInfo applicationInfo_;
     Profile profile_;
@@ -272,6 +285,7 @@ private:
     bool isErrorInfoEnhance_ = false;
     std::string appRunningUniqueId_;
     std::string instanceKey_;
+    bool isNeedPreloadModule_ = false;
 };
 }  // namespace AppExecFwk
 }  // namespace OHOS

interfaces/inner_api/app_manager/include/appmgr/app_mgr_client.h

@@ -185,16 +185,19 @@ public:
      *
      * @param  bundleName, bundle name in Application record.
      * @param  uid, uid.
+     * @param  reason, caller function name.
      * @return ERR_OK, return back success, others fail.
      */
-    virtual AppMgrResultCode KillApplicationByUid(const std::string &bundleName, const int uid);
+    virtual AppMgrResultCode KillApplicationByUid(const std::string &bundleName, const int uid,
+        const std::string& reason = "KillApplicationByUid");
 
     /**
      * Kill the application self.
      *
      * @return Returns ERR_OK on success, others on failure.
      */
-    virtual AppMgrResultCode KillApplicationSelf(const bool clearPageStack = false);
+    virtual AppMgrResultCode KillApplicationSelf(const bool clearPageStack = false,
+        const std::string& reason = "KillApplicationSelf");
 
     /**
      * ClearUpApplicationData, call ClearUpApplicationData() through proxy project,

interfaces/inner_api/app_manager/include/appmgr/app_mgr_constants.h

@@ -98,6 +98,7 @@ enum class AppStartType {
 enum class PreloadMode {
     PRESS_DOWN = 0,
     PRE_MAKE = 1,
+    PRELOAD_MODULE = 2,
 };
 
 enum class PreloadState {

interfaces/inner_api/app_manager/include/appmgr/app_mgr_interface.h

@@ -729,11 +729,11 @@ public:
 
     /**
      * @brief mark a process which is going restart.
-     * @param bundleName the bundleName of the process.
+     * @param uid the uid of the process.
      *
      * @return Returns ERR_OK on success, others on failure.
      */
-    virtual int32_t SignRestartAppFlag(const std::string &bundleName)
+    virtual int32_t SignRestartAppFlag(int32_t uid)
     {
         return 0;
     }
@@ -854,6 +854,17 @@ public:
      * @return Returns ERR_OK on success, others on failure.
      */
     virtual int32_t GetSupportedProcessCachePids(const std::string &bundleName, std::vector<int32_t> &pidList) = 0;
+
+    /**
+     * Get appIndex of pid.
+     * @param pid The pid.
+     * @param appIndex appIndex of pid.
+     * @return Returns ERR_OK on success, others on failure.
+     */
+    virtual int32_t GetAppIndexByPid(pid_t pid, int32_t &appIndex)
+    {
+        return 0;
+    }
 };
 }  // namespace AppExecFwk
 }  // namespace OHOS

interfaces/inner_api/app_manager/include/appmgr/app_mgr_ipc_interface_code.h

@@ -117,6 +117,7 @@ enum class AppMgrInterfaceCode {
     CHECK_IS_KIA_PROCESS = 91,
     GET_All_RUNNING_INSTANCE_KEYS_BY_BUNDLENAME = 92,
     GET_All_RUNNING_INSTANCE_KEYS_BY_SELF = 93,
+    GET_APP_INDEX_BY_PID = 94,
 };
 } // AppExecFwk
 } // OHOS

interfaces/inner_api/app_manager/include/appmgr/app_mgr_proxy.h

@@ -640,11 +640,11 @@ public:
 
     /**
      * @brief mark a process which is going restart.
-     * @param bundleName the bundleName of the process.
+     * @param uid the uid of the process.
      *
      * @return Returns ERR_OK on success, others on failure.
      */
-    int32_t SignRestartAppFlag(const std::string &bundleName) override;
+    int32_t SignRestartAppFlag(int32_t uid) override;
 
     /**
      * Get appRunningUniqueId by pid.
@@ -739,6 +739,8 @@ public:
      */
     virtual int32_t GetSupportedProcessCachePids(const std::string &bundleName,
         std::vector<int32_t> &pidList) override;
+
+    virtual int32_t GetAppIndexByPid(pid_t pid, int32_t &appIndex) override;
 private:
     bool SendTransactCmd(AppMgrInterfaceCode code, MessageParcel &data, MessageParcel &reply);
     bool WriteInterfaceToken(MessageParcel &data);

interfaces/inner_api/app_manager/include/appmgr/app_mgr_stub.h

@@ -158,6 +158,7 @@ private:
     int32_t HandleNotifyProcessDependedOnWeb(MessageParcel &data, MessageParcel &reply);
     int32_t HandleKillProcessDependedOnWeb(MessageParcel &data, MessageParcel &reply);
     int32_t HandleRestartResidentProcessDependedOnWeb(MessageParcel &data, MessageParcel &reply);
+    int32_t HandleGetAppIndexByPid(MessageParcel &data, MessageParcel &reply);
     int32_t OnRemoteRequestInner(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option);
     int32_t OnRemoteRequestInnerFirst(uint32_t code, MessageParcel &data,
         MessageParcel &reply, MessageOption &option);

interfaces/inner_api/app_manager/include/appmgr/process_data.h

@@ -67,6 +67,7 @@ struct ProcessData : public Parcelable {
     int32_t exitReason = 0;
     std::string exitMsg = "";
     int32_t childUid = -1;
+    bool isPreload = false;
 };
 }  // namespace AppExecFwk
 }  // namespace OHOS