merge

Signed-off-by: zzhcharmer <zhouzhenhui3@h-partners.com>

frameworks/js/napi/app/application_context/application_context.js

@@ -200,6 +200,14 @@ class ApplicationContext {
   getCurrentAppCloneIndex() {
     return this.__context_impl__.getCurrentAppCloneIndex();
   }
+
+  getCurrentInstanceKey() {
+    return this.__context_impl__.getCurrentInstanceKey();
+  }
+
+  getAllRunningInstanceKeys() {
+    return this.__context_impl__.getAllRunningInstanceKeys();
+  }
   
   set area(mode) {
     return this.__context_impl__.switchArea(mode);

frameworks/js/napi/app/js_app_manager/js_app_manager_utils.cpp

@@ -165,7 +165,10 @@ napi_value CreateJsRunningMultiAppInfo(napi_env env, const RunningMultiAppInfo &
     }
     napi_set_named_property(env, object, "bundleName", CreateJsValue(env, info.bundleName));
     napi_set_named_property(env, object, "mode", CreateJsValue(env, info.mode));
-    napi_set_named_property(env, object, "runningAppClones", CreateJsRunningAppCloneArray(env, info.runningAppClones));
+    napi_set_named_property(env, object, "runningAppClones",
+        CreateJsRunningAppCloneArray(env, info.runningAppClones));
+    napi_set_named_property(env, object, "runningMultiInstances",
+        CreateJsRunningMultiInstanceInfosArray(env, info.runningMultiIntanceInfos));
 
     return object;
 }
@@ -181,6 +184,17 @@ napi_value CreateJsRunningAppCloneArray(napi_env env, const std::vector<RunningA
     return arrayValue;
 }
 
+napi_value CreateJsRunningMultiInstanceInfosArray(napi_env env, const std::vector<RunningMultiInstanceInfo>& data)
+{
+    napi_value arrayValue = nullptr;
+    napi_create_array_with_length(env, data.size(), &arrayValue);
+    uint32_t index = 0;
+    for (const auto &item : data) {
+        napi_set_element(env, arrayValue, index++, CreateJsRunningMultiInstanceInfo(env, item));
+    }
+    return arrayValue;
+}
+
 napi_value CreateJsRunningAppClone(napi_env env, const RunningAppClone &info)
 {
     napi_value object = nullptr;
@@ -196,6 +210,21 @@ napi_value CreateJsRunningAppClone(napi_env env, const RunningAppClone &info)
     return object;
 }
 
+napi_value CreateJsRunningMultiInstanceInfo(napi_env env, const RunningMultiInstanceInfo &info)
+{
+    napi_value object = nullptr;
+    napi_create_object(env, &object);
+    if (object == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "null obj");
+        return nullptr;
+    }
+    napi_set_named_property(env, object, "instanceKey", CreateJsValue(env, info.instanceKey));
+    napi_set_named_property(env, object, "uid", CreateJsValue(env, info.uid));
+    napi_set_named_property(env, object, "pids", CreateNativeArray(env, info.pids));
+
+    return object;
+}
+
 napi_value ApplicationStateInit(napi_env env)
 {
     TAG_LOGD(AAFwkTag::APPMGR, "called");

frameworks/js/napi/app/js_app_manager/js_app_manager_utils.h

@@ -32,6 +32,7 @@ using OHOS::AppExecFwk::ProcessData;
 using OHOS::AppExecFwk::RunningProcessInfo;
 using OHOS::AppExecFwk::RunningMultiAppInfo;
 using OHOS::AppExecFwk::RunningAppClone;
+using OHOS::AppExecFwk::RunningMultiInstanceInfo;
 #ifdef SUPPORT_GRAPHICS
 using OHOS::AppExecFwk::AbilityFirstFrameStateData;
 #endif
@@ -69,6 +70,8 @@ JsAppProcessState ConvertToJsAppProcessState(
 napi_value CreateJsRunningMultiAppInfo(napi_env env, const RunningMultiAppInfo &info);
 napi_value CreateJsRunningAppCloneArray(napi_env env, const std::vector<RunningAppClone>& data);
 napi_value CreateJsRunningAppClone(napi_env env, const RunningAppClone &info);
+napi_value CreateJsRunningMultiInstanceInfosArray(napi_env env, const std::vector<RunningMultiInstanceInfo>& data);
+napi_value CreateJsRunningMultiInstanceInfo(napi_env env, const RunningMultiInstanceInfo &info);
 }  // namespace AbilityRuntime
 }  // namespace OHOS
 #endif // OHOS_ABILITY_RUNTIME_JS_APP_MANAGER_UTILS_H

frameworks/native/ability/native/ability_business_error/ability_business_error.cpp

@@ -89,6 +89,11 @@ constexpr const char* ERROR_MSG_EXTENSION_START_THIRD_PARTY_APP_CONTROLLED =
     "The extension can not start the specified third party application.";
 constexpr const char* ERROR_MSG_EXTENSION_START_SERVICE_CONTROLLED = "The extension can not start the service.";
 constexpr const char* ERROR_MSG_FREE_INSTALL_TASK_NOT_EXIST = "The target free install task does not exist.";
+constexpr const char* ERROR_MSG_MULTI_INSTANCE_NOT_SUPPORTED = "Multi-instance is not supported.";
+constexpr const char* ERROR_MSG_INVALID_APP_INSTANCE_KEY = "The app instance key does not exist.";
+constexpr const char* ERROR_MSG_UPPER_LIMIT = "The number of app instances reaches the limit.";
+constexpr const char* ERROR_MSG_APP_INSTANCE_KEY_NOT_SUPPORT = "The APP_INSTANCE_KEY cannot be specified.";
+constexpr const char* ERROR_MSG_CREATE_NEW_INSTANCE_NOT_SUPPORT = "Creating a new instance is not supported.";
 
 // follow ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST of appexecfwk_errors.h in bundle_framework
 constexpr int32_t ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST = 8521220;
@@ -150,7 +155,12 @@ static std::unordered_map<AbilityErrorCode, const char*> ERR_CODE_MAP = {
         ERROR_MSG_EXTENSION_START_THIRD_PARTY_APP_CONTROLLED },
     { AbilityErrorCode::ERROR_CODE_EXTENSION_START_SERVICE_CONTROLLED, ERROR_MSG_EXTENSION_START_SERVICE_CONTROLLED},
     { AbilityErrorCode::ERROR_CODE_BUNDLE_NAME_INVALID, ERROR_MSG_TARGET_BUNDLE_NOT_EXIST},
-    { AbilityErrorCode::ERROR_CODE_FREE_INSTALL_TASK_NOT_EXIST, ERROR_MSG_FREE_INSTALL_TASK_NOT_EXIST }
+    { AbilityErrorCode::ERROR_CODE_FREE_INSTALL_TASK_NOT_EXIST, ERROR_MSG_FREE_INSTALL_TASK_NOT_EXIST },
+    { AbilityErrorCode::ERROR_MULTI_INSTANCE_NOT_SUPPORTED, ERROR_MSG_MULTI_INSTANCE_NOT_SUPPORTED },
+    { AbilityErrorCode::ERROR_CODE_INVALID_APP_INSTANCE_KEY, ERROR_MSG_INVALID_APP_INSTANCE_KEY },
+    { AbilityErrorCode::ERROR_CODE_UPPER_LIMIT, ERROR_MSG_UPPER_LIMIT },
+    { AbilityErrorCode::ERROR_CODE_APP_INSTANCE_KEY_NOT_SUPPORT, ERROR_MSG_APP_INSTANCE_KEY_NOT_SUPPORT },
+    { AbilityErrorCode::ERROR_CODE_CREATE_NEW_INSTANCE_NOT_SUPPORT, ERROR_MSG_CREATE_NEW_INSTANCE_NOT_SUPPORT },
 };
 
 static std::unordered_map<int32_t, AbilityErrorCode> INNER_TO_JS_ERROR_CODE_MAP {
@@ -215,6 +225,12 @@ static std::unordered_map<int32_t, AbilityErrorCode> INNER_TO_JS_ERROR_CODE_MAP
     {EXTENSION_BLOCKED_BY_SERVICE_LIST, AbilityErrorCode::ERROR_CODE_EXTENSION_START_SERVICE_CONTROLLED},
     {ERR_BUNDLE_NOT_EXIST, AbilityErrorCode::ERROR_CODE_BUNDLE_NAME_INVALID},
     {ERR_FREE_INSTALL_TASK_NOT_EXIST, AbilityErrorCode::ERROR_CODE_FREE_INSTALL_TASK_NOT_EXIST},
+    {ERR_MULTI_INSTANCE_NOT_SUPPORTED, AbilityErrorCode::ERROR_MULTI_INSTANCE_NOT_SUPPORTED},
+    {ERR_NOT_SUPPORT_APP_CLONE, AbilityErrorCode::ERROR_NOT_APP_CLONE},
+    {ERR_INVALID_APP_INSTANCE_KEY, AbilityErrorCode::ERROR_CODE_INVALID_APP_INSTANCE_KEY},
+    {ERR_UPPER_LIMIT, AbilityErrorCode::ERROR_CODE_UPPER_LIMIT},
+    {ERR_APP_INSTANCE_KEY_NOT_SUPPORT, AbilityErrorCode::ERROR_CODE_APP_INSTANCE_KEY_NOT_SUPPORT},
+    {ERR_CREATE_NEW_INSTANCE_NOT_SUPPORT, AbilityErrorCode::ERROR_CODE_CREATE_NEW_INSTANCE_NOT_SUPPORT},
 };
 }
 

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

@@ -598,6 +598,12 @@ int32_t ApplicationContext::GetProcessRunningInformation(AppExecFwk::RunningProc
     return (contextImpl_ != nullptr) ? contextImpl_->GetProcessRunningInformation(info) : -1;
 }
 
+int32_t ApplicationContext::GetAllRunningInstanceKeys(const std::string& bundleName,
+    std::vector<std::string> &instanceKeys)
+{
+    return (contextImpl_ != nullptr) ? contextImpl_->GetAllRunningInstanceKeys(bundleName, instanceKeys) : -1;
+}
+
 bool ApplicationContext::IsUpdatingConfigurations()
 {
     return (contextImpl_ != nullptr) ? contextImpl_->IsUpdatingConfigurations() : false;
@@ -826,6 +832,11 @@ int32_t ApplicationContext::GetCurrentAppMode()
     return appMode_;
 }
 
+std::string ApplicationContext::GetCurrentInstanceKey()
+{
+    TAG_LOGD(AAFwkTag::APPKIT, "getCurrentInstanceKey is %{public}s", instanceKey_.c_str());
+    return instanceKey_;
+}
 
 void ApplicationContext::SetAppRunningUniqueId(const std::string &appRunningUniqueId)
 {
@@ -854,6 +865,12 @@ void ApplicationContext::SetCurrentAppMode(int32_t appMode)
     appMode_ = appMode;
 }
 
+void ApplicationContext::SetCurrentInstanceKey(const std::string& instanceKey)
+{
+    TAG_LOGD(AAFwkTag::APPKIT, "setCurrentInstanceKey is %{public}s", instanceKey.c_str());
+    instanceKey_ = instanceKey;
+}
+
 void ApplicationContext::ProcessSecurityExit(const AAFwk::ExitReason &exitReason)
 {
     if (appProcessExitCallback_ == nullptr) {

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

@@ -1239,6 +1239,15 @@ int32_t ContextImpl::GetProcessRunningInformation(AppExecFwk::RunningProcessInfo
     return result;
 }
 
+int32_t ContextImpl::GetAllRunningInstanceKeys(const std::string& bundleName,
+    std::vector<std::string> &instanceKeys)
+{
+    auto appMgrClient = DelayedSingleton<AppExecFwk::AppMgrClient>::GetInstance();
+    auto result = appMgrClient->GetAllRunningInstanceKeysByBundleName(bundleName, instanceKeys);
+    TAG_LOGD(AAFwkTag::APPKIT, "result is %{public}d", result);
+    return result;
+}
+
 int32_t ContextImpl::RestartApp(const AAFwk::Want& want)
 {
     auto result = OHOS::AAFwk::AbilityManagerClient::GetInstance()->RestartApp(want);

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

@@ -938,6 +938,70 @@ napi_value JsApplicationContextUtils::OnGetCurrentAppCloneIndex(napi_env env, Na
     return CreateJsValue(env, appIndex);
 }
 
+napi_value JsApplicationContextUtils::GetCurrentInstanceKey(napi_env env, napi_callback_info info)
+{
+    GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
+        OnGetCurrentInstanceKey, APPLICATION_CONTEXT_NAME);
+}
+
+napi_value JsApplicationContextUtils::OnGetCurrentInstanceKey(napi_env env, NapiCallbackInfo& info)
+{
+    TAG_LOGD(AAFwkTag::APPKIT, "Get current instance key");
+    auto context = applicationContext_.lock();
+    if (context == nullptr) {
+        TAG_LOGE(AAFwkTag::APPKIT, "context is nullptr.");
+        ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT);
+        return CreateJsUndefined(env);
+    }
+    if (context->GetCurrentAppMode() != static_cast<int32_t>(AppExecFwk::MultiAppModeType::MULTI_INSTANCE)) {
+        ThrowError(env, AbilityErrorCode::ERROR_MULTI_INSTANCE_NOT_SUPPORTED);
+        return CreateJsUndefined(env);
+    }
+    std::string instanceKey = context->GetCurrentInstanceKey();
+    return CreateJsValue(env, instanceKey);
+}
+
+napi_value JsApplicationContextUtils::GetAllRunningInstanceKeys(napi_env env, napi_callback_info info)
+{
+    GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils,
+        OnGetAllRunningInstanceKeys, APPLICATION_CONTEXT_NAME);
+}
+
+napi_value JsApplicationContextUtils::OnGetAllRunningInstanceKeys(napi_env env, NapiCallbackInfo& info)
+{
+    TAG_LOGD(AAFwkTag::APPKIT, "Get all running instance keys");
+    auto innerErrCode = std::make_shared<ErrCode>(ERR_OK);
+    std::shared_ptr<std::vector<std::string>> instanceKeys;
+    NapiAsyncTask::ExecuteCallback execute =
+        [applicationContext = applicationContext_, innerErrCode, instanceKeys]() {
+        auto context = applicationContext.lock();
+        if (!context) {
+            TAG_LOGE(AAFwkTag::APPKIT, "applicationContext is released");
+            *innerErrCode = ERR_ABILITY_RUNTIME_EXTERNAL_CONTEXT_NOT_EXIST;
+            return;
+        }
+        if (context->GetCurrentAppMode() != static_cast<int32_t>(AppExecFwk::MultiAppModeType::MULTI_INSTANCE)) {
+            *innerErrCode = static_cast<int>(AbilityErrorCode::ERROR_MULTI_INSTANCE_NOT_SUPPORTED);
+            return;
+        }
+        std::string bundleName = context->GetBundleName();
+        *innerErrCode = context->GetAllRunningInstanceKeys(bundleName, *instanceKeys);
+    };
+    auto complete = [applicationContext = applicationContext_, innerErrCode, instanceKeys](
+        napi_env env, NapiAsyncTask& task, int32_t status) {
+        if (*innerErrCode != ERR_OK) {
+            task.Reject(env, CreateJsError(env, *innerErrCode, "failed to get instance keys."));
+            return;
+        }
+        task.ResolveWithNoError(env, CreateNativeArray(env, *instanceKeys));
+    };
+
+    napi_value result = nullptr;
+    NapiAsyncTask::Schedule("JsApplicationContextUtils::OnGetRunningProcessInformation",
+        env, CreateAsyncTaskWithLastParam(env, nullptr, std::move(execute), std::move(complete), &result));
+    return result;
+}
+
 void JsApplicationContextUtils::Finalizer(napi_env env, void *data, void *hint)
 {
     TAG_LOGD(AAFwkTag::APPKIT, "called");
@@ -1536,7 +1600,8 @@ napi_value JsApplicationContextUtils::CreateJsApplicationContext(napi_env env)
         napi_set_named_property(env, object, "resourceManager", CreateJsResourceManager(env, resourceManager, context));
     }
 
-    BindNativeApplicationContext(env, object);
+    BindNativeApplicationContextOne(env, object);
+    BindNativeApplicationContextTwo(env, object);
     return object;
 }
 
@@ -1582,7 +1647,7 @@ napi_value JsApplicationContextUtils::OnSetSupportedProcessCacheSelf(napi_env en
     return CreateJsUndefined(env);
 }
 
-void JsApplicationContextUtils::BindNativeApplicationContext(napi_env env, napi_value object)
+void JsApplicationContextUtils::BindNativeApplicationContextOne(napi_env env, napi_value object)
 {
     BindNativeProperty(env, object, "cacheDir", JsApplicationContextUtils::GetCacheDir);
     BindNativeProperty(env, object, "tempDir", JsApplicationContextUtils::GetTempDir);
@@ -1619,6 +1684,10 @@ void JsApplicationContextUtils::BindNativeApplicationContext(napi_env env, napi_
     BindNativeFunction(env, object, "setFont", MD_NAME, JsApplicationContextUtils::SetFont);
     BindNativeFunction(env, object, "clearUpApplicationData", MD_NAME,
         JsApplicationContextUtils::ClearUpApplicationData);
+}
+
+void JsApplicationContextUtils::BindNativeApplicationContextTwo(napi_env env, napi_value object)
+{
     BindNativeFunction(env, object, "preloadUIExtensionAbility", MD_NAME,
         JsApplicationContextUtils::PreloadUIExtensionAbility);
     BindNativeFunction(env, object, "getProcessRunningInformation", MD_NAME,
@@ -1627,6 +1696,10 @@ void JsApplicationContextUtils::BindNativeApplicationContext(napi_env env, napi_
         JsApplicationContextUtils::GetRunningProcessInformation);
     BindNativeFunction(env, object, "getCurrentAppCloneIndex", MD_NAME,
         JsApplicationContextUtils::GetCurrentAppCloneIndex);
+    BindNativeFunction(env, object, "getCurrentInstanceKey", MD_NAME,
+        JsApplicationContextUtils::GetCurrentInstanceKey);
+    BindNativeFunction(env, object, "getAllRunningInstanceKeys", MD_NAME,
+        JsApplicationContextUtils::GetAllRunningInstanceKeys);
     BindNativeFunction(env, object, "getGroupDir", MD_NAME, JsApplicationContextUtils::GetGroupDir);
     BindNativeFunction(env, object, "restartApp", MD_NAME, JsApplicationContextUtils::RestartApp);
     BindNativeFunction(env, object, "setSupportedProcessCache", MD_NAME,

frameworks/native/appkit/app/main_thread.cpp

@@ -1401,7 +1401,9 @@ void MainThread::HandleLaunchApplication(const AppLaunchData &appLaunchData, con
     std::shared_ptr<AbilityRuntime::ApplicationContext> applicationContext =
         AbilityRuntime::ApplicationContext::GetInstance();
     int32_t appIndex = appLaunchData.GetAppIndex();
+    std::string instanceKey = appLaunchData.GetInstanceKey();
     applicationContext->SetCurrentAppCloneIndex(appIndex);
+    applicationContext->SetCurrentInstanceKey(instanceKey);
     applicationContext->SetCurrentAppMode(static_cast<int32_t>(appInfo.multiAppMode.multiAppModeType));
     applicationContext->AttachContextImpl(contextImpl);
     auto appRunningId = appLaunchData.GetAppRunningUniqueId();

interfaces/inner_api/ability_manager/include/ability_manager_errors.h

@@ -611,6 +611,41 @@ enum {
      */
     ERR_ALL_APP_START_BLOCKED = 2097270,
 
+    /**
+     * Result(2097271) not support multi-instance.
+     */
+    ERR_MULTI_INSTANCE_NOT_SUPPORTED = 2097271,
+
+    /*
+     * Result (2097272) for not support app instance key.
+     */
+    ERR_APP_INSTANCE_KEY_NOT_SUPPORT = 2097272,
+
+    /*
+     * Result (2097273) for reach the upper limit.
+     */
+    ERR_UPPER_LIMIT = 2097273,
+
+    /*
+     * Result (2097274) for not support to create a new instance.
+     */
+    ERR_CREATE_NEW_INSTANCE_NOT_SUPPORT = 2097274,
+
+    /*
+     * Result (2097275) for invalid app instance key.
+     */
+    ERR_INVALID_APP_INSTANCE_KEY = 2097275,
+
+    /*
+     * Result (2097276) for not support app clone.
+     */
+    ERR_NOT_SUPPORT_APP_CLONE = 2097276,
+
+    /*
+     * Result (2097277) for invalid extension type.
+     */
+    ERR_INVALID_EXTENSION_TYPE = 2097277,
+
     /**
      * Native error(3000000) for target bundle not exist.
      */

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

@@ -212,6 +212,16 @@ public:
         appRunningUniqueId_ = appRunningUniqueId;
     }
 
+    inline std::string GetInstanceKey() const
+    {
+        return instanceKey_;
+    }
+
+    inline void SetInstanceKey(const std::string& instanceKey)
+    {
+        instanceKey_ = instanceKey;
+    }
+
     /**
      * @brief read this Sequenceable object from a Parcel.
      *
@@ -261,6 +271,7 @@ private:
     bool isMultiThread_ = false;
     bool isErrorInfoEnhance_ = false;
     std::string appRunningUniqueId_;
+    std::string instanceKey_;
 };
 }  // namespace AppExecFwk
 }  // namespace OHOS

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

@@ -234,6 +234,17 @@ public:
      */
     virtual AppMgrResultCode GetProcessRunningInformation(RunningProcessInfo &info);
 
+    /**
+     * GetAllRunningInstanceKeysByBundleName, call GetAllRunningInstanceKeysByBundleName() through proxy project.
+     * Obtains running isntance keys of multi-instance app that are running on the device.
+     *
+     * @param bundlename, bundle name in Application record.
+     * @param instanceKeys, output instance keys of the multi-insatnce app.
+     * @return ERR_OK ,return back success，others fail.
+     */
+    virtual AppMgrResultCode GetAllRunningInstanceKeysByBundleName(const std::string &bundleName,
+        std::vector<std::string> &instanceKeys);
+
     /**
      * GetAllRenderProcesses, call GetAllRenderProcesses() through proxy project.
      * Obtains information about render processes that are running on the device.

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

@@ -158,6 +158,17 @@ public:
     virtual int32_t GetRunningMultiAppInfoByBundleName(const std::string &bundleName,
         RunningMultiAppInfo &info) = 0;
 
+    /**
+     * GetAllRunningInstanceKeysByBundleName, call GetAllRunningInstanceKeysByBundleName() through proxy project.
+     * Obtains running isntance keys of multi-instance app that are running on the device.
+     *
+     * @param bundlename, bundle name in Application record.
+     * @param instanceKeys, output instance keys of the multi-insatnce app.
+     * @return ERR_OK ,return back success，others fail.
+     */
+    virtual int32_t GetAllRunningInstanceKeysByBundleName(const std::string &bundleName,
+        std::vector<std::string> &instanceKeys) = 0;
+
     /**
      * GetRunningProcessesByBundleType, call GetRunningProcessesByBundleType() through proxy project.
      * Obtains information about application processes by bundle type that are running on the device.

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

@@ -115,6 +115,7 @@ enum class AppMgrInterfaceCode {
     SET_SUPPORTED_PROCESS_CACHE = 89,
     REGISTER_KIA_INTERCEPTOR = 90,
     CHECK_IS_KIA_PROCESS = 91,
+    GET_All_RUNNING_INSTANCE_KEYS_BY_BUNDLENAME = 92,
 };
 } // AppExecFwk
 } // OHOS

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

@@ -135,6 +135,17 @@ public:
     virtual int32_t GetRunningMultiAppInfoByBundleName(const std::string &bundleName,
         RunningMultiAppInfo &info) override;
 
+    /**
+     * GetAllRunningInstanceKeysByBundleName, call GetAllRunningInstanceKeysByBundleName() through proxy project.
+     * Obtains running isntance keys of multi-instance app that are running on the device.
+     *
+     * @param bundlename, bundle name in Application record.
+     * @param instanceKeys, output instance keys of the multi-insatnce app.
+     * @return ERR_OK ,return back success，others fail.
+     */
+    virtual int32_t GetAllRunningInstanceKeysByBundleName(const std::string &bundleName,
+        std::vector<std::string> &instanceKeys) override;
+
     /**
      * GetRunningProcessesByBundleType, call GetRunningProcessesByBundleType() through proxy project.
      * Obtains information about application processes by bundle type that are running on the device.

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

@@ -105,6 +105,7 @@ private:
     int32_t HandleDumpHeapMemory(MessageParcel &data, MessageParcel &reply);
     int32_t HandleDumpJsHeapMemory(MessageParcel &data, MessageParcel &reply);
     int32_t HandleGetRunningMultiAppInfoByBundleName(MessageParcel &data, MessageParcel &reply);
+    int32_t HandleGetAllRunningInstanceKeysByBundleName(MessageParcel &data, MessageParcel &reply);
     int32_t HandleIsAppRunning(MessageParcel &data, MessageParcel &reply);
     int32_t HandleGetAppRunningStateByBundleName(MessageParcel &data, MessageParcel &reply);
     int32_t HandleNotifyLoadRepairPatch(MessageParcel &data, MessageParcel &reply);

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

@@ -25,17 +25,25 @@
 
 namespace OHOS {
 namespace AppExecFwk {
-const int32_t MAX_CLONE_APP_NUM = 128;
+constexpr int32_t MAX_CLONE_APP_NUM = 128;
+constexpr int32_t MAX_INSTANCE_NUM = 10;
 struct RunningAppClone {
     int32_t appCloneIndex;
     int32_t uid;
     std::vector<int32_t> pids;
 };
 
+struct RunningMultiInstanceInfo {
+    std::string instanceKey;
+    int32_t uid;
+    std::vector<int32_t> pids;
+};
+
 struct RunningMultiAppInfo : public Parcelable {
     std::string bundleName;
     int32_t mode;
     std::vector<RunningAppClone> runningAppClones;
+    std::vector<RunningMultiInstanceInfo> runningMultiIntanceInfos;
     
     bool ReadFromParcel(Parcel &parcel);
     virtual bool Marshalling(Parcel &parcel) const override;

interfaces/inner_api/app_manager/src/appmgr/app_launch_data.cpp

@@ -106,6 +106,11 @@ bool AppLaunchData::Marshalling(Parcel &parcel) const
         return false;
     }
 
+    if (!parcel.WriteString(instanceKey_)) {
+        TAG_LOGE(AAFwkTag::APPMGR, "Marshalling, Failed to write instance key.");
+        return false;
+    }
+
     return true;
 }
 
@@ -152,6 +157,7 @@ bool AppLaunchData::ReadFromParcel(Parcel &parcel)
     appRunningUniqueId_ = parcel.ReadString();
     isMultiThread_ = parcel.ReadBool();
     isErrorInfoEnhance_ = parcel.ReadBool();
+    instanceKey_ = parcel.ReadString();
     return true;
 }
 

interfaces/inner_api/app_manager/src/appmgr/app_mgr_client.cpp

@@ -416,6 +416,20 @@ AppMgrResultCode AppMgrClient::GetProcessRunningInformation(AppExecFwk::RunningP
     return AppMgrResultCode::ERROR_SERVICE_NOT_CONNECTED;
 }
 
+AppMgrResultCode AppMgrClient::GetAllRunningInstanceKeysByBundleName(const std::string &bundleName,
+    std::vector<std::string> &instanceKeys)
+{
+    sptr<IAppMgr> service = iface_cast<IAppMgr>(mgrHolder_->GetRemoteObject());
+    if (service != nullptr) {
+        int32_t result = service->GetAllRunningInstanceKeysByBundleName(bundleName, instanceKeys);
+        if (result == ERR_OK) {
+            return AppMgrResultCode::RESULT_OK;
+        }
+        return AppMgrResultCode::ERROR_SERVICE_NOT_READY;
+    }
+    return AppMgrResultCode::ERROR_SERVICE_NOT_CONNECTED;
+}
+
 AppMgrResultCode AppMgrClient::GetAllRenderProcesses(std::vector<RenderProcessInfo> &info)
 {
     sptr<IAppMgr> service = iface_cast<IAppMgr>(mgrHolder_->GetRemoteObject());

interfaces/inner_api/app_manager/src/appmgr/app_mgr_proxy.cpp

@@ -219,6 +219,25 @@ int32_t AppMgrProxy::GetRunningMultiAppInfoByBundleName(const std::string &bundl
     return result;
 }
 
+int32_t AppMgrProxy::GetAllRunningInstanceKeysByBundleName(const std::string &bundleName,
+    std::vector<std::string> &instanceKeys)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option(MessageOption::TF_SYNC);
+    if (!WriteInterfaceToken(data)) {
+        return ERR_FLATTEN_OBJECT;
+    }
+    PARCEL_UTIL_WRITE_RET_INT(data, String, bundleName);
+
+    PARCEL_UTIL_SENDREQ_RET_INT(AppMgrInterfaceCode::GET_All_RUNNING_INSTANCE_KEYS_BY_BUNDLENAME, data, reply, option);
+    if (!reply.ReadStringVector(&instanceKeys)) {
+        return ERR_INVALID_DATA;
+    }
+    int32_t result = reply.ReadInt32();
+    return result;
+}
+
 int32_t AppMgrProxy::GetRunningProcessesByBundleType(const BundleType bundleType,
     std::vector<RunningProcessInfo> &info)
 {

interfaces/inner_api/app_manager/src/appmgr/app_mgr_stub.cpp

@@ -213,6 +213,8 @@ int32_t AppMgrStub::OnRemoteRequestInnerThird(uint32_t code, MessageParcel &data
             return HandleStartNativeProcessForDebugger(data, reply);
         case static_cast<uint32_t>(AppMgrInterfaceCode::NOTIFY_APP_FAULT):
             return HandleNotifyFault(data, reply);
+        case static_cast<uint32_t>(AppMgrInterfaceCode::GET_All_RUNNING_INSTANCE_KEYS_BY_BUNDLENAME):
+            return HandleGetAllRunningInstanceKeysByBundleName(data, reply);
     }
     return INVALID_FD;
 }
@@ -493,6 +495,22 @@ int32_t AppMgrStub::HandleGetRunningMultiAppInfoByBundleName(MessageParcel &data
     return NO_ERROR;
 }
 
+int32_t AppMgrStub::HandleGetAllRunningInstanceKeysByBundleName(MessageParcel &data, MessageParcel &reply)
+{
+    std::string bundleName = data.ReadString();
+    std::vector<std::string> instanceKeys;
+    int32_t result = GetAllRunningInstanceKeysByBundleName(bundleName, instanceKeys);
+    if (!reply.WriteStringVector(instanceKeys)) {
+        TAG_LOGE(AAFwkTag::APPMGR, "failed to write isntanceKeys");
+        return ERR_INVALID_VALUE;
+    }
+    if (!reply.WriteInt32(result)) {
+        TAG_LOGE(AAFwkTag::APPMGR, "fail to write result.");
+        return ERR_INVALID_VALUE;
+    }
+    return NO_ERROR;
+}
+
 int32_t AppMgrStub::HandleGetRunningProcessesByBundleType(MessageParcel &data, MessageParcel &reply)
 {
     HITRACE_METER(HITRACE_TAG_APP);

interfaces/inner_api/app_manager/src/appmgr/running_multi_info.cpp

@@ -39,6 +39,19 @@ bool RunningMultiAppInfo::ReadFromParcel(Parcel &parcel)
         parcel.ReadInt32Vector(&clone.pids);
         runningAppClones.emplace_back(clone);
     }
+
+    int32_t runningMultiIntanceInfosSize;
+    READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, runningMultiIntanceInfosSize);
+    if (runningMultiIntanceInfosSize > MAX_INSTANCE_NUM) {
+        return false;
+    }
+    for (auto i = 0; i < runningMultiIntanceInfosSize; i++) {
+        RunningMultiInstanceInfo instanceInfo;
+        instanceInfo.instanceKey = Str16ToStr8(parcel.ReadString16());
+        instanceInfo.uid = parcel.ReadInt32();
+        parcel.ReadInt32Vector(&instanceInfo.pids);
+        runningMultiIntanceInfos.emplace_back(instanceInfo);
+    }
     return true;
 }
 
@@ -69,6 +82,18 @@ bool RunningMultiAppInfo::Marshalling(Parcel &parcel) const
             return false;
         }
     }
+    WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, runningMultiIntanceInfos.size());
+    if (runningMultiIntanceInfos.size() > MAX_INSTANCE_NUM) {
+        return false;
+    }
+    for (auto &instanceInfo : runningMultiIntanceInfos) {
+        WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(instanceInfo.instanceKey));
+        WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, instanceInfo.uid);
+        if (!parcel.WriteInt32Vector(instanceInfo.pids)) {
+            TAG_LOGE(AAFwkTag::APPMGR, "write runningMultiIntanceInfos failed.");
+            return false;
+        }
+    }
     return true;
 }
 }  // namespace AppExecFwk

interfaces/kits/native/ability/native/ability_business_error/ability_business_error.h

@@ -162,6 +162,21 @@ enum class AbilityErrorCode {
     // Not support back to caller.
     ERROR_CODE_NOT_SUPPROT_BACK_TO_CALLER = 16000075,
 
+    // invalid app instance key.
+    ERROR_CODE_INVALID_APP_INSTANCE_KEY = 16000076,
+
+    // upper limit.
+    ERROR_CODE_UPPER_LIMIT = 16000077,
+
+    // The multi-instance is not supported.
+    ERROR_MULTI_INSTANCE_NOT_SUPPORTED = 16000078,
+
+    // APP_INSTANCE_KEY cannot be specified.
+    ERROR_CODE_APP_INSTANCE_KEY_NOT_SUPPORT = 16000079,
+
+    // Not support to create a new instance.
+    ERROR_CODE_CREATE_NEW_INSTANCE_NOT_SUPPORT = 16000080,
+
     // invalid caller.
     ERROR_CODE_INVALID_CALLER = 16200001,
 

interfaces/kits/native/appkit/ability_runtime/context/application_context.h

@@ -143,6 +143,10 @@ public:
     int32_t SetSupportedProcessCacheSelf(bool isSupport);
     int32_t GetCurrentAppCloneIndex();
     void SetCurrentAppCloneIndex(int32_t appIndex);
+    std::string GetCurrentInstanceKey();
+    void SetCurrentInstanceKey(const std::string& instanceKey);
+    int32_t GetAllRunningInstanceKeys(const std::string& bundleName,
+        std::vector<std::string> &instanceKeys);
     int32_t GetCurrentAppMode();
     void SetCurrentAppMode(int32_t appIndex);
     void ProcessSecurityExit(const AAFwk::ExitReason &exitReason);
@@ -171,6 +175,7 @@ private:
     std::string appRunningUniqueId_;
     int32_t appIndex_ = 0;
     int32_t appMode_ = 0;
+    std::string instanceKey_;
 };
 }  // namespace AbilityRuntime
 }  // namespace OHOS

interfaces/kits/native/appkit/ability_runtime/context/context_impl.h

@@ -351,6 +351,14 @@ public:
      */
     int32_t GetProcessRunningInformation(AppExecFwk::RunningProcessInfo &info);
 
+    /**
+     * @brief Get all running instance keys for the current app
+     *
+     * @return error code
+     */
+    int32_t GetAllRunningInstanceKeys(const std::string& bundleName,
+        std::vector<std::string> &instanceKeys);
+
     /**
      * @brief Restart app
      *

interfaces/kits/native/appkit/ability_runtime/context/js_application_context_utils.h

@@ -100,6 +100,8 @@ public:
     napi_value OnSetSupportedProcessCacheSelf(napi_env env, NapiCallbackInfo& info);
     napi_value OnPreloadUIExtensionAbility(napi_env env, NapiCallbackInfo& info);
     napi_value OnGetCurrentAppCloneIndex(napi_env env, NapiCallbackInfo& info);
+    napi_value OnGetCurrentInstanceKey(napi_env env, NapiCallbackInfo& info);
+    napi_value OnGetAllRunningInstanceKeys(napi_env env, NapiCallbackInfo& info);
     napi_value OnSetFontSizeScale(napi_env env, NapiCallbackInfo& info);
 
     static napi_value GetCacheDir(napi_env env, napi_callback_info info);
@@ -124,6 +126,8 @@ public:
     static napi_value SetSupportedProcessCacheSelf(napi_env env, napi_callback_info info);
     static napi_value PreloadUIExtensionAbility(napi_env env, napi_callback_info info);
     static napi_value GetCurrentAppCloneIndex(napi_env env, napi_callback_info info);
+    static napi_value GetCurrentInstanceKey(napi_env env, napi_callback_info info);
+    static napi_value GetAllRunningInstanceKeys(napi_env env, napi_callback_info info);
     static napi_value SetFontSizeScale(napi_env env, napi_callback_info info);
 
 protected:
@@ -139,7 +143,8 @@ private:
     napi_value OnCreateSystemHspModuleResourceManager(napi_env env, NapiCallbackInfo& info);
     napi_value OnGetApplicationContext(napi_env env, NapiCallbackInfo& info);
     bool CheckCallerIsSystemApp();
-    static void BindNativeApplicationContext(napi_env env, napi_value object);
+    static void BindNativeApplicationContextOne(napi_env env, napi_value object);
+    static void BindNativeApplicationContextTwo(napi_env env, napi_value object);
     static JsAppProcessState ConvertToJsAppProcessState(
         const AppExecFwk::AppProcessState &appProcessState, const bool &isFocused);
     std::shared_ptr<JsAbilityLifecycleCallback> callback_;

services/abilitymgr/include/ability_manager_service.h

@@ -2287,6 +2287,8 @@ private:
     
     void SendStartAbilityOtherExtensionEvent(const AppExecFwk::AbilityInfo& abilityInfo,
         const Want& want, uint32_t specifyTokenId);
+    
+    void SetMinimizedDuringFreeInstall(const sptr<SessionInfo>& sessionInfo);
 
     /**
      * @brief Check debug app in developer mode.

services/abilitymgr/include/ability_record.h

@@ -1093,6 +1093,11 @@ public:
 
     void RemoveConnectWant();
 
+    inline std::string GetInstanceKey() const
+    {
+        return instanceKey_;
+    }
+
 protected:
     void SendEvent(uint32_t msg, uint32_t timeOut, int32_t param = -1, bool isExtension = false);
 
@@ -1318,6 +1323,7 @@ private:
     ffrt::mutex connectWantLock_;
     bool isLaunching_ = true;
     LaunchDebugInfo launchDebugInfo_;
+    std::string instanceKey_ = "";
 };
 }  // namespace AAFwk
 }  // namespace OHOS

services/abilitymgr/include/ability_util.h

@@ -306,12 +306,29 @@ static constexpr int64_t MICROSECONDS = 1000000;    // MICROSECONDS mean 10^6 mi
     }
 }
 
+[[maybe_unused]] static void RemoveInstanceKey(Want &want)
+{
+    want.RemoveParam(Want::APP_INSTANCE_KEY);
+    want.RemoveParam(Want::CREATE_APP_INSTANCE_KEY);
+}
+
 [[maybe_unused]] static void RemoveWantKey(Want &want)
 {
     RemoveShowModeKey(want);
     RemoveWindowModeKey(want);
 }
 
+[[maybe_unused]] static int32_t CheckInstanceKey(const Want &want)
+{
+    auto instanceKey = want.GetStringParam(Want::APP_INSTANCE_KEY);
+    auto isCreating = want.GetBoolParam(Want::CREATE_APP_INSTANCE_KEY, false);
+    if (!instanceKey.empty() || isCreating) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "Not support multi-instance");
+        return ERR_MULTI_INSTANCE_NOT_SUPPORTED;
+    }
+    return ERR_OK;
+}
+
 [[maybe_unused]] static void WantSetParameterWindowMode(Want &want, int32_t windowMode)
 {
     want.SetParam(Want::PARAM_RESV_WINDOW_MODE, windowMode);

services/abilitymgr/include/app_scheduler.h

@@ -139,7 +139,7 @@ public:
      */
     int LoadAbility(sptr<IRemoteObject> token, sptr<IRemoteObject> preToken,
         const AppExecFwk::AbilityInfo &abilityInfo, const AppExecFwk::ApplicationInfo &applicationInfo,
-        const Want &want, int32_t abilityRecordId);
+        const Want &want, int32_t abilityRecordId, const std::string &instanceKey);
 
     /**
      * terminate ability with token.

services/abilitymgr/include/utils/ability_permission_util.h

@@ -38,10 +38,19 @@ public:
     // check dominate screen
     bool IsDominateScreen(const Want &want, bool isPendingWantCaller);
 
+    int32_t CheckMultiInstanceAndAppClone(Want &want, int32_t userId, int32_t appIndex,
+        sptr<IRemoteObject> callerToken);
+
 private:
     AbilityPermissionUtil() = default;
     ~AbilityPermissionUtil() = default;
 
+    int32_t CheckMultiInstance(Want &want, sptr<IRemoteObject> callerToken, bool isCreating,
+        const std::string &instanceKey, int32_t maxCount);
+
+    int32_t UpdateInstanceKey(Want &want, const std::string &originInstanceKey,
+        const std::vector<std::string> &instanceKeyArray, const std::string &instanceKey);
+
     DISALLOW_COPY_AND_MOVE(AbilityPermissionUtil);
 };
 } // namespace AAFwk

services/abilitymgr/src/ability_connect_manager.cpp

@@ -1392,7 +1392,7 @@ void AbilityConnectManager::LoadAbility(const std::shared_ptr<AbilityRecord> &ab
     UpdateUIExtensionInfo(abilityRecord);
     DelayedSingleton<AppScheduler>::GetInstance()->LoadAbility(
         token, perToken, abilityRecord->GetAbilityInfo(), abilityRecord->GetApplicationInfo(),
-        abilityRecord->GetWant(), abilityRecord->GetRecordId());
+        abilityRecord->GetWant(), abilityRecord->GetRecordId(), "");
     abilityRecord->SetLoadState(AbilityLoadState::LOADING);
 }
 

services/abilitymgr/src/ability_manager_service.cpp

@@ -616,6 +616,7 @@ int32_t AbilityManagerService::StartAbilityByInsightIntent(const Want &want, con
     std::string bundleNameFromAbilityRecord = abilityRecord->GetAbilityInfo().bundleName;
     if (!bundleNameFromWant.empty() && bundleNameFromWant == bundleNameFromIntentMgr &&
         bundleNameFromWant == bundleNameFromAbilityRecord) {
+        AbilityUtil::RemoveInstanceKey(const_cast<Want &>(want));
         TAG_LOGI(AAFwkTag::ABILITYMGR, "bundleName match");
         return StartAbility(want, callerToken, userId, -1);
     }
@@ -653,6 +654,7 @@ int AbilityManagerService::StartAbilityByUIContentSession(const Want &want, cons
         TAG_LOGE(AAFwkTag::ABILITYMGR, "callerToken unequal to top ablity token");
         return NOT_TOP_ABILITY;
     }
+    AbilityUtil::RemoveInstanceKey(const_cast<Want &>(want));
     return StartAbility(want, callerToken, userId, requestCode);
 }
 
@@ -1036,6 +1038,11 @@ int AbilityManagerService::StartAbilityInner(const Want &want, const sptr<IRemot
     if (!StartAbilityUtils::GetAppIndex(want, callerToken, appIndex)) {
         return ERR_APP_CLONE_INDEX_INVALID;
     }
+    auto checkRet = AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(const_cast<Want &>(want),
+        validUserId, appIndex, callerToken);
+    if (checkRet != ERR_OK) {
+        return checkRet;
+    }
     StartAbilityInfoWrap threadLocalInfo(want, validUserId, appIndex, callerToken);
     auto shouldBlockFunc = [aams = shared_from_this()]() { return aams->ShouldBlockAllAppStart(); };
     AbilityInterceptorParam interceptorParam = AbilityInterceptorParam(want, requestCode, GetUserId(),
@@ -1066,6 +1073,10 @@ int AbilityManagerService::StartAbilityInner(const Want &want, const sptr<IRemot
     AbilityRequest abilityRequest;
 #ifdef SUPPORT_SCREEN
     if (ImplicitStartProcessor::IsImplicitStartAction(want)) {
+        auto checkResult = AbilityUtil::CheckInstanceKey(want);
+        if (checkResult != ERR_OK) {
+            return checkResult;
+        }
         abilityRequest.Voluation(want, requestCode, callerToken);
         if (specifyTokenId > 0 && callerToken != nullptr) { // for sa specify tokenId and caller token
             UpdateCallerInfoFromToken(abilityRequest.want, callerToken);
@@ -1362,6 +1373,11 @@ int AbilityManagerService::StartAbilityDetails(const Want &want, const AbilitySt
     if (!StartAbilityUtils::GetAppIndex(want, callerToken, appIndex)) {
         return ERR_APP_CLONE_INDEX_INVALID;
     }
+    auto checkRet = AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(const_cast<Want &>(want),
+        validUserId, appIndex, callerToken);
+    if (checkRet != ERR_OK) {
+        return checkRet;
+    }
     StartAbilityInfoWrap threadLocalInfo(want, validUserId, appIndex, callerToken);
     auto shouldBlockFunc = [aams = shared_from_this()]() { return aams->ShouldBlockAllAppStart(); };
     AbilityInterceptorParam interceptorParam = AbilityInterceptorParam(want, requestCode, GetUserId(),
@@ -1396,6 +1412,10 @@ int AbilityManagerService::StartAbilityDetails(const Want &want, const AbilitySt
     AbilityRequest abilityRequest;
 #ifdef SUPPORT_SCREEN
     if (ImplicitStartProcessor::IsImplicitStartAction(want)) {
+        auto checkResult = AbilityUtil::CheckInstanceKey(want);
+        if (checkResult != ERR_OK) {
+            return checkResult;
+        }
         abilityRequest.Voluation(
             want, requestCode, callerToken, std::make_shared<AbilityStartSetting>(abilityStartSetting));
         abilityRequest.callType = AbilityCallType::START_SETTINGS_TYPE;
@@ -1656,6 +1676,11 @@ int AbilityManagerService::StartAbilityForOptionInner(const Want &want, const St
     if (!StartAbilityUtils::GetAppIndex(want, callerToken, appIndex)) {
         return ERR_APP_CLONE_INDEX_INVALID;
     }
+    auto checkRet = AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(const_cast<Want &>(want),
+        validUserId, appIndex, callerToken);
+    if (checkRet != ERR_OK) {
+        return checkRet;
+    }
     StartAbilityInfoWrap threadLocalInfo(want, validUserId, appIndex, callerToken);
     auto shouldBlockFunc = [aams = shared_from_this()]() { return aams->ShouldBlockAllAppStart(); };
     AbilityInterceptorParam interceptorParam = AbilityInterceptorParam(want, requestCode, GetUserId(),
@@ -1693,6 +1718,10 @@ int AbilityManagerService::StartAbilityForOptionInner(const Want &want, const St
     AbilityRequest abilityRequest;
 #ifdef SUPPORT_SCREEN
     if (ImplicitStartProcessor::IsImplicitStartAction(want)) {
+        auto checkResult = AbilityUtil::CheckInstanceKey(want);
+        if (checkResult != ERR_OK) {
+            return checkResult;
+        }
         abilityRequest.Voluation(want, requestCode, callerToken);
         if (PermissionVerification::GetInstance()->IsSystemAppCall()) {
             bool windowFocused = startOptions.GetWindowFocused();
@@ -3537,6 +3566,8 @@ int AbilityManagerService::CloseUIAbilityBySCB(const sptr<SessionInfo> &sessionI
         return ERR_WRONG_INTERFACE_CALL;
     }
 
+    SetMinimizedDuringFreeInstall(sessionInfo);
+
     auto uiAbilityManager = GetUIAbilityManagerByUid(IPCSkeleton::GetCallingUid());
     CHECK_POINTER_AND_RETURN(uiAbilityManager, ERR_INVALID_VALUE);
     TAG_LOGI(AAFwkTag::ABILITYMGR,
@@ -3771,6 +3802,51 @@ int AbilityManagerService::MinimizeUIExtensionAbility(const sptr<SessionInfo> &e
     return ERR_OK;
 }
 
+void AbilityManagerService::SetMinimizedDuringFreeInstall(const sptr<SessionInfo> &sessionInfo)
+{
+    if (sessionInfo == nullptr) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "sessionInfo null");
+        return;
+    }
+
+    if (!(sessionInfo->want).HasParameter(KEY_SESSION_ID)) {
+        return;
+    }
+
+    std::string sessionId = (sessionInfo->want).GetStringParam(KEY_SESSION_ID);
+    if (sessionId.empty()) {
+        return;
+    }
+
+    if (freeInstallManager_ == nullptr) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "freeInstallManager_ null");
+        return;
+    }
+    FreeInstallInfo taskInfo;
+    if (!freeInstallManager_->GetFreeInstallTaskInfo(sessionId, taskInfo)) {
+        TAG_LOGI(AAFwkTag::ABILITYMGR, "free install task with sessionId=%{public}s does not exist",
+            sessionId.c_str());
+        return;
+    }
+
+    if (taskInfo.isFreeInstallFinished) {
+        TAG_LOGI(AAFwkTag::ABILITYMGR, "free install task finished");
+        return;
+    }
+
+    {
+        std::lock_guard<ffrt::mutex> guard(preStartSessionMapLock_);
+        preStartSessionMap_.insert(std::make_pair(sessionId, sessionInfo));
+        auto it = preStartSessionMap_.find(sessionId);
+        if (it == preStartSessionMap_.end()) {
+            TAG_LOGI(AAFwkTag::ABILITYMGR, "session info with sessionId=%{public}s does not exist",
+                sessionId.c_str());
+            return;
+        }
+        it->second->isMinimizedDuringFreeInstall = true;
+    }
+}
+
 int AbilityManagerService::MinimizeUIAbilityBySCB(const sptr<SessionInfo> &sessionInfo, bool fromUser,
     uint32_t sceneFlag)
 {
@@ -3786,6 +3862,8 @@ int AbilityManagerService::MinimizeUIAbilityBySCB(const sptr<SessionInfo> &sessi
         return ERR_WRONG_INTERFACE_CALL;
     }
 
+    SetMinimizedDuringFreeInstall(sessionInfo);
+
     auto uiAbilityManager = GetUIAbilityManagerByUid(IPCSkeleton::GetCallingUid());
     CHECK_POINTER_AND_RETURN(uiAbilityManager, ERR_INVALID_VALUE);
     auto abilityRecord = uiAbilityManager->GetUIAbilityRecordBySessionInfo(sessionInfo);
@@ -7138,6 +7216,11 @@ int AbilityManagerService::StartAbilityByCall(const Want &want, const sptr<IAbil
     if (!StartAbilityUtils::GetAppIndex(want, callerToken, appIndex)) {
         return ERR_APP_CLONE_INDEX_INVALID;
     }
+    auto checkRet = AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(const_cast<Want &>(want),
+        GetUserId(), appIndex, callerToken);
+    if (checkRet != ERR_OK) {
+        return checkRet;
+    }
     StartAbilityInfoWrap threadLocalInfo(want, GetUserId(), appIndex, callerToken);
     auto shouldBlockFunc = [aams = shared_from_this()]() { return aams->ShouldBlockAllAppStart(); };
     AbilityInterceptorParam interceptorParam = AbilityInterceptorParam(want, 0, GetUserId(), true, nullptr,
@@ -8066,6 +8149,16 @@ int AbilityManagerService::StartUserTest(const Want &want, const sptr<IRemoteObj
         return ERR_INVALID_VALUE;
     }
 
+    auto checkResult = AbilityUtil::CheckInstanceKey(want);
+    if (checkResult != ERR_OK) {
+        return checkResult;
+    }
+    int32_t appIndex = 0;
+    if (!StartAbilityUtils::GetAppIndex(want, nullptr, appIndex) || appIndex != 0) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "Not support app clone");
+        return ERR_NOT_SUPPORT_APP_CLONE;
+    }
+
     auto bms = AbilityUtil::GetBundleManagerHelper();
     CHECK_POINTER_AND_RETURN(bms, START_USER_TEST_FAIL);
     AppExecFwk::BundleInfo bundleInfo;
@@ -10126,6 +10219,10 @@ int32_t AbilityManagerService::NotifySaveAsResult(const Want &want, int resultCo
         return CHECK_PERMISSION_FAILED;
     }
 #endif // WITH_DLP
+    auto checkResult = AbilityUtil::CheckInstanceKey(want);
+    if (checkResult != ERR_OK) {
+        return checkResult;
+    }
 
     for (const auto &item : startAbilityChain_) {
         if (item.second->GetHandlerName() == StartAbilitySandboxSavefile::handlerName_) {
@@ -10195,6 +10292,12 @@ void AbilityManagerService::StartSpecifiedAbilityBySCB(const Want &want)
         TAG_LOGE(AAFwkTag::ABILITYMGR, "no sceneboard called, no allowed");
         return;
     }
+    int32_t appIndex = 0;
+    if (!StartAbilityUtils::GetAppIndex(want, nullptr, appIndex)) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "invalid app clone index");
+    }
+    (void)AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(const_cast<Want &>(want),
+        GetUserId(), appIndex, nullptr);
     auto uiAbilityManager = GetUIAbilityManagerByUid(IPCSkeleton::GetCallingUid());
     CHECK_POINTER(uiAbilityManager);
     uiAbilityManager->StartSpecifiedAbilityBySCB(want);
@@ -10645,6 +10748,7 @@ int32_t AbilityManagerService::StartAbilityWithInsightIntent(const Want &want, i
         CHECK_CALLER_IS_SYSTEM_APP;
     }
     AbilityUtil::RemoveShowModeKey(const_cast<Want &>(want));
+    AbilityUtil::RemoveInstanceKey(const_cast<Want &>(want));
     EventInfo eventInfo = BuildEventInfo(want, userId);
     SendAbilityEvent(EventName::START_ABILITY, HiSysEventType::BEHAVIOR, eventInfo);
     int32_t ret = StartAbilityWrap(want, nullptr, requestCode, false, userId);
@@ -10673,6 +10777,7 @@ int32_t AbilityManagerService::StartAbilityByCallWithInsightIntent(const Want &w
     }
 
     AbilityUtil::RemoveWantKey(const_cast<Want &>(want));
+    AbilityUtil::RemoveInstanceKey(const_cast<Want &>(want));
     AbilityRequest abilityRequest;
     abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE;
     abilityRequest.callerUid = IPCSkeleton::GetCallingUid();
@@ -11842,6 +11947,12 @@ int32_t AbilityManagerService::StartUIAbilityByPreInstall(const FreeInstallInfo
         (sessionInfo->want).SetElement(want.GetElement());
     }
 
+    if (sessionInfo == nullptr || sessionInfo->isMinimizedDuringFreeInstall) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "sessionInfo is nullptr or ability is already minimized");
+        RemovePreStartSession(sessionId);
+        return ERR_INVALID_VALUE;
+    }
+
     int errCode = ERR_OK;
     bool isColdStart = true;
     if ((errCode = StartUIAbilityByPreInstallInner(sessionInfo, taskInfo.specifyTokenId, 0, isColdStart)) != ERR_OK) {
@@ -12013,7 +12124,7 @@ ErrCode AbilityManagerService::OpenLink(const Want& want, sptr<IRemoteObject> ca
     int32_t userId, int requestCode)
 {
     TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
-
+    AbilityUtil::RemoveInstanceKey(const_cast<Want &>(want));
     std::string callerBundleName;
     Want convertedWant = want;
     if (!WantUtils::IsAtomicServiceUrl(want) ||
@@ -12059,6 +12170,8 @@ int32_t AbilityManagerService::CleanUIAbilityBySCB(const sptr<SessionInfo> &sess
         return ERR_WRONG_INTERFACE_CALL;
     }
 
+    SetMinimizedDuringFreeInstall(sessionInfo);
+
     auto uiAbilityManager = GetUIAbilityManagerByUid(IPCSkeleton::GetCallingUid());
     CHECK_POINTER_AND_RETURN(uiAbilityManager, ERR_INVALID_VALUE);
     TAG_LOGI(AAFwkTag::ABILITYMGR, "user request clean session: %{public}d", sessionInfo->persistentId);

services/abilitymgr/src/ability_record.cpp

@@ -219,6 +219,9 @@ std::shared_ptr<AbilityRecord> AbilityRecord::CreateAbilityRecord(const AbilityR
     abilityRecord->SetAppIndex(appIndex);
     abilityRecord->SetCallerAccessTokenId(abilityRequest.callerAccessTokenId);
     abilityRecord->sessionInfo_ = abilityRequest.sessionInfo;
+    if (abilityRequest.sessionInfo != nullptr) {
+        abilityRecord->instanceKey_ = abilityRequest.sessionInfo->instanceKey;
+    }
     if (!abilityRecord->Init()) {
         TAG_LOGE(AAFwkTag::ABILITYMGR, "failed init");
         return nullptr;
@@ -331,7 +334,7 @@ int AbilityRecord::LoadAbility()
     std::lock_guard guard(wantLock_);
     want_.SetParam(ABILITY_OWNER_USERID, ownerMissionUserId_);
     auto result = DelayedSingleton<AppScheduler>::GetInstance()->LoadAbility(
-        token_, callerToken_, abilityInfo_, abilityInfo_.applicationInfo, want_, recordId_);
+        token_, callerToken_, abilityInfo_, abilityInfo_.applicationInfo, want_, recordId_, instanceKey_);
     want_.RemoveParam(ABILITY_OWNER_USERID);
     SetLoadState(AbilityLoadState::LOADING);
 

services/abilitymgr/src/app_scheduler.cpp

@@ -68,7 +68,7 @@ bool AppScheduler::Init(const std::weak_ptr<AppStateCallback> &callback)
 
 int AppScheduler::LoadAbility(sptr<IRemoteObject> token, sptr<IRemoteObject> preToken,
     const AppExecFwk::AbilityInfo &abilityInfo, const AppExecFwk::ApplicationInfo &applicationInfo,
-    const Want &want, int32_t abilityRecordId)
+    const Want &want, int32_t abilityRecordId, const std::string &instanceKey)
 {
     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
     TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
@@ -80,6 +80,7 @@ int AppScheduler::LoadAbility(sptr<IRemoteObject> token, sptr<IRemoteObject> pre
     loadParam.isShellCall = AAFwk::PermissionVerification::GetInstance()->IsShellCall();
     loadParam.token = token;
     loadParam.preToken = preToken;
+    loadParam.instanceKey = instanceKey;
     int ret = static_cast<int>(IN_PROCESS_CALL(
         appMgrClient_->LoadAbility(abilityInfo, applicationInfo, want, loadParam)));
     if (ret != ERR_OK) {

services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp

@@ -86,9 +86,9 @@ int UIAbilityLifecycleManager::StartUIAbility(AbilityRequest &abilityRequest, sp
     }
     abilityRequest.sessionInfo = sessionInfo;
 
-    TAG_LOGI(AAFwkTag::ABILITYMGR, "session:%{public}d. bundle:%{public}s, ability:%{public}s",
+    TAG_LOGI(AAFwkTag::ABILITYMGR, "session:%{public}d. bundle:%{public}s, ability:%{public}s, instanceKey:%{public}s",
         sessionInfo->persistentId, abilityRequest.abilityInfo.bundleName.c_str(),
-        abilityRequest.abilityInfo.name.c_str());
+        abilityRequest.abilityInfo.name.c_str(), sessionInfo->instanceKey.c_str());
     std::shared_ptr<AbilityRecord> uiAbilityRecord = nullptr;
     auto iter = sessionAbilityMap_.find(sessionInfo->persistentId);
     if (iter != sessionAbilityMap_.end()) {
@@ -359,6 +359,10 @@ int UIAbilityLifecycleManager::NotifySCBToStartUIAbility(const AbilityRequest &a
     auto sessionInfo = CreateSessionInfo(abilityRequest);
     sessionInfo->requestCode = abilityRequest.requestCode;
     sessionInfo->persistentId = GetPersistentIdByAbilityRequest(abilityRequest, sessionInfo->reuse);
+    auto instanceKey = abilityRequest.want.GetStringParam(Want::APP_INSTANCE_KEY);
+    if (!instanceKey.empty()) {
+        sessionInfo->instanceKey = instanceKey;
+    }
     sessionInfo->userId = userId_;
     sessionInfo->isAtomicService = (abilityInfo.applicationInfo.bundleType == AppExecFwk::BundleType::ATOMIC_SERVICE);
     TAG_LOGI(
@@ -1483,10 +1487,11 @@ bool UIAbilityLifecycleManager::CheckProperties(const std::shared_ptr<AbilityRec
     const auto& abilityInfo = abilityRecord->GetAbilityInfo();
     int32_t appIndex = 0;
     (void)AbilityRuntime::StartupUtil::GetAppIndex(abilityRequest.want, appIndex);
+    auto instanceKey = abilityRequest.want.GetStringParam(Want::APP_INSTANCE_KEY);
     return abilityInfo.launchMode == launchMode && abilityRequest.abilityInfo.name == abilityInfo.name &&
         abilityRequest.abilityInfo.bundleName == abilityInfo.bundleName &&
         abilityRequest.abilityInfo.moduleName == abilityInfo.moduleName &&
-        appIndex == abilityRecord->GetAppIndex();
+        appIndex == abilityRecord->GetAppIndex() && instanceKey == abilityRecord->GetInstanceKey();
 }
 
 void UIAbilityLifecycleManager::OnTimeOut(uint32_t msgId, int64_t abilityRecordId, bool isHalf)
@@ -1864,6 +1869,7 @@ int UIAbilityLifecycleManager::StartAbilityBySpecifed(const AbilityRequest &abil
     sessionInfo->requestCode = abilityRequest.requestCode;
     sessionInfo->processOptions = abilityRequest.processOptions;
     sessionInfo->startWindowOption = abilityRequest.startWindowOption;
+    sessionInfo->instanceKey = abilityRequest.want.GetStringParam(Want::APP_INSTANCE_KEY);
     SpecifiedInfo specifiedInfo;
     specifiedInfo.abilityName = abilityRequest.abilityInfo.name;
     specifiedInfo.bundleName = abilityRequest.abilityInfo.bundleName;

services/abilitymgr/src/utils/ability_permission_util.cpp

@@ -25,6 +25,8 @@
 #include "ipc_skeleton.h"
 #include "permission_constants.h"
 #include "permission_verification.h"
+#include "start_ability_utils.h"
+#include "utils/app_mgr_util.h"
 
 using OHOS::Security::AccessToken::AccessTokenKit;
 
@@ -103,5 +105,95 @@ bool AbilityPermissionUtil::IsDominateScreen(const Want &want, bool isPendingWan
     TAG_LOGD(AAFwkTag::ABILITYMGR, "not dominate screen.");
     return false;
 }
+
+int32_t AbilityPermissionUtil::CheckMultiInstanceAndAppClone(Want &want, int32_t userId, int32_t appIndex,
+    sptr<IRemoteObject> callerToken)
+{
+    auto instanceKey = want.GetStringParam(Want::APP_INSTANCE_KEY);
+    auto isCreating = want.GetBoolParam(Want::CREATE_APP_INSTANCE_KEY, false);
+    AppExecFwk::ApplicationInfo appInfo;
+    auto isSupportMultiInstance = AppUtils::GetInstance().IsSupportMultiInstance();
+    if (isSupportMultiInstance) {
+        if (!StartAbilityUtils::GetApplicationInfo(want.GetBundle(), userId, appInfo)) {
+            TAG_LOGE(AAFwkTag::ABILITYMGR, "can't get applicationInfo through bundleName");
+            return RESOLVE_APP_ERR;
+        }
+        if (appInfo.multiAppMode.multiAppModeType == AppExecFwk::MultiAppModeType::UNSPECIFIED) {
+            if (!instanceKey.empty() || isCreating || appIndex != 0) {
+                TAG_LOGE(AAFwkTag::ABILITYMGR, "Not support multi-instance or appClone");
+                return ERR_MULTI_APP_NOT_SUPPORTED;
+            }
+        }
+        if (appInfo.multiAppMode.multiAppModeType == AppExecFwk::MultiAppModeType::MULTI_INSTANCE) {
+            if (appIndex != 0) {
+                TAG_LOGE(AAFwkTag::ABILITYMGR, "Not support appClone");
+                return ERR_NOT_SUPPORT_APP_CLONE;
+            }
+            return CheckMultiInstance(want, callerToken, isCreating, instanceKey, appInfo.multiAppMode.maxCount);
+        }
+    }
+    if (!isSupportMultiInstance || appInfo.multiAppMode.multiAppModeType == AppExecFwk::MultiAppModeType::APP_CLONE) {
+        if (!instanceKey.empty() || isCreating) {
+            TAG_LOGE(AAFwkTag::ABILITYMGR, "Not support multi-instance");
+            return ERR_MULTI_INSTANCE_NOT_SUPPORTED;
+        }
+    }
+    return ERR_OK;
+}
+
+int32_t AbilityPermissionUtil::CheckMultiInstance(Want &want, sptr<IRemoteObject> callerToken,
+    bool isCreating, const std::string &instanceKey, int32_t maxCount)
+{
+    auto appMgr = AppMgrUtil::GetAppMgr();
+    if (appMgr == nullptr) {
+        TAG_LOGE(AAFwkTag::FREE_INSTALL, "null appMgr");
+        return ERR_INVALID_VALUE;
+    }
+    auto callerRecord = Token::GetAbilityRecordByToken(callerToken);
+    std::vector<std::string> instanceKeyArray;
+    auto result = appMgr->GetAllRunningInstanceKeysByBundleName(want.GetBundle(), instanceKeyArray);
+    if (result != ERR_OK) {
+        TAG_LOGE(AAFwkTag::FREE_INSTALL, "Failed to get instance key");
+        return ERR_INVALID_VALUE;
+    }
+    // in-app launch
+    if (callerRecord != nullptr && callerRecord->GetAbilityInfo().bundleName == want.GetBundle()) {
+        if (isCreating) {
+            if (!instanceKey.empty()) {
+                TAG_LOGE(AAFwkTag::ABILITYMGR, "Not allow to set instanceKey");
+                return ERR_APP_INSTANCE_KEY_NOT_SUPPORT;
+            }
+            if (static_cast<int32_t>(instanceKeyArray.size()) == maxCount) {
+                TAG_LOGE(AAFwkTag::ABILITYMGR, "reach upper limit");
+                return ERR_UPPER_LIMIT;
+            }
+            return ERR_OK;
+        }
+        return UpdateInstanceKey(want, instanceKey, instanceKeyArray, callerRecord->GetInstanceKey());
+    }
+    // inter-app launch
+    if (isCreating) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "not support to create a new instance");
+        return ERR_CREATE_NEW_INSTANCE_NOT_SUPPORT;
+    }
+    std::string defaultInstanceKey = "app_instance_0";
+    return UpdateInstanceKey(want, instanceKey, instanceKeyArray, defaultInstanceKey);
+}
+
+int32_t AbilityPermissionUtil::UpdateInstanceKey(Want &want, const std::string &originInstanceKey,
+    const std::vector<std::string> &instanceKeyArray, const std::string &instanceKey)
+{
+    if (originInstanceKey.empty()) {
+        want.SetParam(Want::APP_INSTANCE_KEY, instanceKey);
+        return ERR_OK;
+    }
+    for (const auto& key : instanceKeyArray) {
+        if (key == originInstanceKey) {
+            return ERR_OK;
+        }
+    }
+    TAG_LOGE(AAFwkTag::ABILITYMGR, "invalid instanceKey");
+    return ERR_INVALID_APP_INSTANCE_KEY;
+}
 } // AAFwk
 } // OHOS

services/abilitymgr/src/utils/modal_system_dialog_util.cpp

@@ -24,8 +24,8 @@ namespace AbilityRuntime {
 namespace {
 constexpr char DEVELOPER_MODE_STATE[] = "const.security.developermode.state";
 constexpr const char* RESOURCE_ID_GENERAL_GET_IT = "general_get_it";
-constexpr const char* RESOURCE_ID_DEVELOPER_DIALOG_TITLE = "ohos_lab_developer_mode_tips";
-constexpr const char* RESOURCE_ID_DEVELOPER_DIALOG_CONTENT = "ohos_desc_developer_mode_tips";
+constexpr const char* RESOURCE_ID_DEVELOPER_DIALOG_TITLE = "lab_developer_mode_tips";
+constexpr const char* RESOURCE_ID_DEVELOPER_DIALOG_CONTENT = "desc_developer_mode_tips";
 }
 
 bool ModalSystemDialogUtil::CheckDebugAppNotInDeveloperMode(const AppExecFwk::ApplicationInfo &applicationInfo)

services/appmgr/include/app_mgr_service.h

@@ -160,6 +160,17 @@ public:
     virtual int32_t GetRunningMultiAppInfoByBundleName(const std::string &bundleName,
         RunningMultiAppInfo &info) override;
 
+    /**
+     * GetAllRunningInstanceKeysByBundleName, call GetAllRunningInstanceKeysByBundleName() through proxy project.
+     * Obtains running isntance keys of multi-instance app that are running on the device.
+     *
+     * @param bundlename, bundle name in Application record.
+     * @param instanceKeys, output instance keys of the multi-insatnce app.
+     * @return ERR_OK ,return back success，others fail.
+     */
+    virtual int32_t GetAllRunningInstanceKeysByBundleName(const std::string &bundleName,
+        std::vector<std::string> &instanceKeys) override;
+
     /**
      * GetRunningProcessesByBundleType, call GetRunningProcessesByBundleType() through proxy project.
      * Obtains information about application processes by bundle type that are running on the device.

services/appmgr/include/app_mgr_service_inner.h

@@ -349,6 +349,17 @@ public:
     virtual int32_t GetRunningMultiAppInfoByBundleName(const std::string &bundleName,
         RunningMultiAppInfo &info);
 
+    /**
+     * GetAllRunningInstanceKeysByBundleName, call GetAllRunningInstanceKeysByBundleName() through proxy project.
+     * Obtains running isntance keys of multi-instance app that are running on the device.
+     *
+     * @param bundlename, bundle name in Application record.
+     * @param instanceKeys, output instance keys of the multi-insatnce app.
+     * @return ERR_OK ,return back success，others fail.
+     */
+    virtual int32_t GetAllRunningInstanceKeysByBundleName(const std::string &bundleName,
+        std::vector<std::string> &instanceKeys);
+
     /**
      * GetRunningProcessesByBundleType, Obtains information about application processes by bundle type.
      *
@@ -465,15 +476,13 @@ public:
     int32_t StartNativeProcessForDebugger(const AAFwk::Want &want);
 
     std::shared_ptr<AppRunningRecord> CreateAppRunningRecord(
-        sptr<IRemoteObject> token,
-        sptr<IRemoteObject> preToken,
+        std::shared_ptr<AbilityRuntime::LoadParam> loadParam,
         std::shared_ptr<ApplicationInfo> appInfo,
         std::shared_ptr<AbilityInfo> abilityInfo,
         const std::string &processName,
         const BundleInfo &bundleInfo,
         const HapModuleInfo &hapModuleInfo,
         std::shared_ptr<AAFwk::Want> want,
-        int32_t abilityRecordId,
         bool isKia = false);
 
     /**
@@ -1482,6 +1491,8 @@ private:
     void GetRunningCloneAppInfo(const std::shared_ptr<AppRunningRecord> &appRecord,
         RunningMultiAppInfo &info);
 
+    void GetRunningMultiInstanceKeys(const std::shared_ptr<AppRunningRecord> &appRecord,
+        std::vector<std::string> &instanceKeys);
     /**
      * To Prevent process being killed when ability is starting in an existing process,
      * we need notify memmgr to increase process priority.
@@ -1568,6 +1579,11 @@ private:
         bool &isWatermarkEnabled, bool &isFileUri, std::string &processName);
     int32_t ProcessKia(bool isKia, std::shared_ptr<AppRunningRecord> appRecord,
         const std::string& watermarkBusinessName, bool isWatermarkEnabled);
+    bool CheckAppRecordAndPriorityObject(const std::shared_ptr<AppRunningRecord> &appRecord);
+    void GetAppCloneInfo(const std::shared_ptr<AppRunningRecord> &appRecord,
+        RunningMultiAppInfo &info);
+    void GetMultiInstanceInfo(const std::shared_ptr<AppRunningRecord> &appRecord,
+        RunningMultiAppInfo &info);
     const std::string TASK_ON_CALLBACK_DIED = "OnCallbackDiedTask";
     std::vector<AppStateCallbackWithUserId> appStateCallbacks_;
     std::shared_ptr<RemoteClientManager> remoteClientManager_;

services/appmgr/include/app_running_manager.h

@@ -58,8 +58,8 @@ public:
      *
      * @return AppRunningRecord pointer if success get or create.
      */
-    std::shared_ptr<AppRunningRecord> CreateAppRunningRecord(
-        const std::shared_ptr<ApplicationInfo> &appInfo, const std::string &processName, const BundleInfo &bundleInfo);
+    std::shared_ptr<AppRunningRecord> CreateAppRunningRecord(const std::shared_ptr<ApplicationInfo> &appInfo,
+        const std::string &processName, const BundleInfo &bundleInfo, const std::string &instanceKey);
 
     /**
      * CheckAppRunningRecordIsExist, Get process record by application name and process Name.
@@ -72,7 +72,7 @@ public:
      */
     std::shared_ptr<AppRunningRecord> CheckAppRunningRecordIsExist(const std::string &appName,
         const std::string &processName, const int uid, const BundleInfo &bundleInfo,
-        const std::string &specifiedProcessFlag = "", bool *isProCache = nullptr);
+        const std::string &specifiedProcessFlag = "", bool *isProCache = nullptr, const std::string &instanceKey = "");
 
 #ifdef APP_NO_RESPONSE_DIALOG
     /**

services/appmgr/include/app_running_record.h

@@ -630,6 +630,8 @@ public:
     bool IsKilling() const;
     void SetAppIndex(const int32_t appIndex);
     int32_t GetAppIndex() const;
+    void SetInstanceKey(const std::string& instanceKey);
+    std::string GetInstanceKey() const;
     void SetSecurityFlag(bool securityFlag);
     bool GetSecurityFlag() const;
 
@@ -989,6 +991,7 @@ private:
     ffrt::mutex renderPidSetLock_;
     AppSpawnStartMsg startMsg_;
     int32_t appIndex_ = 0;
+    std::string instanceKey_;
     bool securityFlag_ = false;
     int32_t requestProcCode_ = 0;
     ProcessChangeReason processChangeReason_ = ProcessChangeReason::REASON_NONE;

services/appmgr/src/app_mgr_service.cpp

@@ -397,6 +397,16 @@ int32_t AppMgrService::GetRunningMultiAppInfoByBundleName(const std::string &bun
     return appMgrServiceInner_->GetRunningMultiAppInfoByBundleName(bundleName, info);
 }
 
+
+int32_t AppMgrService::GetAllRunningInstanceKeysByBundleName(const std::string &bundleName,
+    std::vector<std::string> &instanceKeys)
+{
+    if (!IsReady()) {
+        return ERR_INVALID_OPERATION;
+    }
+    return appMgrServiceInner_->GetAllRunningInstanceKeysByBundleName(bundleName, instanceKeys);
+}
+
 int32_t AppMgrService::GetRunningProcessesByBundleType(BundleType bundleType,
     std::vector<RunningProcessInfo> &info)
 {

services/appmgr/src/app_mgr_service_inner.cpp

@@ -358,8 +358,9 @@ void AppMgrServiceInner::StartSpecifiedProcess(const AAFwk::Want &want, const Ap
     auto abilityInfoPtr = std::make_shared<AbilityInfo>(abilityInfo);
     MakeProcessName(abilityInfoPtr, appInfo, hapModuleInfo, appIndex, "", processName);
     TAG_LOGD(AAFwkTag::APPMGR, "processName = %{public}s", processName.c_str());
-    auto mainAppRecord =
-        appRunningManager_->CheckAppRunningRecordIsExist(appInfo->name, processName, appInfo->uid, bundleInfo);
+    auto instanceKey = want.GetStringParam(Want::APP_INSTANCE_KEY);
+    auto mainAppRecord = appRunningManager_->CheckAppRunningRecordIsExist(appInfo->name, processName, appInfo->uid,
+        bundleInfo, "", nullptr, instanceKey);
     if (mainAppRecord != nullptr) {
         TAG_LOGD(AAFwkTag::APPMGR, "main process exists.");
         mainAppRecord->SetScheduleNewProcessRequestState(requestId, want, hapModuleInfo.moduleName);
@@ -475,8 +476,8 @@ void AppMgrServiceInner::HandlePreloadApplication(const PreloadRequest &request)
         NotifyAppRunningStatusEvent(
             bundleInfo.name, appInfo->uid, AbilityRuntime::RunningStatus::APP_RUNNING_START);
     }
-    appRecord = CreateAppRunningRecord(nullptr, nullptr, appInfo, abilityInfo, processName, bundleInfo,
-        hapModuleInfo, want, NO_ABILITY_RECORD_ID);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    appRecord = CreateAppRunningRecord(loadParam, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, want);
     if (appRecord != nullptr) {
         appRecord->SetPreloadState(PreloadState::PRELOADING);
         LoadAbilityNoAppRecord(appRecord, false, appInfo, abilityInfo, processName, specifiedProcessFlag, bundleInfo,
@@ -603,7 +604,7 @@ void AppMgrServiceInner::LoadAbility(std::shared_ptr<AbilityInfo> abilityInfo, s
     std::shared_ptr<AppRunningRecord> appRecord;
     bool isProcCache = false;
     appRecord = appRunningManager_->CheckAppRunningRecordIsExist(appInfo->name,
-        processName, appInfo->uid, bundleInfo, specifiedProcessFlag, &isProcCache);
+        processName, appInfo->uid, bundleInfo, specifiedProcessFlag, &isProcCache, loadParam->instanceKey);
     if (appRecord && abilityInfo->type == AppExecFwk::AbilityType::PAGE) {
         NotifyMemMgrPriorityChanged(appRecord);
     }
@@ -616,8 +617,8 @@ void AppMgrServiceInner::LoadAbility(std::shared_ptr<AbilityInfo> abilityInfo, s
             NotifyAppRunningStatusEvent(
                 bundleInfo.name, appInfo->uid, AbilityRuntime::RunningStatus::APP_RUNNING_START);
         }
-        appRecord = CreateAppRunningRecord(loadParam->token, loadParam->preToken, appInfo, abilityInfo,
-            processName, bundleInfo, hapModuleInfo, want, loadParam->abilityRecordId, isKia);
+        appRecord = CreateAppRunningRecord(loadParam, appInfo, abilityInfo,
+            processName, bundleInfo, hapModuleInfo, want, isKia);
         LoadAbilityNoAppRecord(appRecord, loadParam->isShellCall, appInfo, abilityInfo, processName,
             specifiedProcessFlag, bundleInfo, hapModuleInfo, want, appExistFlag, false, loadParam->token);
         if (ProcessKia(isKia, appRecord, watermarkBusinessName, isWatermarkEnabled) != ERR_OK) {
@@ -1820,8 +1821,140 @@ int32_t AppMgrServiceInner::GetRunningMultiAppInfoByBundleName(const std::string
     return ERR_OK;
 }
 
+int32_t AppMgrServiceInner::GetAllRunningInstanceKeysByBundleName(const std::string &bundleName,
+    std::vector<std::string> &instanceKeys)
+{
+    if (bundleName.empty()) {
+        TAG_LOGE(AAFwkTag::APPMGR, "bundlename null");
+        return AAFwk::INVALID_PARAMETERS_ERR;
+    }
+    if (remoteClientManager_ == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "remoteClientManager_ null");
+        return ERR_INVALID_VALUE;
+    }
+    auto bundleMgrHelper = remoteClientManager_->GetBundleManagerHelper();
+    if (bundleMgrHelper == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "bundleMgrHelper null");
+        return ERR_INVALID_VALUE;
+    }
+    ApplicationInfo appInfo;
+    auto queryRet = IN_PROCESS_CALL(bundleMgrHelper->GetApplicationInfo(bundleName,
+        ApplicationFlag::GET_BASIC_APPLICATION_INFO, currentUserId_, appInfo));
+    if (!queryRet) {
+        TAG_LOGE(AAFwkTag::APPMGR, "bundle unexist");
+        return AAFwk::ERR_BUNDLE_NOT_EXIST;
+    }
+    if (appInfo.multiAppMode.multiAppModeType != MultiAppModeType::MULTI_INSTANCE) {
+        TAG_LOGE(AAFwkTag::APPMGR, "bundle unsupport multi-instance");
+        return AAFwk::ERR_MULTI_INSTANCE_NOT_SUPPORTED;
+    }
+    if (!appRunningManager_) {
+        TAG_LOGE(AAFwkTag::APPMGR, "appRunningManager null");
+        return ERR_INVALID_VALUE;
+    }
+    auto multiAppInfoMap = appRunningManager_->GetAppRunningRecordMap();
+    for (const auto &item : multiAppInfoMap) {
+        const std::shared_ptr<AppRunningRecord> &appRecord = item.second;
+        if (appRecord == nullptr || appRecord->GetBundleName() != bundleName) {
+            continue;
+        }
+        if (GetUserIdByUid(appRecord->GetUid()) != currentUserId_) {
+            continue;
+        }
+        GetRunningMultiInstanceKeys(appRecord, instanceKeys);
+    }
+    return ERR_OK;
+}
+
 void AppMgrServiceInner::GetRunningCloneAppInfo(const std::shared_ptr<AppRunningRecord> &appRecord,
     RunningMultiAppInfo &info)
+{
+    if (info.mode == static_cast<int32_t>(MultiAppModeType::APP_CLONE)) {
+        GetAppCloneInfo(appRecord, info);
+        return;
+    }
+    if (info.mode == static_cast<int32_t>(MultiAppModeType::MULTI_INSTANCE)) {
+        GetMultiInstanceInfo(appRecord, info);
+    }
+}
+
+bool AppMgrServiceInner::CheckAppRecordAndPriorityObject(const std::shared_ptr<AppRunningRecord> &appRecord)
+{
+    if (!appRecord) {
+        TAG_LOGE(AAFwkTag::APPMGR, "appRecord null");
+        return false;
+    }
+    if (appRecord->GetPriorityObject() == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "priorityObject null");
+        return false;
+    }
+    return true;
+}
+
+void AppMgrServiceInner::GetAppCloneInfo(const std::shared_ptr<AppRunningRecord> &appRecord,
+    RunningMultiAppInfo &info)
+{
+    if (!CheckAppRecordAndPriorityObject(appRecord)) {
+        return;
+    }
+    auto PriorityObject = appRecord->GetPriorityObject();
+    size_t index = 0;
+    for (; index < info.runningAppClones.size(); index++) {
+        if (info.runningAppClones[index].appCloneIndex == appRecord->GetAppIndex()) {
+            break;
+        }
+    }
+    auto childProcessRecordMap = appRecord->GetChildProcessRecordMap();
+    if (index < info.runningAppClones.size()) {
+        info.runningAppClones[index].pids.emplace_back(PriorityObject->GetPid());
+        for (auto it : childProcessRecordMap) {
+            info.runningAppClones[index].pids.emplace_back(it.first);
+        }
+        return;
+    }
+    RunningAppClone cloneInfo;
+    cloneInfo.appCloneIndex = appRecord->GetAppIndex();
+    cloneInfo.uid = appRecord->GetUid();
+    cloneInfo.pids.emplace_back(PriorityObject->GetPid());
+    for (auto it : childProcessRecordMap) {
+        cloneInfo.pids.emplace_back(it.first);
+    }
+    info.runningAppClones.emplace_back(cloneInfo);
+}
+
+void AppMgrServiceInner::GetMultiInstanceInfo(const std::shared_ptr<AppRunningRecord> &appRecord,
+    RunningMultiAppInfo &info)
+{
+    if (!CheckAppRecordAndPriorityObject(appRecord)) {
+        return;
+    }
+    auto PriorityObject = appRecord->GetPriorityObject();
+    size_t index = 0;
+    for (; index < info.runningMultiIntanceInfos.size(); index++) {
+        if (info.runningMultiIntanceInfos[index].instanceKey == appRecord->GetInstanceKey()) {
+            break;
+        }
+    }
+    auto childProcessRecordMap = appRecord->GetChildProcessRecordMap();
+    if (index < info.runningMultiIntanceInfos.size()) {
+        info.runningMultiIntanceInfos[index].pids.emplace_back(PriorityObject->GetPid());
+        for (auto it : childProcessRecordMap) {
+            info.runningMultiIntanceInfos[index].pids.emplace_back(it.first);
+        }
+        return;
+    }
+    RunningMultiInstanceInfo instanceInfo;
+    instanceInfo.instanceKey = appRecord->GetInstanceKey();
+    instanceInfo.uid = appRecord->GetUid();
+    instanceInfo.pids.emplace_back(PriorityObject->GetPid());
+    for (auto it : childProcessRecordMap) {
+        instanceInfo.pids.emplace_back(it.first);
+    }
+    info.runningMultiIntanceInfos.emplace_back(instanceInfo);
+}
+
+void AppMgrServiceInner::GetRunningMultiInstanceKeys(const std::shared_ptr<AppRunningRecord> &appRecord,
+    std::vector<std::string> &instanceKeys)
 {
     if (!appRecord) {
         TAG_LOGE(AAFwkTag::APPMGR, "appRecord null");
@@ -1832,30 +1965,13 @@ void AppMgrServiceInner::GetRunningCloneAppInfo(const std::shared_ptr<AppRunning
         TAG_LOGE(AAFwkTag::APPMGR, "priorityObject null");
         return;
     }
-    if (info.mode == static_cast<int32_t>(MultiAppModeType::APP_CLONE)) {
-        size_t index = 0;
-        for (; index < info.runningAppClones.size(); index++) {
-            if (info.runningAppClones[index].appCloneIndex == appRecord->GetAppIndex()) {
-                break;
-            }
-        }
-        auto childProcessRecordMap = appRecord->GetChildProcessRecordMap();
-        if (index < info.runningAppClones.size()) {
-            info.runningAppClones[index].pids.emplace_back(PriorityObject->GetPid());
-            for (auto it : childProcessRecordMap) {
-                info.runningAppClones[index].pids.emplace_back(it.first);
-            }
-        } else {
-            RunningAppClone cloneInfo;
-            cloneInfo.appCloneIndex = appRecord->GetAppIndex();
-            cloneInfo.uid = appRecord->GetUid();
-            cloneInfo.pids.emplace_back(PriorityObject->GetPid());
-            for (auto it : childProcessRecordMap) {
-                cloneInfo.pids.emplace_back(it.first);
-            }
-            info.runningAppClones.emplace_back(cloneInfo);
+    size_t index = 0;
+    for (; index < instanceKeys.size(); ++index) {
+        if (instanceKeys[index] == appRecord->GetInstanceKey()) {
+            return;
         }
     }
+    instanceKeys.emplace_back(appRecord->GetInstanceKey());
 }
 
 int32_t AppMgrServiceInner::GetProcessRunningInfosByUserId(std::vector<RunningProcessInfo> &info, int32_t userId)
@@ -2222,10 +2338,10 @@ std::shared_ptr<AppRunningRecord> AppMgrServiceInner::GetAppRunningRecordByPid(c
     return appRunningManager_->GetAppRunningRecordByPid(pid);
 }
 
-std::shared_ptr<AppRunningRecord> AppMgrServiceInner::CreateAppRunningRecord(sptr<IRemoteObject> token,
-    sptr<IRemoteObject> preToken, std::shared_ptr<ApplicationInfo> appInfo,
+std::shared_ptr<AppRunningRecord> AppMgrServiceInner::CreateAppRunningRecord(
+    std::shared_ptr<AbilityRuntime::LoadParam> loadParam, std::shared_ptr<ApplicationInfo> appInfo,
     std::shared_ptr<AbilityInfo> abilityInfo, const std::string &processName, const BundleInfo &bundleInfo,
-    const HapModuleInfo &hapModuleInfo, std::shared_ptr<AAFwk::Want> want, int32_t abilityRecordId, bool isKia)
+    const HapModuleInfo &hapModuleInfo, std::shared_ptr<AAFwk::Want> want, bool isKia)
 {
     HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
     if (want != nullptr && (want->GetBoolParam(DEBUG_APP, false) || want->GetBoolParam(NATIVE_DEBUG, false))) {
@@ -2234,11 +2350,12 @@ std::shared_ptr<AppRunningRecord> AppMgrServiceInner::CreateAppRunningRecord(spt
             return nullptr;
         }
     }
-    if (!appRunningManager_) {
-        TAG_LOGE(AAFwkTag::APPMGR, "appRunningManager null");
+    if (!appRunningManager_ || loadParam == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "appRunningManager or loadParam null");
         return nullptr;
     }
-    auto appRecord = appRunningManager_->CreateAppRunningRecord(appInfo, processName, bundleInfo);
+    auto appRecord = appRunningManager_->CreateAppRunningRecord(appInfo, processName, bundleInfo,
+        loadParam->instanceKey);
     if (!appRecord) {
         TAG_LOGE(AAFwkTag::APPMGR, "get appRecord fail");
         return nullptr;
@@ -2249,7 +2366,7 @@ std::shared_ptr<AppRunningRecord> AppMgrServiceInner::CreateAppRunningRecord(spt
     appRecord->SetEmptyKeepAliveAppState(false);
     appRecord->SetTaskHandler(taskHandler_);
     appRecord->SetEventHandler(eventHandler_);
-    appRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo, want, abilityRecordId);
+    appRecord->AddModule(appInfo, abilityInfo, loadParam->token, hapModuleInfo, want, loadParam->abilityRecordId);
     appRecord->SetIsKia(isKia);
     if (want) {
         appRecord->SetDebugApp(want->GetBoolParam(DEBUG_APP, false));
@@ -3761,7 +3878,7 @@ void AppMgrServiceInner::StartEmptyResidentProcess(
         return;
     }
 
-    auto appRecord = appRunningManager_->CreateAppRunningRecord(appInfo, processName, info);
+    auto appRecord = appRunningManager_->CreateAppRunningRecord(appInfo, processName, info, "");
     if (!appRecord) {
         TAG_LOGE(AAFwkTag::APPMGR, "start process [%{public}s] fail", processName.c_str());
         return;
@@ -4056,7 +4173,7 @@ int AppMgrServiceInner::StartEmptyProcess(const AAFwk::Want &want, const sptr<IR
         TAG_LOGE(AAFwkTag::APPMGR, "disable start process in logout user");
         return ERR_INVALID_OPERATION;
     }
-    auto appRecord = appRunningManager_->CreateAppRunningRecord(appInfo, processName, info);
+    auto appRecord = appRunningManager_->CreateAppRunningRecord(appInfo, processName, info, "");
     CHECK_POINTER_AND_RETURN_VALUE(appRecord, ERR_INVALID_VALUE);
 
     auto isDebug = want.GetBoolParam(DEBUG_APP, false);
@@ -4183,7 +4300,9 @@ void AppMgrServiceInner::StartSpecifiedAbility(const AAFwk::Want &want, const Ap
     hapModules.emplace_back(hapModuleInfo);
 
     std::shared_ptr<AppRunningRecord> appRecord;
-    appRecord = appRunningManager_->CheckAppRunningRecordIsExist(appInfo->name, processName, appInfo->uid, bundleInfo);
+    auto instanceKey = want.GetStringParam(Want::APP_INSTANCE_KEY);
+    appRecord = appRunningManager_->CheckAppRunningRecordIsExist(appInfo->name, processName, appInfo->uid, bundleInfo,
+        "", nullptr, instanceKey);
     if (!appRecord) {
         bool appExistFlag = appRunningManager_->CheckAppRunningRecordIsExistByBundleName(bundleInfo.name);
         bool appMultiUserExistFlag = appRunningManager_->CheckAppRunningRecordIsExistByUid(bundleInfo.uid);
@@ -4192,7 +4311,7 @@ void AppMgrServiceInner::StartSpecifiedAbility(const AAFwk::Want &want, const Ap
                 bundleInfo.name, appInfo->uid, AbilityRuntime::RunningStatus::APP_RUNNING_START);
         }
         // new app record
-        appRecord = appRunningManager_->CreateAppRunningRecord(appInfo, processName, bundleInfo);
+        appRecord = appRunningManager_->CreateAppRunningRecord(appInfo, processName, bundleInfo, instanceKey);
         if (!appRecord) {
             TAG_LOGE(AAFwkTag::APPMGR, "start process [%{public}s] fail", processName.c_str());
             return;

services/appmgr/src/app_running_manager.cpp

@@ -64,7 +64,8 @@ void AppRunningManager::initConfig(const Configuration &config)
 }
 
 std::shared_ptr<AppRunningRecord> AppRunningManager::CreateAppRunningRecord(
-    const std::shared_ptr<ApplicationInfo> &appInfo, const std::string &processName, const BundleInfo &bundleInfo)
+    const std::shared_ptr<ApplicationInfo> &appInfo, const std::string &processName, const BundleInfo &bundleInfo,
+    const std::string &instanceKey)
 {
     if (!appInfo) {
         TAG_LOGE(AAFwkTag::APPMGR, "param error");
@@ -96,6 +97,7 @@ std::shared_ptr<AppRunningRecord> AppRunningManager::CreateAppRunningRecord(
     appRecord->SetSignCode(signCode);
     appRecord->SetJointUserId(bundleInfo.jointUserId);
     appRecord->SetAppIdentifier(bundleInfo.signatureInfo.appIdentifier);
+    appRecord->SetInstanceKey(instanceKey);
     {
         std::lock_guard guard(runningRecordMapMutex_);
         appRunningRecordMap_.emplace(recordId, appRecord);
@@ -109,7 +111,7 @@ std::shared_ptr<AppRunningRecord> AppRunningManager::CreateAppRunningRecord(
 
 std::shared_ptr<AppRunningRecord> AppRunningManager::CheckAppRunningRecordIsExist(const std::string &appName,
     const std::string &processName, const int uid, const BundleInfo &bundleInfo,
-    const std::string &specifiedProcessFlag, bool *isProCache)
+    const std::string &specifiedProcessFlag, bool *isProCache, const std::string &instanceKey)
 {
     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
     TAG_LOGD(AAFwkTag::APPMGR,
@@ -136,7 +138,7 @@ std::shared_ptr<AppRunningRecord> AppRunningManager::CheckAppRunningRecordIsExis
     }
     for (const auto &item : appRunningMap) {
         const auto &appRecord = item.second;
-        if (appRecord && appRecord->GetProcessName() == processName &&
+        if (appRecord && appRecord->GetProcessName() == processName && appRecord->GetInstanceKey() == instanceKey &&
             (specifiedProcessFlag.empty() || appRecord->GetSpecifiedProcessFlag() == specifiedProcessFlag) &&
             !(appRecord->IsTerminating()) && !(appRecord->IsKilling()) && !(appRecord->GetRestartAppFlag()) &&
             !(appRecord->IsUserRequestCleaning())) {

services/appmgr/src/app_running_record.cpp

@@ -484,6 +484,7 @@ void AppRunningRecord::LaunchApplication(const Configuration &config)
     launchData.SetUId(mainUid_);
     launchData.SetUserTestInfo(userTestRecord_);
     launchData.SetAppIndex(appIndex_);
+    launchData.SetInstanceKey(instanceKey_);
     launchData.SetDebugApp(isDebugApp_);
     launchData.SetPerfCmd(perfCmd_);
     launchData.SetErrorInfoEnhance(isErrorInfoEnhance_);
@@ -1845,6 +1846,11 @@ void AppRunningRecord::SetAppIndex(const int32_t appIndex)
     appIndex_ = appIndex;
 }
 
+void AppRunningRecord::SetInstanceKey(const std::string& instanceKey)
+{
+    instanceKey_ = instanceKey;
+}
+
 void AppRunningRecord::GetSplitModeAndFloatingMode(bool &isSplitScreenMode, bool &isFloatingWindowMode)
 {
     auto abilitiesMap = GetAbilities();
@@ -1877,6 +1883,11 @@ int32_t AppRunningRecord::GetAppIndex() const
     return appIndex_;
 }
 
+std::string AppRunningRecord::GetInstanceKey() const
+{
+    return instanceKey_;
+}
+
 void AppRunningRecord::SetSecurityFlag(bool securityFlag)
 {
     securityFlag_ = securityFlag;

services/common/include/app_utils.h

@@ -53,6 +53,7 @@ public:
     bool EnableMoveUIAbilityToBackgroundApi();
     bool IsLaunchEmbededUIAbility();
     bool IsSupportNativeChildProcess();
+    bool IsSupportMultiInstance();
     bool IsAllowResidentInExtremeMemory(const std::string& bundleName, const std::string& abilityName = "");
     bool IsAllowNativeChildProcess(const std::string &appIdentifier);
     int32_t GetLimitMaximumExtensionsPerProc();
@@ -84,6 +85,7 @@ private:
     volatile DeviceConfiguration<bool> enableMoveUIAbilityToBackgroundApi_ = {false, true};
     volatile DeviceConfiguration<bool> isLaunchEmbededUIAbility_ = {false, false};
     volatile DeviceConfiguration<bool> isSupportNativeChildProcess_ = {false, false};
+    volatile DeviceConfiguration<bool> isSupportMultiInstance_ = {false, false};
     DeviceConfiguration<std::vector<std::pair<std::string, std::string>>>
         residentProcessInExtremeMemory_ = {false, {}};
     DeviceConfiguration<std::vector<std::string>>

services/common/src/app_utils.cpp

@@ -66,6 +66,7 @@ constexpr const char* BROKER_DELEGATE_BUNDLE_NAME = "const.sys.abilityms.broker_
 constexpr const char* COLLABORATOR_BROKER_UID = "const.sys.abilityms.collaborator_broker_uid";
 constexpr const char* COLLABORATOR_BROKER_RESERVE_UID = "const.sys.abilityms.collaborator_broker_reserve_uid";
 constexpr const char* MAX_CHILD_PROCESS = "const.max_native_child_process";
+constexpr const char* SUPPORT_MULTI_INSTANCE = "const.abilityms.support_multi_instance";
 }
 
 AppUtils::~AppUtils() {}
@@ -438,5 +439,15 @@ int32_t AppUtils::MaxChildProcess()
     TAG_LOGD(AAFwkTag::DEFAULT, "MaxChildProcess: %{public}d", maxChildProcess_.value);
     return maxChildProcess_.value;
 }
+
+bool AppUtils::IsSupportMultiInstance()
+{
+    if (!isSupportMultiInstance_.isLoaded) {
+        isSupportMultiInstance_.value = system::GetBoolParameter(SUPPORT_MULTI_INSTANCE, false);
+        isSupportMultiInstance_.isLoaded = true;
+    }
+    TAG_LOGD(AAFwkTag::DEFAULT, "called %{public}d", isSupportMultiInstance_.value);
+    return isSupportMultiInstance_.value;
+}
 }  // namespace AAFwk
 }  // namespace OHOS

test/fuzztest/abilityappmgrapprunningmanager_fuzzer/abilityappmgrapprunningmanager_fuzzer.cpp

@@ -175,7 +175,7 @@ bool DoSomethingInterestingWithMyAPI(const char* data, size_t size)
     std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
     std::string jsonStr(data, size);
     BundleInfo bundleInfo;
-    manager->CreateAppRunningRecord(appInfo, jsonStr, bundleInfo);
+    manager->CreateAppRunningRecord(appInfo, jsonStr, bundleInfo, "");
     int uid = static_cast<int>(GetU32Data(data));
     manager->CheckAppRunningRecordIsExist(jsonStr, jsonStr, uid, bundleInfo, jsonStr);
     manager->CheckAppRunningRecordIsExistByBundleName(jsonStr);

test/mock/frameworks_kits_appkit_test/include/mock_app_mgr_service.h

@@ -82,6 +82,8 @@ public:
     MOCK_METHOD2(UpdateRenderState, int32_t(pid_t renderPid, int32_t state));
     MOCK_METHOD2(GetRunningMultiAppInfoByBundleName, int32_t(const std::string &bundleName,
         RunningMultiAppInfo &info));
+    MOCK_METHOD2(GetAllRunningInstanceKeysByBundleName, int32_t(const std::string &bundleName,
+        std::vector<std::string> &instanceKeys));
     MOCK_METHOD1(SetSupportedProcessCacheSelf, int32_t(bool isSupported));
     MOCK_METHOD2(SetSupportedProcessCache, int32_t(int32_t pid, bool isSupport));
     MOCK_METHOD3(StartNativeChildProcess, int32_t(const std::string &libName, int32_t childProcessCount,
@@ -159,6 +161,12 @@ public:
         return 0;
     }
 
+    virtual int32_t GetRunningMultiAppInfoByBundleName(const std::string &bundleName,
+        RunningMultiAppInfo &info) override
+    {
+        return 0;
+    }
+
     virtual int GetRunningProcessesByBundleType(const BundleType bundleType,
         std::vector<RunningProcessInfo>& info) override
     {

test/mock/mock_appmgr_service/include/mock_app_mgr_service_inner.h

@@ -46,6 +46,8 @@ public:
         int32_t(const std::string&, const int32_t, const pid_t, int32_t appCloneIndex, int32_t userId));
     MOCK_METHOD1(IsBackgroundRunningRestricted, int32_t(const std::string&));
     MOCK_METHOD1(GetAllRunningProcesses, int32_t(std::vector<RunningProcessInfo>&));
+    MOCK_METHOD2(GetAllRunningInstanceKeysByBundleName, int32_t(const std::string &bundleName,
+        std::vector<std::string> &instanceKeys));
     MOCK_METHOD1(GetAllRenderProcesses, int32_t(std::vector<RenderProcessInfo>&));
     MOCK_METHOD1(GetAllChildrenProcesses, int(std::vector<ChildProcessInfo>&));
     MOCK_METHOD1(RegisterAppStateCallback, void(const sptr<IAppStateCallback>& callback));

test/mock/services_abilitymgr_test/libs/appexecfwk_core/include/appmgr/app_mgr_client.h

@@ -129,6 +129,17 @@ public:
      */
     virtual AppMgrResultCode GetAllRunningProcesses(std::vector<RunningProcessInfo>& info);
 
+    /**
+     * GetAllRunningInstanceKeysByBundleName, call GetAllRunningInstanceKeysByBundleName() through proxy project.
+     * Obtains running isntance keys of multi-instance app that are running on the device.
+     *
+     * @param bundlename, bundle name in Application record.
+     * @param instanceKeys, output instance keys of the multi-insatnce app.
+     * @return ERR_OK ,return back success，others fail.
+     */
+    virtual AppMgrResultCode GetAllRunningInstanceKeysByBundleName(const std::string &bundleName,
+        std::vector<std::string> &instanceKeys);
+
     /**
      * GetAllRenderProcesses, call GetAllRenderProcesses() through proxy project.
      * Obtains information about render processes that are running on the device.

test/mock/services_abilitymgr_test/libs/appexecfwk_core/include/appmgr/app_mgr_interface.h

@@ -111,6 +111,17 @@ public:
      */
     virtual int GetAllRunningProcesses(std::vector<RunningProcessInfo>& info) = 0;
 
+    /**
+     * GetAllRunningInstanceKeysByBundleName, call GetAllRunningInstanceKeysByBundleName() through proxy project.
+     * Obtains running isntance keys of multi-instance app that are running on the device.
+     *
+     * @param bundlename, bundle name in Application record.
+     * @param instanceKeys, output instance keys of the multi-insatnce app.
+     * @return ERR_OK ,return back success，others fail.
+     */
+    virtual int32_t GetAllRunningInstanceKeysByBundleName(const std::string &bundleName,
+        std::vector<std::string> &instanceKeys) = 0;
+
     /**
      * GetAllRenderProcesses, call GetAllRenderProcesses() through proxy project.
      * Obtains information about render processes that are running on the device.

test/mock/services_abilitymgr_test/libs/appexecfwk_core/src/appmgr/mock_app_scheduler.cpp

@@ -43,7 +43,7 @@ bool AppScheduler::Init(const std::weak_ptr<AppStateCallback>& callback)
 
 int AppScheduler::LoadAbility(sptr<IRemoteObject> token, sptr<IRemoteObject> preToken,
     const AppExecFwk::AbilityInfo& abilityInfo, const AppExecFwk::ApplicationInfo& applicationInfo,
-    const AAFwk::Want& want, int32_t abilityRecordId)
+    const AAFwk::Want& want, int32_t abilityRecordId, const std::string &instanceKey)
 {
     TAG_LOGI(AAFwkTag::TEST, "Test AppScheduler::LoadAbility()");
     if (applicationInfo.bundleName.find("com.ix.First.Test") != std::string::npos) {

test/mock/services_appmgr_test/include/mock_app_mgr_service.h

@@ -93,6 +93,8 @@ public:
         std::vector<RunningProcessInfo> &info));
     MOCK_METHOD2(GetRunningMultiAppInfoByBundleName, int32_t(const std::string &bundleName,
         RunningMultiAppInfo &info));
+    MOCK_METHOD2(GetAllRunningInstanceKeysByBundleName, int32_t(const std::string &bundleName,
+        std::vector<std::string> &instanceKeys));
     MOCK_METHOD2(IsApplicationRunning, int32_t(const std::string &bundleName, bool &isRunning));
     MOCK_METHOD3(IsAppRunning, int32_t(const std::string &bundleName,
         int32_t appCloneIndex, bool &isRunning));

test/mock/services_appmgr_test/include/mock_app_mgr_service_inner.h

@@ -49,6 +49,8 @@ public:
     MOCK_METHOD3(ClearUpApplicationDataBySelf, int32_t(int32_t, pid_t, int32_t userId));
     MOCK_METHOD1(IsBackgroundRunningRestricted, int32_t(const std::string&));
     MOCK_METHOD1(GetAllRunningProcesses, int32_t(std::vector<RunningProcessInfo>&));
+    MOCK_METHOD2(GetAllRunningInstanceKeysByBundleName, int32_t(const std::string &bundleName,
+        std::vector<std::string> &instanceKeys));
     MOCK_METHOD1(GetAllRenderProcesses, int32_t(std::vector<RenderProcessInfo>&));
     MOCK_METHOD1(GetAllChildrenProcesses, int(std::vector<ChildProcessInfo>&));
     MOCK_METHOD1(RegisterAppStateCallback, void(const sptr<IAppStateCallback>& callback));

test/moduletest/common/ams/app_mgr_service_test/ams_app_mgr_service_module_test.cpp

@@ -401,6 +401,28 @@ HWTEST_F(AppMgrServiceModuleTest, GetAllRunningProcesses_001, TestSize.Level1)
     }
 }
 
+/*
+ * Feature: AppMgrService
+ * Function: GetAllRunningInstanceKeysByBundleName
+ * SubFunction: NA
+ * FunctionPoints: AppMgrService => AppMgrServiceInner: GetAllRunningInstanceKeysByBundleName
+ * CaseDescription: Check GetAllRunningInstanceKeysByBundleName.
+ */
+HWTEST_F(AppMgrServiceModuleTest, GetAllRunningInstanceKeysByBundleName_001, TestSize.Level1)
+{
+    EXPECT_TRUE(appMgrService_);
+    EXPECT_TRUE(mockAppMgrServiceInner_);
+
+    std::string testBundleName = "testBundleName";
+    std::vector<std::string> testInstanceKeys;
+
+    EXPECT_CALL(*mockAppMgrServiceInner_, GetAllRunningInstanceKeysByBundleName(_, _))
+        .Times(1).WillOnce(Return(ERR_OK));
+
+    auto result = appMgrService_->GetAllRunningInstanceKeysByBundleName(testBundleName, testInstanceKeys);
+    EXPECT_EQ(result, ERR_OK);
+}
+
 /*
  * Feature: AppMgrService
  * Function: KillApplication

test/moduletest/common/ams/app_running_processes_info_module_test/BUILD.gn

@@ -41,6 +41,7 @@ ohos_moduletest("AppRunningProcessesInfoModuleTest") {
 
   deps = [
     "${ability_runtime_native_path}/appkit:appkit_manager_helper",
+    "${ability_runtime_path}/utils/server/startup:startup_util",
     "${ability_runtime_services_path}/common:app_util",
     "${ability_runtime_services_path}/common:res_sched_util",
     "${ability_runtime_test_path}/moduletest/common/ams:appmgr_mst_source",

test/moduletest/common/ams/app_running_processes_info_module_test/app_running_processes_info_module_test.cpp

@@ -33,6 +33,7 @@
 #include "mock_app_spawn_client.h"
 #include "mock_native_token.h"
 #include "mock_sa_call.h"
+#include "param.h"
 
 using namespace testing::ext;
 using OHOS::iface_cast;
@@ -199,8 +200,10 @@ HWTEST_F(AppRunningProcessesInfoModuleTest, ApplicationStart_001, TestSize.Level
     BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
     EXPECT_FALSE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo));
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr);
     record->SetUid(uid);
     EXPECT_TRUE(record != nullptr) << ",create apprunningrecord fail!";
 
@@ -259,8 +262,10 @@ HWTEST_F(AppRunningProcessesInfoModuleTest, ApplicationStart_002, TestSize.Level
     BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
     EXPECT_FALSE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo));
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr);
     record->SetUid(uid);
     EXPECT_TRUE(record != nullptr) << ",create apprunningrecord fail!";
 
@@ -321,8 +326,10 @@ HWTEST_F(AppRunningProcessesInfoModuleTest, ApplicationStart_003, TestSize.Level
     BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
     EXPECT_FALSE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo));
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr);
     record->SetUid(uid);
     EXPECT_TRUE(record != nullptr) << ",create apprunningrecord fail!";
 
@@ -362,9 +369,9 @@ HWTEST_F(AppRunningProcessesInfoModuleTest, ApplicationStart_003, TestSize.Level
     BundleInfo bundleInfo2;
     HapModuleInfo hapModuleInfo2;
     EXPECT_FALSE(service_->GetBundleAndHapInfo(*abilityInfo2, appInfo2, bundleInfo2, hapModuleInfo2));
-    sptr<MockAbilityToken> mockToken = new (std::nothrow) MockAbilityToken();
+    loadParam->token = new (std::nothrow) MockAbilityToken();
     auto record2 = service_->CreateAppRunningRecord(
-        mockToken, nullptr, appInfo2, abilityInfo2, processName2, bundleInfo2, hapModuleInfo2, nullptr, 0);
+        loadParam, appInfo2, abilityInfo2, processName2, bundleInfo2, hapModuleInfo2, nullptr);
     record2->SetUid(uid);
     EXPECT_TRUE(record != nullptr) << ",create apprunningrecord fail!";
 
@@ -401,8 +408,10 @@ HWTEST_F(AppRunningProcessesInfoModuleTest, ApplicationStart_004, TestSize.Level
     BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
     EXPECT_FALSE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo));
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr);
     record->SetUid(uid);
     EXPECT_TRUE(record != nullptr) << ",create apprunningrecord fail!";
 
@@ -459,8 +468,10 @@ HWTEST_F(AppRunningProcessesInfoModuleTest, ApplicationStart_005, TestSize.Level
     BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
     EXPECT_FALSE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo));
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr);
     record->SetUid(uid);
     pid_t pid = 16738;
     record->GetPriorityObject()->SetPid(pid);
@@ -521,8 +532,10 @@ HWTEST_F(AppRunningProcessesInfoModuleTest, ApplicationStart_006, TestSize.Level
     BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
     EXPECT_FALSE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo));
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr);
     record->SetUid(uid);
     pid_t pid = 16739;
     record->GetPriorityObject()->SetPid(pid);

test/moduletest/common/ams/app_service_flow_test/BUILD.gn

@@ -32,6 +32,7 @@ ohos_moduletest("AmsAppServiceFlowModuleTest") {
   deps = [
     "${ability_runtime_native_path}/ability/native:abilitykit_native",
     "${ability_runtime_native_path}/appkit:appkit_manager_helper",
+    "${ability_runtime_path}/utils/server/startup:startup_util",
     "${ability_runtime_services_path}/common:app_util",
     "${ability_runtime_services_path}/common:perm_verification",
     "${ability_runtime_services_path}/common:res_sched_util",

test/moduletest/common/ams/app_service_flow_test/ams_app_service_flow_module_test.cpp

@@ -29,6 +29,7 @@
 #include "mock_ability_token.h"
 #include "mock_app_scheduler.h"
 #include "mock_app_spawn_client.h"
+#include "param.h"
 
 using namespace testing::ext;
 using testing::_;
@@ -135,8 +136,10 @@ TestApplicationPreRunningRecord AmsAppServiceFlowModuleTest::TestCreateApplicati
     auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(
         appInfo->name, appName, appInfo->uid, bundleInfo);
     if (!appRecord) {
+        auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+        loadParam->token = token;
         appRecord = serviceInner_->CreateAppRunningRecord(
-            token, nullptr, appInfo, abilityInfo, appName, bundleInfo, hapModuleInfo, nullptr, 0);
+            loadParam, appInfo, abilityInfo, appName, bundleInfo, hapModuleInfo, nullptr);
         appRecord->GetPriorityObject()->SetPid(TestApplicationPreRunningRecord::g_pid++);
     } else {
         serviceInner_->StartAbility(token, nullptr, abilityInfo, appRecord, hapModuleInfo, nullptr, 0);

test/moduletest/mock/include/mock_app_mgr_client.h

@@ -37,6 +37,8 @@ public:
     MOCK_METHOD2(GetRunningProcessInfoByToken, void((const sptr<IRemoteObject>& token,
         AppExecFwk::RunningProcessInfo& info)));
     MOCK_METHOD1(GetAllRunningProcesses, AppMgrResultCode(std::vector<RunningProcessInfo>& info));
+    MOCK_METHOD2(GetAllRunningInstanceKeysByBundleName, AppMgrResultCode(const std::string &bundleName,
+        std::vector<std::string> &instanceKeys));
 
     AppMgrResultCode GetProcessRunningInfosByUserId(std::vector<RunningProcessInfo>& info, int32_t userId);
 

test/unittest/BUILD.gn

@@ -349,6 +349,7 @@ group("unittest") {
       "ability_manager_service_sixth_test:unittest",
       "ability_manager_service_third_test:unittest",
       "ability_manager_stub_test:unittest",
+      "ability_permission_util_test:unittest",
       "ability_record_dump_test:unittest",
       "ability_record_mgr_test:unittest",
       "ability_record_test:unittest",

test/unittest/ability_permission_util_test/BUILD.gn

@@ -0,0 +1,50 @@
+# 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/test.gni")
+import("//foundation/ability/ability_runtime/ability_runtime.gni")
+
+module_output_path = "ability_runtime/abilitymgr"
+
+ohos_unittest("ability_permission_util_test") {
+  module_out_path = module_output_path
+
+  sources = [ "ability_permission_util_test.cpp" ]
+
+  configs = [ "${ability_runtime_services_path}/abilitymgr:abilityms_config" ]
+
+  deps = [
+    "${ability_runtime_services_path}/abilitymgr:abilityms",
+    "${ability_runtime_services_path}/common:app_util",
+    "//third_party/googletest:gtest_main",
+  ]
+
+  external_deps = [
+    "ability_base:want",
+    "ability_runtime:app_manager",
+    "bundle_framework:appexecfwk_base",
+    "bundle_framework:appexecfwk_core",
+    "c_utils:utils",
+    "ffrt:libffrt",
+    "hilog:libhilog",
+    "init:libbegetutil",
+    "ipc:ipc_core",
+    "jsoncpp:jsoncpp",
+  ]
+}
+
+group("unittest") {
+  testonly = true
+
+  deps = [ ":ability_permission_util_test" ]
+}

test/unittest/ability_permission_util_test/ability_permission_util_test.cpp

@@ -0,0 +1,263 @@
+/*
+ * 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 <gtest/gtest.h>
+
+#define private public
+#include "ability_record.h"
+#include "utils/ability_permission_util.h"
+#undef private
+#include "app_utils.h"
+#include "hilog_tag_wrapper.h"
+#include "parameters.h"
+
+using namespace testing;
+using namespace testing::ext;
+
+namespace OHOS {
+namespace AAFwk {
+class AbilityPermissionUtilTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void AbilityPermissionUtilTest::SetUpTestCase(void) {}
+void AbilityPermissionUtilTest::TearDownTestCase(void) {}
+void AbilityPermissionUtilTest::SetUp() {}
+void AbilityPermissionUtilTest::TearDown() {}
+
+/**
+ * @tc.name: AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0100
+ * @tc.desc: CheckMultiInstanceAndAppClone
+ * @tc.type: FUNC
+ * @tc.require: NA
+ */
+HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0100 start");
+    Want want;
+    auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(want, 100, 0, nullptr);
+
+    bool isSupportMultiInstance = AppUtils::GetInstance().IsSupportMultiInstance();
+    std::string deviceType = OHOS::system::GetDeviceType();
+    TAG_LOGI(AAFwkTag::TEST, "current deviceType is %{public}s", deviceType.c_str());
+    if (deviceType == "2in1") {
+        EXPECT_EQ(result, RESOLVE_APP_ERR);
+    } else {
+        EXPECT_EQ(result, ERR_OK);
+    }
+
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0100 end");
+}
+
+/**
+ * @tc.name: AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0200
+ * @tc.desc: CheckMultiInstanceAndAppClone
+ * @tc.type: FUNC
+ * @tc.require: NA
+ */
+HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0200 start");
+    Want want;
+    std::string instanceKey = "app_instance_0";
+    want.SetParam(Want::APP_INSTANCE_KEY, instanceKey);
+    auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(want, 100, 0, nullptr);
+
+    bool isSupportMultiInstance = AppUtils::GetInstance().IsSupportMultiInstance();
+    std::string deviceType = OHOS::system::GetDeviceType();
+    TAG_LOGI(AAFwkTag::TEST, "current deviceType is %{public}s", deviceType.c_str());
+    if (deviceType == "2in1") {
+        EXPECT_EQ(result, RESOLVE_APP_ERR);
+    } else {
+        EXPECT_EQ(result, ERR_MULTI_INSTANCE_NOT_SUPPORTED);
+    }
+
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0200 end");
+}
+
+/**
+ * @tc.name: AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0300
+ * @tc.desc: CheckMultiInstanceAndAppClone
+ * @tc.type: FUNC
+ * @tc.require: NA
+ */
+HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0300, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0300 start");
+    Want want;
+    want.SetParam(Want::CREATE_APP_INSTANCE_KEY, true);
+    auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(want, 100, 0, nullptr);
+
+    bool isSupportMultiInstance = AppUtils::GetInstance().IsSupportMultiInstance();
+    std::string deviceType = OHOS::system::GetDeviceType();
+    TAG_LOGI(AAFwkTag::TEST, "current deviceType is %{public}s", deviceType.c_str());
+    if (deviceType == "2in1") {
+        EXPECT_EQ(result, RESOLVE_APP_ERR);
+    } else {
+        EXPECT_EQ(result, ERR_MULTI_INSTANCE_NOT_SUPPORTED);
+    }
+
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0300 end");
+}
+
+/**
+ * @tc.name: AbilityPermissionUtil_CheckMultiInstance_0100
+ * @tc.desc: CheckMultiInstance
+ * @tc.type: FUNC
+ * @tc.require: NA
+ */
+HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstance_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0100 start");
+
+    Want want;
+    auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, nullptr, true, "", 0);
+    EXPECT_EQ(result, ERR_CREATE_NEW_INSTANCE_NOT_SUPPORT);
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0100 end");
+}
+
+/**
+ * @tc.name: AbilityPermissionUtil_CheckMultiInstance_0200
+ * @tc.desc: CheckMultiInstance
+ * @tc.type: FUNC
+ * @tc.require: NA
+ */
+HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstance_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0200 start");
+
+    std::string bundleName = "com.ohos.test";
+    Want want;
+    want.SetBundle(bundleName);
+    OHOS::AppExecFwk::AbilityInfo abilityInfo;
+    abilityInfo.bundleName = bundleName;
+    OHOS::AppExecFwk::ApplicationInfo applicationInfo;
+    auto abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
+    auto isInitial = abilityRecord->Init();
+    EXPECT_TRUE(isInitial);
+    auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, abilityRecord->GetToken(), true, "", 1);
+    EXPECT_EQ(result, ERR_OK);
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0200 end");
+}
+
+/**
+ * @tc.name: AbilityPermissionUtil_CheckMultiInstance_0300
+ * @tc.desc: CheckMultiInstance
+ * @tc.type: FUNC
+ * @tc.require: NA
+ */
+HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstance_0300, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0300 start");
+
+    std::string bundleName = "com.ohos.test";
+    Want want;
+    want.SetBundle(bundleName);
+    OHOS::AppExecFwk::AbilityInfo abilityInfo;
+    abilityInfo.bundleName = bundleName;
+    OHOS::AppExecFwk::ApplicationInfo applicationInfo;
+    auto abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
+    auto isInitial = abilityRecord->Init();
+    EXPECT_TRUE(isInitial);
+    std::string instanceKey = "app_instance_0";
+    auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, abilityRecord->GetToken(), true,
+        instanceKey, 1);
+    EXPECT_EQ(result, ERR_APP_INSTANCE_KEY_NOT_SUPPORT);
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0300 end");
+}
+
+/**
+ * @tc.name: AbilityPermissionUtil_CheckMultiInstance_0400
+ * @tc.desc: CheckMultiInstance
+ * @tc.type: FUNC
+ * @tc.require: NA
+ */
+HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstance_0400, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0400 start");
+
+    std::string bundleName = "com.ohos.test";
+    Want want;
+    want.SetBundle(bundleName);
+    OHOS::AppExecFwk::AbilityInfo abilityInfo;
+    abilityInfo.bundleName = bundleName;
+    OHOS::AppExecFwk::ApplicationInfo applicationInfo;
+    auto abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
+    auto isInitial = abilityRecord->Init();
+    EXPECT_TRUE(isInitial);
+    auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, abilityRecord->GetToken(), true, "", 0);
+    EXPECT_EQ(result, ERR_UPPER_LIMIT);
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0400 end");
+}
+
+/**
+ * @tc.name: AbilityPermissionUtil_UpdateInstanceKey_0100
+ * @tc.desc: UpdateInstanceKey
+ * @tc.type: FUNC
+ * @tc.require: NA
+ */
+HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_UpdateInstanceKey_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_UpdateInstanceKey_0100 start");
+
+    Want want;
+    std::vector<std::string> instanceKeyArray;
+    auto result = AbilityPermissionUtil::GetInstance().UpdateInstanceKey(want, "", instanceKeyArray, "");
+    EXPECT_EQ(result, ERR_OK);
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_UpdateInstanceKey_0100 end");
+}
+
+/**
+ * @tc.name: AbilityPermissionUtil_UpdateInstanceKey_0200
+ * @tc.desc: UpdateInstanceKey
+ * @tc.type: FUNC
+ * @tc.require: NA
+ */
+HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_UpdateInstanceKey_0200, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_UpdateInstanceKey_0200 start");
+
+    Want want;
+    std::string originInstanceKey = "app_instance_0";
+    std::vector<std::string> instanceKeyArray;
+    auto result = AbilityPermissionUtil::GetInstance().UpdateInstanceKey(want, originInstanceKey, instanceKeyArray, "");
+    EXPECT_EQ(result, ERR_INVALID_APP_INSTANCE_KEY);
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_UpdateInstanceKey_0200 end");
+}
+
+/**
+ * @tc.name: AbilityPermissionUtil_UpdateInstanceKey_0300
+ * @tc.desc: UpdateInstanceKey
+ * @tc.type: FUNC
+ * @tc.require: NA
+ */
+HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_UpdateInstanceKey_0300, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_UpdateInstanceKey_0300 start");
+
+    Want want;
+    std::string originInstanceKey = "app_instance_0";
+    std::vector<std::string> instanceKeyArray;
+    instanceKeyArray.push_back(originInstanceKey);
+    auto result = AbilityPermissionUtil::GetInstance().UpdateInstanceKey(want, originInstanceKey, instanceKeyArray, "");
+    EXPECT_EQ(result, ERR_OK);
+    TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_UpdateInstanceKey_0300 end");
+}
+}  // namespace AAFwk
+}  // namespace OHOS

test/unittest/ability_record_test/ability_record_test.cpp

@@ -3546,5 +3546,20 @@ HWTEST_F(AbilityRecordTest, AbilityRecord_GetPermissionedUriList_006, TestSize.L
     EXPECT_EQ(paramStramUris.size(), 1);
 }
 
+/*
+ * Feature: AbilityRecord
+ * Function: GetInstanceKey
+ * SubFunction: GetInstanceKey
+ * FunctionPoints: NA
+ * EnvConditions: NA
+ * CaseDescription: Verify AbilityRecord GetInstanceKey
+ */
+HWTEST_F(AbilityRecordTest, AbilityRecord_GetInstanceKey_001, TestSize.Level1)
+{
+    std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
+    auto instanceKey = abilityRecord->GetInstanceKey();
+    EXPECT_EQ(instanceKey, "");
+}
+
 }  // namespace AAFwk
 }  // namespace OHOS

test/unittest/ams_app_running_record_test/ams_app_running_record_test.cpp

@@ -221,8 +221,10 @@ HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_001, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     EXPECT_TRUE(record != nullptr);
     EXPECT_EQ(record->GetName(), GetTestAppName());
@@ -256,13 +258,14 @@ HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_002, TestSize.Level1)
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
     // Create
-    sptr<IRemoteObject> token = GetMockToken();
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     record->SetUid(1010);
     // Get
     auto record1 = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     EXPECT_TRUE(record1 != nullptr);
     EXPECT_EQ(record1->GetName(), GetTestAppName());
     EXPECT_EQ(record1->GetProcessName(), GetTestProcessName());
@@ -291,22 +294,23 @@ HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_003, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     record->SetUid(1010);
 
     auto anotherAbilityInfo = std::make_shared<AbilityInfo>();
     anotherAbilityInfo->name = "Another_ability";
     anotherAbilityInfo->applicationInfo.uid = 1010;
-    sptr<IRemoteObject> anotherToken = new (std::nothrow) MockAbilityToken();
-    auto record1 = service_->CreateAppRunningRecord(GetMockToken(),
-        anotherToken,
+    loadParam->preToken = new (std::nothrow) MockAbilityToken();
+    auto record1 = service_->CreateAppRunningRecord(loadParam,
         appInfo,
         anotherAbilityInfo,
         GetTestProcessName(),
         bundleInfo,
         hapModuleInfo,
-        nullptr, 0);
+        nullptr);
     EXPECT_EQ(record1->GetName(), GetTestAppName());
     EXPECT_EQ(record1->GetProcessName(), GetTestProcessName());
 
@@ -335,8 +339,10 @@ HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_004, TestSize.Level1)
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
     // Create
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, nullptr, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, nullptr, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     EXPECT_TRUE(record == nullptr);
 }
 
@@ -359,8 +365,10 @@ HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_005, TestSize.Level1)
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
     // Create
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, nullptr, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, nullptr, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     EXPECT_TRUE(record != nullptr);
 }
 
@@ -747,8 +755,10 @@ HWTEST_F(AmsAppRunningRecordTest, DeleteAppRunningRecord_001, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     EXPECT_TRUE(record != nullptr);
     record->SetState(ApplicationState::APP_STATE_BACKGROUND);
     record->SetApplicationClient(GetMockedAppSchedulerClient());
@@ -957,8 +967,10 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchAbilityForApp_001, TestSize.Level1)
     hapModuleInfo.moduleName = "module789";
 
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     std::shared_ptr<AppRunningRecord> record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     EXPECT_CALL(*mockAppSchedulerClient_, ScheduleLaunchApplication(_, _)).Times(1);
     EXPECT_CALL(*mockAppSchedulerClient_, ScheduleLaunchAbility(_, _, _, _)).Times(1);
@@ -998,8 +1010,10 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchAbilityForApp_002, TestSize.Level1)
     const int EXPECT_ABILITY_LAUNCH_TIME = 3;
     EXPECT_TRUE(service_ != nullptr);
 
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     std::shared_ptr<AppRunningRecord> record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     sptr<IRemoteObject> token2 = new (std::nothrow) MockAbilityToken();
     record->AddModule(appInfo, abilityInfo2, token2, hapModuleInfo, nullptr, 0);
@@ -1046,8 +1060,10 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchAbilityForApp_003, TestSize.Level1)
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
 
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     std::shared_ptr<AppRunningRecord> record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     record->SetState(ApplicationState::APP_STATE_READY);
     record->SetApplicationClient(GetMockedAppSchedulerClient());
 
@@ -1090,8 +1106,10 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchAbilityForApp_004, TestSize.Level1)
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
 
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     std::shared_ptr<AppRunningRecord> record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     EXPECT_CALL(*mockAppSchedulerClient_, ScheduleLaunchApplication(_, _)).Times(1);
     EXPECT_CALL(*mockAppSchedulerClient_, ScheduleLaunchAbility(_, _, _, _)).Times(1);
@@ -1100,10 +1118,8 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchAbilityForApp_004, TestSize.Level1)
     EXPECT_EQ(record->GetState(), ApplicationState::APP_STATE_READY);
 
     EXPECT_CALL(*mockAppSchedulerClient_, ScheduleLaunchApplication(_, _)).Times(0);
-    AbilityRuntime::LoadParam loadParam;
-    loadParam.token = new (std::nothrow) MockAbilityToken();
-    auto loadParamPtr = std::make_shared<AbilityRuntime::LoadParam>(loadParam);
-    service_->LoadAbility(abilityInfo2, appInfo, nullptr, loadParamPtr);
+    loadParam->token = new (std::nothrow) MockAbilityToken();
+    service_->LoadAbility(abilityInfo2, appInfo, nullptr, loadParam);
     TAG_LOGI(AAFwkTag::TEST, "AmsAppRunningRecordTest LaunchAbilityForApp_004 end");
 }
 
@@ -1137,8 +1153,10 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchAbilityForApp_005, TestSize.Level1)
     const int EXPECT_ABILITY_LAUNCH_TIME = 2;
     EXPECT_TRUE(service_ != nullptr);
 
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     std::shared_ptr<AppRunningRecord> record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     sptr<IRemoteObject> token2 = new (std::nothrow) MockAbilityToken();
     record->AddModule(appInfo, abilityInfo2, token2, hapModuleInfo, nullptr, 0);
@@ -1204,8 +1222,10 @@ HWTEST_F(AmsAppRunningRecordTest, TerminateAbility_002, TestSize.Level1)
     appInfo->name = GetTestAppName();
     appInfo->bundleName = GetTestAppName();
 
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     std::shared_ptr<AppRunningRecord> record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     EXPECT_CALL(*mockAppSchedulerClient_, ScheduleCleanAbility(_, _)).Times(0);
     record->TerminateAbility(GetMockToken(), false);
@@ -1272,8 +1292,10 @@ HWTEST_F(AmsAppRunningRecordTest, SetUid_GetUid_001, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     EXPECT_TRUE(record != nullptr);
     record->SetUid(102);
@@ -1307,8 +1329,10 @@ HWTEST_F(AmsAppRunningRecordTest, OnAbilityStateChanged_001, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
 
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     std::shared_ptr<AppRunningRecord> record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     auto moduleRecord = record->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName);
     EXPECT_TRUE(moduleRecord != nullptr);
     auto abilityRecord = record->GetAbilityRunningRecordByToken(GetMockToken());
@@ -1361,8 +1385,10 @@ HWTEST_F(AmsAppRunningRecordTest, AddModule_001, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo0, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo0, nullptr, 0);
+        loadParam, appInfo0, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo0, nullptr);
     EXPECT_TRUE(record != nullptr);
     auto moduleRecordList = record->GetAllModuleRecord();
     EXPECT_TRUE(moduleRecordList.size() == 1);
@@ -1412,8 +1438,10 @@ HWTEST_F(AmsAppRunningRecordTest, AddModule_002, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     EXPECT_TRUE(record != nullptr);
 
@@ -1456,7 +1484,7 @@ HWTEST_F(AmsAppRunningRecordTest, GetModuleRecordByModuleName_001, TestSize.Leve
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
-    auto record = service_->appRunningManager_->CreateAppRunningRecord(appInfo, GetTestProcessName(), bundleInfo);
+    auto record = service_->appRunningManager_->CreateAppRunningRecord(appInfo, GetTestProcessName(), bundleInfo, "");
     EXPECT_TRUE(record != nullptr);
     EXPECT_TRUE(record->hapModules_.size() == 0);
     auto moduleRecord = record->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName);
@@ -1506,8 +1534,10 @@ HWTEST_F(AmsAppRunningRecordTest, GetAbilities_001, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     EXPECT_TRUE(record != nullptr);
 
@@ -1542,8 +1572,10 @@ HWTEST_F(AmsAppRunningRecordTest, GetAbilities_002, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     EXPECT_TRUE(record != nullptr);
 
@@ -1581,8 +1613,10 @@ HWTEST_F(AmsAppRunningRecordTest, RemoveModuleRecord_001, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     EXPECT_TRUE(record != nullptr);
 
@@ -1786,8 +1820,10 @@ HWTEST_F(AmsAppRunningRecordTest, StartSpecifiedAbility_001, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     EXPECT_TRUE(record != nullptr);
     EXPECT_EQ(record->GetName(), GetTestAppName());
@@ -1818,8 +1854,10 @@ HWTEST_F(AmsAppRunningRecordTest, StartSpecifiedAbility_002, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     EXPECT_TRUE(record != nullptr);
     EXPECT_EQ(record->GetName(), GetTestAppName());
@@ -1857,8 +1895,10 @@ HWTEST_F(AmsAppRunningRecordTest, Specified_LaunchApplication_001, TestSize.Leve
     hapModuleInfo.moduleName = "module789";
 
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     std::shared_ptr<AppRunningRecord> record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     record->SetApplicationClient(GetMockedAppSchedulerClient());
     record->specifiedRequestId_ = 1;
@@ -2258,8 +2298,10 @@ HWTEST_F(AmsAppRunningRecordTest, GetAbilityRunningRecord_002, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
 
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     std::shared_ptr<AppRunningRecord> record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     sptr<IRemoteObject> token = new (std::nothrow) MockAbilityToken();
     record->AddModule(appInfo, abilityInfo, token, hapModuleInfo, nullptr, 0);
@@ -2302,8 +2344,10 @@ HWTEST_F(AmsAppRunningRecordTest, AddAbilityStage_001, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     EXPECT_TRUE(record != nullptr);
 
     record->AddAbilityStage();
@@ -2350,8 +2394,10 @@ HWTEST_F(AmsAppRunningRecordTest, AddAbilityStageBySpecifiedAbility_001, TestSiz
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     EXPECT_TRUE(record != nullptr);
 
     record->AddAbilityStageBySpecifiedAbility(bundleName1);
@@ -2404,8 +2450,10 @@ HWTEST_F(AmsAppRunningRecordTest, AddAbilityStageDone_001, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     EXPECT_TRUE(record != nullptr);
     record->AddAbilityStageDone();
 
@@ -2454,7 +2502,7 @@ HWTEST_F(AmsAppRunningRecordTest, GetModuleRunningRecordByToken_001, TestSize.Le
     hapModuleInfo.moduleName = "module789";
     sptr<IRemoteObject> token = new (std::nothrow) MockAbilityToken();
     EXPECT_TRUE(service_ != nullptr);
-    auto record = service_->appRunningManager_->CreateAppRunningRecord(appInfo, GetTestProcessName(), bundleInfo);
+    auto record = service_->appRunningManager_->CreateAppRunningRecord(appInfo, GetTestProcessName(), bundleInfo, "");
     EXPECT_TRUE(record != nullptr);
     EXPECT_TRUE(record->hapModules_.size() == 0);
 
@@ -2510,7 +2558,7 @@ HWTEST_F(AmsAppRunningRecordTest, GetModuleRunningRecordByTerminateLists_001, Te
     sptr<IRemoteObject> token = new (std::nothrow) MockAbilityToken();
     sptr<IRemoteObject> token1 = new (std::nothrow) MockAbilityToken();
     EXPECT_TRUE(service_ != nullptr);
-    auto record = service_->appRunningManager_->CreateAppRunningRecord(appInfo, GetTestProcessName(), bundleInfo);
+    auto record = service_->appRunningManager_->CreateAppRunningRecord(appInfo, GetTestProcessName(), bundleInfo, "");
     EXPECT_TRUE(record != nullptr);
     EXPECT_TRUE(record->hapModules_.size() == 0);
 
@@ -2559,8 +2607,10 @@ HWTEST_F(AmsAppRunningRecordTest, UpdateAbilityFocusState_001, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     EXPECT_TRUE(record != nullptr);
 
     auto abilityRecord = record->GetAbilityRunningRecordByToken(GetMockToken());
@@ -2763,8 +2813,10 @@ HWTEST_F(AmsAppRunningRecordTest, IsUIExtension_001, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     EXPECT_TRUE(record != nullptr);
     EXPECT_EQ(AAFwk::UIExtensionUtils::IsUIExtension(record->extensionType_), false);
@@ -2799,8 +2851,10 @@ HWTEST_F(AmsAppRunningRecordTest, IsUIExtension_002, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
 
     EXPECT_TRUE(record != nullptr);
     EXPECT_EQ(AAFwk::UIExtensionUtils::IsUIExtension(record->extensionType_), true);

test/unittest/ams_service_load_ability_process_test/ams_service_load_ability_process_test.cpp

@@ -1215,8 +1215,10 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartProcess001, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
 
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token;
     std::shared_ptr<AppRunningRecord> record = service_->CreateAppRunningRecord(
-        token, nullptr, appInfo, abilityInfo, GetTestAppName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestAppName(), bundleInfo, hapModuleInfo, nullptr);
 
     service_->StartProcess(abilityInfo->applicationName,
         GetTestAppName(),
@@ -1265,8 +1267,10 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartProcess002, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
 
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token;
     std::shared_ptr<AppRunningRecord> record = service_->CreateAppRunningRecord(
-        token, nullptr, appInfo, abilityInfo, GetTestAppName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestAppName(), bundleInfo, hapModuleInfo, nullptr);
 
     service_->SetAppSpawnClient(nullptr);
     service_->StartProcess(abilityInfo->applicationName,
@@ -1310,8 +1314,10 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartProcess003, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
 
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token;
     std::shared_ptr<AppRunningRecord> record = service_->CreateAppRunningRecord(
-        token, nullptr, appInfo, abilityInfo, GetTestAppName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestAppName(), bundleInfo, hapModuleInfo, nullptr);
 
     service_->StartProcess(abilityInfo->applicationName,
         GetTestAppName(),
@@ -1361,8 +1367,10 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartProcess004, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
 
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token;
     std::shared_ptr<AppRunningRecord> record = service_->CreateAppRunningRecord(
-        token, nullptr, appInfo, abilityInfo, GetTestAppName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestAppName(), bundleInfo, hapModuleInfo, nullptr);
 
     EXPECT_NE(record, nullptr);
     CHECK_POINTER_IS_NULLPTR(record);

test/unittest/app_mgr_service_inner_second_test/app_mgr_service_inner_second_test.cpp

@@ -28,6 +28,7 @@
 #include "mock_native_token.h"
 #include "mock_permission_verification.h"
 #include "mock_sa_call.h"
+#include "param.h"
 
 using namespace testing;
 using namespace testing::ext;
@@ -185,8 +186,11 @@ HWTEST_F(AppMgrServiceInnerSecondTest, AppMgrServiceInnerSecondTest_LoadAbilityN
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.isStageBasedModel = true;
     hapModuleInfo.process = "testMainProcess";
-    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(token_, preToken_, applicationInfo_, abilityInfo_,
-        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, 1, false);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token_;
+    loadParam->preToken = preToken_;
+    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam, applicationInfo_, abilityInfo_,
+        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, false);
     ASSERT_NE(appRecord, nullptr);
     appRecord->SetEmptyKeepAliveAppState(true);
     appRecord->SetMainProcess(true);
@@ -212,8 +216,11 @@ HWTEST_F(AppMgrServiceInnerSecondTest, AppMgrServiceInnerSecondTest_LoadAbilityN
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.isStageBasedModel = true;
     hapModuleInfo.process = TEST_PROCESS_NAME;
-    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(token_, preToken_, applicationInfo_, abilityInfo_,
-        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, 1, false);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token_;
+    loadParam->preToken = preToken_;
+    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam, applicationInfo_, abilityInfo_,
+        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, false);
     ASSERT_NE(appRecord, nullptr);
     appRecord->SetEmptyKeepAliveAppState(true);
 
@@ -250,8 +257,11 @@ HWTEST_F(AppMgrServiceInnerSecondTest, AppMgrServiceInnerSecondTest_ForceKillApp
     auto appMgrServiceInner = std::make_shared<AppMgrServiceInner>();
     const BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
-    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(token_, preToken_, applicationInfo_, abilityInfo_,
-        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, 1, false);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token_;
+    loadParam->preToken = preToken_;
+    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam, applicationInfo_, abilityInfo_,
+        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, false);
     appRecord->GetPriorityObject()->SetPid(1); // kill Init process
     auto ret = appMgrServiceInner->ForceKillApplicationInner(TEST_BUNDLE_NAME, DEFAULT_INVAL_VALUE, appIndex);
     EXPECT_EQ(ret, ERR_OK);
@@ -270,8 +280,11 @@ HWTEST_F(AppMgrServiceInnerSecondTest, AppMgrServiceInnerSecondTest_ForceKillApp
     auto appMgrServiceInner = std::make_shared<AppMgrServiceInner>();
     const BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
-    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(token_, preToken_, applicationInfo_, abilityInfo_,
-        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, 1, false);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token_;
+    loadParam->preToken = preToken_;
+    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam, applicationInfo_, abilityInfo_,
+        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, false);
     appRecord->GetPriorityObject()->SetPid(INT_MAX);
 
     // kill not exist pid, expect ERR_KILL_PROCESS_NOT_EXIST
@@ -326,8 +339,11 @@ HWTEST_F(AppMgrServiceInnerSecondTest, AppMgrServiceInnerSecondTest_KillProcesse
     HapModuleInfo hapModuleInfo;
     const int32_t accessTokenId = 123; // 123 means tokenid
     applicationInfo_->accessTokenId = accessTokenId;
-    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(token_, preToken_, applicationInfo_, abilityInfo_,
-        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, 1, false);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token_;
+    loadParam->preToken = preToken_;
+    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam, applicationInfo_, abilityInfo_,
+        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, false);
     appRecord->SetSpawned();
     appRecord->GetPriorityObject()->SetPid(INT_MAX);
     auto ret = appMgrServiceInner->KillProcessesByAccessTokenId(accessTokenId);
@@ -351,8 +367,11 @@ HWTEST_F(AppMgrServiceInnerSecondTest, AppMgrServiceInnerSecondTest_KillProcesse
     HapModuleInfo hapModuleInfo;
     const int32_t accessTokenId = 123;
     applicationInfo_->accessTokenId = accessTokenId;
-    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(token_, preToken_, applicationInfo_, abilityInfo_,
-        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, 1, false);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token_;
+    loadParam->preToken = preToken_;
+    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam, applicationInfo_, abilityInfo_,
+        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, false);
     appRecord->SetSpawned();
     appRecord->GetPriorityObject()->SetPid(1);
     auto ret = appMgrServiceInner->KillProcessesByAccessTokenId(accessTokenId);
@@ -405,8 +424,11 @@ HWTEST_F(AppMgrServiceInnerSecondTest, AppMgrServiceInnerSecondTest_GetAllChildr
     auto appMgrServiceInner = std::make_shared<AppMgrServiceInner>();
     BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
-    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(token_, preToken_, applicationInfo_, abilityInfo_,
-        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, 1, false);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token_;
+    loadParam->preToken = preToken_;
+    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam, applicationInfo_, abilityInfo_,
+        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, false);
     ChildProcessRequest request;
     auto record1 = std::make_shared<ChildProcessRecord>(IPCSkeleton::GetCallingPid(), request, appRecord);
     appRecord->AddChildProcessRecord(1, record1);
@@ -432,8 +454,11 @@ HWTEST_F(AppMgrServiceInnerSecondTest, AppMgrServiceInnerSecondTest_GetAllChildr
     HapModuleInfo hapModuleInfo;
     const int32_t accessTokenId = 123; // 123 means tokenid
     applicationInfo_->accessTokenId = accessTokenId;
-    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(token_, preToken_, applicationInfo_, abilityInfo_,
-        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, 1, false);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token_;
+    loadParam->preToken = preToken_;
+    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam, applicationInfo_, abilityInfo_,
+        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, false);
     ChildProcessRequest request;
     auto record1 = std::make_shared<ChildProcessRecord>(IPCSkeleton::GetCallingPid(), request, appRecord);
     appRecord->AddChildProcessRecord(1, record1);
@@ -507,8 +532,11 @@ HWTEST_F(AppMgrServiceInnerSecondTest, AppMgrServiceInnerSecondTest_NotifyAppFau
     auto appMgrServiceInner = std::make_shared<AppMgrServiceInner>();
     BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
-    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(token_, preToken_, applicationInfo_, abilityInfo_,
-        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, 1, false);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token_;
+    loadParam->preToken = preToken_;
+    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam, applicationInfo_, abilityInfo_,
+        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, false);
     appRecord->GetPriorityObject()->SetPid(1);
     appRecord->SetState(ApplicationState::APP_STATE_TERMINATED);
 
@@ -544,8 +572,11 @@ HWTEST_F(AppMgrServiceInnerSecondTest, AppMgrServiceInnerSecondTest_BuildEventIn
 
     BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
-    appRecord = appMgrServiceInner->CreateAppRunningRecord(token_, preToken_, applicationInfo_, abilityInfo_,
-        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, 1, false);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token_;
+    loadParam->preToken = preToken_;
+    appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam, applicationInfo_, abilityInfo_,
+        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, false);
 
     AAFwk::EventInfo eventInfo {.bundleName = applicationInfo_->name,
         .versionName = applicationInfo_->versionName,
@@ -575,8 +606,11 @@ HWTEST_F(AppMgrServiceInnerSecondTest, AppMgrServiceInnerSecondTest_UpdateRender
 
     BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
-    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(token_, preToken_, applicationInfo_, abilityInfo_,
-        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, 1, false);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token_;
+    loadParam->preToken = preToken_;
+    auto appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam, applicationInfo_, abilityInfo_,
+        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, false);
     appRecord->GetPriorityObject()->SetPid(1);
     ret = appMgrServiceInner->UpdateRenderState(INT_MAX, 0);
     EXPECT_EQ(ret, ERR_INVALID_VALUE);
@@ -609,8 +643,11 @@ HWTEST_F(AppMgrServiceInnerSecondTest, AppMgrServiceInnerSecondTest_NotifyMemMgr
     BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
     std::shared_ptr<AppRunningRecord> appRecord = nullptr;
-    appRecord = appMgrServiceInner->CreateAppRunningRecord(token_, preToken_, applicationInfo_, abilityInfo_,
-        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, 1, false);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token_;
+    loadParam->preToken = preToken_;
+    appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam, applicationInfo_, abilityInfo_,
+        TEST_PROCESS_NAME, bundleInfo, hapModuleInfo, want_, false);
 
     ret = appMgrServiceInner->NotifyMemMgrPriorityChanged(appRecord);
     EXPECT_FALSE(ret); // stub err

test/unittest/app_mgr_service_inner_tdd_test/app_mgr_service_inner_tdd_test.cpp

@@ -129,7 +129,7 @@ HWTEST_F(AppMgrServiceInnerTest, SendProcessStartEvent_002, TestSize.Level1)
     std::string processName = "test_processName";
     sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     EXPECT_TRUE(appMgrServiceInner->SendProcessStartEvent(appRecord));
     TAG_LOGI(AAFwkTag::TEST, "SendProcessStartEvent_002 end");
@@ -151,7 +151,7 @@ HWTEST_F(AppMgrServiceInnerTest, SendProcessStartEvent_003, TestSize.Level1)
     std::string processName = "test_processName";
     sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
     std::shared_ptr<ModuleRunningRecord> moduleRunningRecord = std::make_shared<ModuleRunningRecord>(appInfo, nullptr);
@@ -179,7 +179,7 @@ HWTEST_F(AppMgrServiceInnerTest, SendProcessStartEvent_004, TestSize.Level1)
     std::string processName = "test_processName";
     sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
     std::shared_ptr<ModuleRunningRecord> moduleRunningRecord = std::make_shared<ModuleRunningRecord>(appInfo, nullptr);
@@ -210,7 +210,7 @@ HWTEST_F(AppMgrServiceInnerTest, SendProcessStartEvent_005, TestSize.Level1)
     std::string processName = "test_processName";
     sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
     std::shared_ptr<ModuleRunningRecord> moduleRunningRecord = std::make_shared<ModuleRunningRecord>(appInfo, nullptr);
@@ -242,7 +242,7 @@ HWTEST_F(AppMgrServiceInnerTest, SendProcessStartEvent_006, TestSize.Level1)
     std::string processName = "test_processName";
     sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
     std::shared_ptr<ModuleRunningRecord> moduleRunningRecord = std::make_shared<ModuleRunningRecord>(appInfo, nullptr);
@@ -275,7 +275,7 @@ HWTEST_F(AppMgrServiceInnerTest, SendProcessStartEvent_007, TestSize.Level1)
     std::string processName = "test_processName";
     sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
     std::shared_ptr<ModuleRunningRecord> moduleRunningRecord = std::make_shared<ModuleRunningRecord>(appInfo, nullptr);
@@ -319,7 +319,7 @@ HWTEST_F(AppMgrServiceInnerTest, SendProcessStartEvent_008, TestSize.Level1)
     sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
     applicationInfo_->bundleName = "";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
     std::shared_ptr<ModuleRunningRecord> moduleRunningRecord = std::make_shared<ModuleRunningRecord>(appInfo, nullptr);
@@ -378,7 +378,7 @@ HWTEST_F(AppMgrServiceInnerTest, SendProcessStartFailedEvent_002, TestSize.Level
     BundleInfo bundleInfo;
     std::string processName = "test_processName";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_TRUE(
         appMgrServiceInner->SendProcessStartFailedEvent(appRecord, ProcessStartFailedReason::APPSPAWN_FAILED, 0));
     TAG_LOGI(AAFwkTag::TEST, "SendProcessStartFailedEvent_002 end");
@@ -401,7 +401,7 @@ HWTEST_F(AppMgrServiceInnerTest, SendProcessStartFailedEvent_003, TestSize.Level
     sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
     applicationInfo_->bundleName = "testBundleName";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
     std::shared_ptr<ModuleRunningRecord> moduleRunningRecord = std::make_shared<ModuleRunningRecord>(appInfo, nullptr);
@@ -530,7 +530,7 @@ HWTEST_F(AppMgrServiceInnerTest, StartRenderProcessImpl_001, TestSize.Level0)
     std::string bundleName = "test_bundleName";
     sptr<IRemoteObject> token = new MockAbilityToken();
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     pid_t hostPid = 1;
     std::string renderParam = "test_render_param";

test/unittest/app_mgr_service_inner_test/app_mgr_service_inner_test.cpp

@@ -583,7 +583,7 @@ HWTEST_F(AppMgrServiceInnerTest, LaunchApplication_001, TestSize.Level0)
     BundleInfo info;
     std::string processName = "test_processName";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     recordId_ += 1;
     appMgrServiceInner->LaunchApplication(appRecord);
 
@@ -637,7 +637,7 @@ HWTEST_F(AppMgrServiceInnerTest, AddAbilityStageDone_001, TestSize.Level0)
 
     BundleInfo info;
     std::string processName = "test_processName";
-    appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+    appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     recordId_ += 1;
 
     appMgrServiceInner->AddAbilityStageDone(recordId_);
@@ -660,7 +660,7 @@ HWTEST_F(AppMgrServiceInnerTest, ApplicationForegrounded_001, TestSize.Level0)
 
     BundleInfo info;
     std::string processName = "test_processName";
-    appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+    appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     recordId_ += 1;
 
     appMgrServiceInner->ApplicationForegrounded(recordId_);
@@ -681,7 +681,8 @@ HWTEST_F(AppMgrServiceInnerTest, ApplicationForegrounded_002, TestSize.Level0)
 
     BundleInfo info;
     std::string processName = "test_processName";
-    auto record = appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+    auto record =
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     recordId_ += 1;
 
     appMgrServiceInner->ApplicationForegrounded(recordId_);
@@ -702,9 +703,11 @@ HWTEST_F(AppMgrServiceInnerTest, ApplicationForegrounded_003, TestSize.Level0)
 
     BundleInfo info;
     std::string processName = "test_processName";
-    auto record = appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+    auto record =
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     recordId_ += 1;
-    auto record2 = appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+    auto record2 =
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     recordId_ += 1;
     std::shared_ptr<PriorityObject> priorityObject = std::make_shared<PriorityObject>();
     std::string callerBundleName = "callerBundleName";
@@ -735,7 +738,7 @@ HWTEST_F(AppMgrServiceInnerTest, ApplicationBackgrounded_001, TestSize.Level0)
     BundleInfo info;
     std::string processName = "test_processName";
     auto appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     EXPECT_NE(appRecord, nullptr);
     recordId_ += 1;
 
@@ -764,7 +767,7 @@ HWTEST_F(AppMgrServiceInnerTest, ApplicationTerminated_001, TestSize.Level0)
     BundleInfo info;
     std::string processName = "test_processName";
     auto appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     EXPECT_NE(appRecord, nullptr);
     recordId_ += 1;
 
@@ -1146,7 +1149,6 @@ HWTEST_F(AppMgrServiceInnerTest, ProcessExist_001, TestSize.Level0)
 HWTEST_F(AppMgrServiceInnerTest, CreateAppRunningRecord_001, TestSize.Level0)
 {
     TAG_LOGI(AAFwkTag::TEST, "CreateAppRunningRecord_001 start");
-    OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
     auto appMgrServiceInner = std::make_shared<AppMgrServiceInner>();
     EXPECT_NE(appMgrServiceInner, nullptr);
 
@@ -1155,63 +1157,65 @@ HWTEST_F(AppMgrServiceInnerTest, CreateAppRunningRecord_001, TestSize.Level0)
     std::shared_ptr<AAFwk::Want> want;
     std::string processName = "test_processName";
 
-    std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner->CreateAppRunningRecord(nullptr, nullptr,
-        nullptr, nullptr, "", bundleInfo, hapModuleInfo, nullptr, 0);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        nullptr, nullptr, "", bundleInfo, hapModuleInfo, nullptr);
     EXPECT_EQ(appRecord, nullptr);
 
-    appRecord = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        nullptr, nullptr, "", bundleInfo, hapModuleInfo, nullptr, 0);
+    loadParam->token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
+    appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        nullptr, nullptr, "", bundleInfo, hapModuleInfo, nullptr);
     EXPECT_EQ(appRecord, nullptr);
 
-    appRecord = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, nullptr, "", bundleInfo, hapModuleInfo, nullptr, 0);
+    appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, nullptr, "", bundleInfo, hapModuleInfo, nullptr);
     EXPECT_EQ(appRecord, nullptr);
 
-    appRecord = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, "", bundleInfo, hapModuleInfo, nullptr, 0);
+    appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, "", bundleInfo, hapModuleInfo, nullptr);
     EXPECT_EQ(appRecord, nullptr);
 
-    appRecord = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, nullptr, 0);
+    appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, nullptr);
     EXPECT_NE(appRecord, nullptr);
 
-    appRecord = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, nullptr, 0);
+    appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, nullptr);
     EXPECT_NE(appRecord, nullptr);
 
-    appRecord = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, nullptr, 0);
+    appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, nullptr);
     EXPECT_NE(appRecord, nullptr);
 
-    std::shared_ptr<AppRunningRecord> appRecord1 = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        nullptr, abilityInfo_, processName, bundleInfo, hapModuleInfo, want, 0);
+    std::shared_ptr<AppRunningRecord> appRecord1 = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        nullptr, abilityInfo_, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_EQ(appRecord1, nullptr);
 
-    std::shared_ptr<AppRunningRecord> appRecord2 = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want, 0);
+    std::shared_ptr<AppRunningRecord> appRecord2 = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_NE(appRecord2, nullptr);
 
     want = std::make_shared<Want>();
     const std::string COLD_START = "coldStart";
     want->SetParam(COLD_START, true);
-    std::shared_ptr<AppRunningRecord> appRecord3 = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want, 0);
+    std::shared_ptr<AppRunningRecord> appRecord3 = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_NE(appRecord3, nullptr);
 
     want->SetParam(COLD_START, false);
-    std::shared_ptr<AppRunningRecord> appRecord4 = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want, 0);
+    std::shared_ptr<AppRunningRecord> appRecord4 = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_NE(appRecord4, nullptr);
 
     appMgrServiceInner->appRunningManager_ = nullptr;
-    std::shared_ptr<AppRunningRecord> appRecord5 = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want, 0);
+    std::shared_ptr<AppRunningRecord> appRecord5 = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_EQ(appRecord5, nullptr);
 
     appMgrServiceInner->appRunningManager_ = nullptr;
     want->SetParam("multiThread", false);
-    std::shared_ptr<AppRunningRecord> appRecord6 = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want, 0);
+    std::shared_ptr<AppRunningRecord> appRecord6 = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_EQ(appRecord6, nullptr);
 
     TAG_LOGI(AAFwkTag::TEST, "CreateAppRunningRecord_001 end");
@@ -1263,14 +1267,17 @@ HWTEST_F(AppMgrServiceInnerTest, UpdateAbilityState_001, TestSize.Level0)
     HapModuleInfo hapModuleInfo;
     std::shared_ptr<AAFwk::Want> want;
     std::string processName = "test_processName";
-    std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, nullptr, processName, bundleInfo, hapModuleInfo, want, 0);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token;
+    std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, nullptr, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_NE(appRecord, nullptr);
     appMgrServiceInner->UpdateAbilityState(token, AbilityState::ABILITY_STATE_CREATE);
 
     OHOS::sptr<IRemoteObject> token1 = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
-    std::shared_ptr<AppRunningRecord> appRecord1 = appMgrServiceInner->CreateAppRunningRecord(token1, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want, 0);
+    loadParam->token = token1;
+    std::shared_ptr<AppRunningRecord> appRecord1 = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_NE(appRecord1, nullptr);
 
     appMgrServiceInner->UpdateAbilityState(token1, AbilityState::ABILITY_STATE_READY);
@@ -1295,8 +1302,9 @@ HWTEST_F(AppMgrServiceInnerTest, UpdateAbilityState_001, TestSize.Level0)
 
     OHOS::sptr<IRemoteObject> token2 = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
     abilityInfo_->type = AbilityType::SERVICE;
-    std::shared_ptr<AppRunningRecord> appRecord2 = appMgrServiceInner->CreateAppRunningRecord(token2, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want, 0);
+    loadParam->token = token2;
+    std::shared_ptr<AppRunningRecord> appRecord2 = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_NE(appRecord2, nullptr);
     appMgrServiceInner->UpdateAbilityState(token2, AbilityState::ABILITY_STATE_CREATE);
 
@@ -1341,8 +1349,10 @@ HWTEST_F(AppMgrServiceInnerTest, UpdateExtensionState_001, TestSize.Level0)
     HapModuleInfo hapModuleInfo;
     std::shared_ptr<AAFwk::Want> want;
     std::string processName = "test_processName";
-    std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want, 0);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token;
+    std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_NE(appRecord, nullptr);
     appMgrServiceInner->UpdateExtensionState(token, ExtensionState::EXTENSION_STATE_CREATE);
 
@@ -1502,8 +1512,10 @@ HWTEST_F(AppMgrServiceInnerTest, KillProcessByAbilityToken_001, TestSize.Level0)
     HapModuleInfo hapModuleInfo;
     std::shared_ptr<AAFwk::Want> want;
     std::string processName = "test_processName";
-    std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want, 0);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token;
+    std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_NE(appRecord, nullptr);
     appMgrServiceInner->KillProcessByAbilityToken(token);
 
@@ -1561,8 +1573,10 @@ HWTEST_F(AppMgrServiceInnerTest, StartAbility_001, TestSize.Level0)
 
     BundleInfo bundleInfo;
     std::string processName = "test_processName";
-    appRecord = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want, 0);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token;
+    appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_NE(appRecord, nullptr);
     appMgrServiceInner->StartAbility(token, nullptr, abilityInfo_, appRecord, hapModuleInfo, want, 0);
     appMgrServiceInner->StartAbility(token, preToken, abilityInfo_, appRecord, hapModuleInfo, want, 0);
@@ -1616,8 +1630,10 @@ HWTEST_F(AppMgrServiceInnerTest, AbilityTerminated_001, TestSize.Level0)
     HapModuleInfo hapModuleInfo;
     std::shared_ptr<AAFwk::Want> want;
     std::string processName = "test_processName";
-    std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want, 0);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token;
+    std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_NE(appRecord, nullptr);
     appMgrServiceInner->AbilityTerminated(token);
 
@@ -1662,7 +1678,7 @@ HWTEST_F(AppMgrServiceInnerTest, OnAppStateChanged_001, TestSize.Level0)
     BundleInfo bundleInfo;
     std::string processName = "test_processName";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     appMgrServiceInner->OnAppStateChanged(appRecord, ApplicationState::APP_STATE_CREATE, true, false);
 
@@ -1729,7 +1745,7 @@ HWTEST_F(AppMgrServiceInnerTest, StartProcess_001, TestSize.Level0)
     std::string bundleName = "test_bundleName";
     sptr<IRemoteObject> token = new MockAbilityToken();
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     appMgrServiceInner->StartProcess(appName, processName, 0, nullptr, 0, bundleInfo, bundleName, 0);
     appMgrServiceInner->StartProcess(appName, processName, 0, appRecord, 0, bundleInfo, bundleName, 0);
@@ -1784,7 +1800,7 @@ HWTEST_F(AppMgrServiceInnerTest, ClearAppRunningData_002, TestSize.Level0)
     BundleInfo info;
     std::string processName = "test_processName";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     appMgrServiceInner->ClearAppRunningData(appRecord, true);
     TAG_LOGI(AAFwkTag::TEST, "ClearAppRunningData_002 end");
 }
@@ -1802,7 +1818,7 @@ HWTEST_F(AppMgrServiceInnerTest, ClearAppRunningData_003, TestSize.Level0)
     BundleInfo info;
     std::string processName = "test_processName";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     appMgrServiceInner->ClearAppRunningData(appRecord, false);
     TAG_LOGI(AAFwkTag::TEST, "ClearAppRunningData_003 end");
 }
@@ -1903,7 +1919,7 @@ HWTEST_F(AppMgrServiceInnerTest, HandleTerminateApplicationTimeOut_001, TestSize
     std::string bundleName = "test_bundleName";
     sptr<IRemoteObject> token = new MockAbilityToken();
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     appRecord->eventId_ = 0;
     appMgrServiceInner->HandleTerminateApplicationTimeOut(0);
@@ -1941,7 +1957,7 @@ HWTEST_F(AppMgrServiceInnerTest, HandleAddAbilityStageTimeOut_001, TestSize.Leve
     std::string bundleName = "test_bundleName";
     sptr<IRemoteObject> token = new MockAbilityToken();
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     appRecord->eventId_ = 0;
     appMgrServiceInner->HandleAddAbilityStageTimeOut(0);
@@ -2168,7 +2184,7 @@ HWTEST_F(AppMgrServiceInnerTest, RestartResidentProcess_001, TestSize.Level0)
     BundleInfo bundleInfo;
     std::string processName = "test_processName";
     appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     appRecord->mainBundleName_ = "com.ohos.settings";
     appMgrServiceInner->RestartResidentProcess(appRecord);
@@ -2415,10 +2431,11 @@ HWTEST_F(AppMgrServiceInnerTest, FinishUserTest_001, TestSize.Level0)
     BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
     std::shared_ptr<AAFwk::Want> want;
-    sptr<IRemoteObject> token = new MockAbilityToken();
     std::string processName = "test_processName";
-    std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want, 0);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = new MockAbilityToken();
+    std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_NE(appRecord, nullptr);
     pid = appRecord->GetPriorityObject()->GetPid();
     appMgrServiceInner->FinishUserTest(msg, 0, bundleName, pid);
@@ -2457,7 +2474,7 @@ HWTEST_F(AppMgrServiceInnerTest, FinishUserTestLocked_001, TestSize.Level0)
     BundleInfo bundleInfo;
     std::string processName = "test_processName";
     appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     std::shared_ptr<UserTestRecord> record = std::make_shared<UserTestRecord>();
     appRecord->SetUserTestInfo(record);
@@ -2543,7 +2560,7 @@ HWTEST_F(AppMgrServiceInnerTest, ScheduleAcceptWantDone_001, TestSize.Level0)
     BundleInfo bundleInfo;
     std::string processName = "test_processName";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     appMgrServiceInner->ScheduleAcceptWantDone(appRecord->GetRecordId(), want, flag);
 
     sptr<IStartSpecifiedAbilityResponse> response;
@@ -2573,7 +2590,7 @@ HWTEST_F(AppMgrServiceInnerTest, HandleStartSpecifiedAbilityTimeOut_001, TestSiz
     std::string bundleName = "test_bundleName";
     sptr<IRemoteObject> token = new MockAbilityToken();
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     appRecord->eventId_ = 0;
     appMgrServiceInner->HandleStartSpecifiedAbilityTimeOut(0);
@@ -2719,7 +2736,7 @@ HWTEST_F(AppMgrServiceInnerTest, KillApplicationByRecord_001, TestSize.Level0)
     BundleInfo bundleInfo;
     std::string processName = "test_processName";
     std::shared_ptr<AppRunningRecord> appRecord1 =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord1, nullptr);
     appMgrServiceInner->KillApplicationByRecord(appRecord);
     appMgrServiceInner->KillApplicationByRecord(appRecord1);
@@ -2748,7 +2765,7 @@ HWTEST_F(AppMgrServiceInnerTest, SendHiSysEvent_001, TestSize.Level0)
     BundleInfo bundleInfo;
     std::string processName = "test_processName";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     appRecord->eventId_ = 0;
     appMgrServiceInner->SendHiSysEvent(0, 0);
@@ -2781,7 +2798,7 @@ HWTEST_F(AppMgrServiceInnerTest, GetAbilityRecordsByProcessID_001, TestSize.Leve
     BundleInfo bundleInfo;
     std::string processName = "test_processName";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     int pid = appRecord->GetPriorityObject()->GetPid();
     appMgrServiceInner->GetAbilityRecordsByProcessID(pid, tokens);
@@ -2808,7 +2825,7 @@ HWTEST_F(AppMgrServiceInnerTest, GetApplicationInfoByProcessID_001, TestSize.Lev
     BundleInfo bundleInfo;
     std::string processName = "test_processName";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     int pid = appRecord->GetPriorityObject()->GetPid();
     appMgrServiceInner->GetApplicationInfoByProcessID(pid, application, debug);
@@ -3122,7 +3139,7 @@ HWTEST_F(AppMgrServiceInnerTest, HandleFocused_001, TestSize.Level0)
     BundleInfo bundleInfo;
     std::string processName = "test_processName";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     appRecord->GetPriorityObject()->SetPid(pid);
     appMgrServiceInner->HandleFocused(focusChangeInfo);
@@ -3155,7 +3172,7 @@ HWTEST_F(AppMgrServiceInnerTest, HandleUnfocused_001, TestSize.Level0)
     BundleInfo bundleInfo;
     std::string processName = "test_processName";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     appRecord->GetPriorityObject()->SetPid(pid);
     appMgrServiceInner->HandleUnfocused(focusChangeInfo);
@@ -3247,7 +3264,7 @@ HWTEST_F(AppMgrServiceInnerTest, SetContinuousTaskProcess_001, TestSize.Level0)
     BundleInfo bundleInfo;
     std::string processName = "test_processName";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     appRecord->GetPriorityObject()->SetPid(0);
     ret = appMgrServiceInner->SetContinuousTaskProcess(0, true);
@@ -3383,7 +3400,7 @@ HWTEST_F(AppMgrServiceInnerTest, GetBundleNameByPid_002, TestSize.Level1)
     EXPECT_NE(appMgrServiceInner, nullptr);
     BundleInfo info;
     std::string processName = "test_processName";
-    appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+    appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     int32_t pid = 0;
     std::string name = "test_name";
     int32_t uid = 0;
@@ -3729,7 +3746,8 @@ HWTEST_F(AppMgrServiceInnerTest, SendReStartProcessEvent_002, TestSize.Level1)
     AAFwk::EventInfo eventInfo;
     BundleInfo info;
     std::string processName = "test_processName";
-    auto record = appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+    auto record =
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     recordId_ += 1;
     int64_t restartTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::
         system_clock::now().time_since_epoch()).count();
@@ -3754,7 +3772,8 @@ HWTEST_F(AppMgrServiceInnerTest, SendReStartProcessEvent_003, TestSize.Level1)
     eventInfo.callerBundleName = "callerBundleName";
     BundleInfo info;
     std::string processName = "test_processName";
-    auto record = appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+    auto record =
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     recordId_ += 1;
     int64_t restartTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::
         system_clock::now().time_since_epoch()).count();
@@ -3780,7 +3799,8 @@ HWTEST_F(AppMgrServiceInnerTest, SendReStartProcessEvent_004, TestSize.Level1)
     eventInfo.bundleName = "bundleName";
     eventInfo.callerBundleName = "bundleName";
     eventInfo.callerProcessName = processName;
-    auto record = appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+    auto record =
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     recordId_ += 1;
     int64_t restartTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::
         system_clock::now().time_since_epoch()).count();
@@ -3806,7 +3826,8 @@ HWTEST_F(AppMgrServiceInnerTest, SendReStartProcessEvent_005, TestSize.Level1)
     eventInfo.bundleName = "bundleName";
     eventInfo.callerBundleName = "bundleName";
     eventInfo.callerProcessName = "processName";
-    auto record = appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+    auto record =
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     recordId_ += 1;
     int64_t restartTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::
         system_clock::now().time_since_epoch()).count();
@@ -3832,10 +3853,10 @@ HWTEST_F(AppMgrServiceInnerTest, SendAppLaunchEvent_001, TestSize.Level0)
     BundleInfo info;
     std::string processName = "test_processName";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     recordId_ += 1;
     std::shared_ptr<AppRunningRecord> appRecord2 =
-        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     recordId_ += 1;
     appRecord->SetState(ApplicationState::APP_STATE_CREATE);
     appRecord->SetKeepAliveEnableState(false);
@@ -4389,8 +4410,10 @@ HWTEST_F(AppMgrServiceInnerTest, AttachedToStatusBar_001, TestSize.Level1)
     HapModuleInfo hapModuleInfo;
     std::shared_ptr<AAFwk::Want> want;
     std::string processName = "test_processName";
-    std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner->CreateAppRunningRecord(token, nullptr,
-        applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want, 0);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = token;
+    std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner->CreateAppRunningRecord(loadParam,
+    applicationInfo_, abilityInfo_, processName, bundleInfo, hapModuleInfo, want);
     EXPECT_NE(appRecord, nullptr);
     appMgrServiceInner->AttachedToStatusBar(token);
 }
@@ -4407,7 +4430,8 @@ HWTEST_F(AppMgrServiceInnerTest, BlockProcessCacheByPids_001, TestSize.Level1)
 
     BundleInfo info;
     std::string processName = "test_processName";
-    auto record = appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info);
+    auto record =
+        appMgrServiceInner->appRunningManager_->CreateAppRunningRecord(applicationInfo_, processName, info, "");
     std::shared_ptr<PriorityObject> priorityObject = std::make_shared<PriorityObject>();
     EXPECT_NE(priorityObject, nullptr);
     std::string callerBundleName = "callerBundleName";

test/unittest/app_mgr_service_test/app_mgr_service_test.cpp

@@ -1736,7 +1736,7 @@ HWTEST_F(AppMgrServiceTest, SetSupportedProcessCacheSelf_002, TestSize.Level0)
     applicationInfo_->name = "hiservcie";
     applicationInfo_->bundleName = "com.ix.hiservcie";
     std::shared_ptr<AppRunningRecord> appRecord =
-        appRunningMgr->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo);
+        appRunningMgr->CreateAppRunningRecord(applicationInfo_, processName, bundleInfo, "");
     EXPECT_NE(appRecord, nullptr);
     appRecord->SetCallerTokenId(IPCSkeleton::GetCallingTokenID());
     appRecord->SetCallerUid(IPCSkeleton::GetCallingUid());

test/unittest/app_running_manager_second_test/app_running_manager_second_test.cpp

@@ -108,7 +108,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_CheckAppRunningRecordIsE
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_CheckAppRunningRecordIsExistByUid_0100 start 2");
     /**
      * @tc.steps: step2. SetUid USR_ID_100, SetRestartAppFlag false
@@ -164,7 +164,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_CheckAppCloneRunningReco
     appInfo_->bundleName = BUNDLE_NAME;
     const std::string processName = "testProcessName";
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     ASSERT_NE(record, nullptr);
 
     /**
@@ -234,7 +234,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_ProcessExitByBundleName_
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     std::shared_ptr<AppRunningRecord> record1 =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     ASSERT_NE(record1, nullptr);
     record1->appInfos_.emplace(BUNDLE_NAME, appInfo_);
 
@@ -280,7 +280,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_ProcessExitByBundleName_
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record1 =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     ASSERT_NE(record1, nullptr);
     record1->appInfos_.emplace(BUNDLE_NAME, appInfo_);
 
@@ -325,7 +325,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_GetPidsByBundleNameUserI
     appInfo_->appIndex = 0;
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record1 =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     ASSERT_NE(record1, nullptr);
     record1->appInfos_.emplace(BUNDLE_NAME, appInfo_);
 
@@ -394,7 +394,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_OnRemoteDied_0100, TestS
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     ASSERT_NE(record, nullptr);
     std::shared_ptr<MockAppMgrServiceInner> appServiceInner = std::make_shared<MockAppMgrServiceInner>();
     sptr<MockApplication> mockApp1 = sptr<MockApplication>::MakeSptr();
@@ -435,11 +435,11 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_NotifyMemoryLevel_0100,
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     auto recordId = AppRecordId::Create();
     appRunningManager->appRunningRecordMap_.emplace(recordId, nullptr);
     std::shared_ptr<AppRunningRecord> record2 =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     record2->priorityObject_ = nullptr;
     auto ret = appRunningManager->NotifyMemoryLevel(1);
 
@@ -460,11 +460,11 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_NotifyProcMemoryLevel_01
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     auto recordId = AppRecordId::Create();
     appRunningManager->appRunningRecordMap_.emplace(recordId, nullptr);
     std::shared_ptr<AppRunningRecord> record2 =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     record2->priorityObject_ = nullptr;
     std::map<pid_t, MemoryLevel> procLevelMap;
     auto ret = appRunningManager->NotifyProcMemoryLevel(procLevelMap);
@@ -487,9 +487,9 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_DumpHeapMemory_0100, Tes
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
 
-    auto record2 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record2 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     record2->priorityObject_ = nullptr;
     OHOS::AppExecFwk::MallocInfo mallocInfo;
     auto ret = appRunningManager->DumpHeapMemory(1, mallocInfo);
@@ -512,8 +512,8 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_GetAppRunningRecordByRen
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    auto record1 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
-    auto record2 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record1 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
+    auto record2 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     auto renderRecord = std::make_shared<RenderRecord>(0, "", -1, -1, -1, record2);
     record2->AddRenderRecord(renderRecord);
     auto ret = appRunningManager->GetAppRunningRecordByRenderPid(1);
@@ -535,7 +535,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_NotifyLoadRepairPatch_01
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    auto record1 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record1 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     auto ret = appRunningManager->NotifyLoadRepairPatch(BUNDLE_NAME, nullptr);
 
     /**
@@ -560,7 +560,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_NotifyLoadRepairPatch_02
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    auto record1 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record1 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     sptr<MockApplication> mockApp1 = sptr<MockApplication>::MakeSptr();
     record1->SetApplicationClient(mockApp1);
     EXPECT_CALL(*mockApp1, ScheduleNotifyLoadRepairPatch(_, _, _)).Times(1).WillOnce(Return(ERR_OK));
@@ -591,7 +591,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_NotifyLoadRepairPatch_03
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     auto recordId = AppRecordId::Create();
     appRunningManager->appRunningRecordMap_.emplace(recordId, nullptr);
 
@@ -617,7 +617,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_NotifyHotReloadPage_0100
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    auto record1 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record1 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     auto ret = appRunningManager->NotifyHotReloadPage(BUNDLE_NAME, nullptr);
 
     /**
@@ -642,7 +642,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_NotifyHotReloadPage_0200
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    auto record1 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record1 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     sptr<MockApplication> mockApp1 = sptr<MockApplication>::MakeSptr();
     record1->SetApplicationClient(mockApp1);
     EXPECT_CALL(*mockApp1, ScheduleNotifyHotReloadPage(_, _)).Times(1).WillOnce(Return(ERR_OK));
@@ -674,7 +674,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_NotifyHotReloadPage_0300
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     auto recordId = AppRecordId::Create();
     appRunningManager->appRunningRecordMap_.emplace(recordId, nullptr);
 
@@ -702,7 +702,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_NotifyUnLoadRepairPatch_
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    auto record1 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record1 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     auto ret = appRunningManager->NotifyUnLoadRepairPatch(BUNDLE_NAME, nullptr);
 
     /**
@@ -728,7 +728,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_NotifyUnLoadRepairPatch_
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    auto record1 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record1 = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     sptr<MockApplication> mockApp1 = sptr<MockApplication>::MakeSptr();
     record1->SetApplicationClient(mockApp1);
     EXPECT_CALL(*mockApp1, ScheduleNotifyUnLoadRepairPatch(_, _, _)).Times(1).WillOnce(Return(ERR_OK));
@@ -760,7 +760,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_NotifyUnLoadRepairPatch_
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     auto recordId = AppRecordId::Create();
     appRunningManager->appRunningRecordMap_.emplace(recordId, nullptr);
 
@@ -923,7 +923,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationFirstForegr
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
 
     /**
      * @tc.steps: step1. Initialize AppRunningManager instance
@@ -953,7 +953,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationFirstForegr
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     record->extensionType_ = AppExecFwk::ExtensionAbilityType::UI;
 
     /**
@@ -983,7 +983,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationFirstForegr
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     record->extensionType_ = AppExecFwk::ExtensionAbilityType::UI;
 
     /**
@@ -1013,7 +1013,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationFirstForegr
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     record->extensionType_ = AppExecFwk::ExtensionAbilityType::SERVICE;
     record->SetAppIndex(0);
 
@@ -1045,7 +1045,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationFirstForegr
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     record->extensionType_ = AppExecFwk::ExtensionAbilityType::SERVICE;
     record->SetAppIndex(1);
     record->SetState(ApplicationState::APP_STATE_FOREGROUND);
@@ -1078,7 +1078,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationFirstForegr
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     record->extensionType_ = AppExecFwk::ExtensionAbilityType::SERVICE;
     record->SetAppIndex(1);
     record->SetState(ApplicationState::APP_STATE_BACKGROUND);
@@ -1163,7 +1163,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationBackground_
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     record->extensionType_ = AppExecFwk::ExtensionAbilityType::UI;
 
     /**
@@ -1191,7 +1191,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationBackground_
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     record->extensionType_ = AppExecFwk::ExtensionAbilityType::WINDOW;
 
     /**
@@ -1220,7 +1220,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationBackground_
     EXPECT_NE(appRunningManager, nullptr);
 
     appInfo_->bundleName = BUNDLE_NAME;
-    auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     record->extensionType_ = AppExecFwk::ExtensionAbilityType::SERVICE;
     record->SetState(ApplicationState::APP_STATE_FOREGROUND);
 
@@ -1249,7 +1249,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationBackground_
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     record->extensionType_ = AppExecFwk::ExtensionAbilityType::SERVICE;
     record->SetAppIndex(1);
     record->SetState(ApplicationState::APP_STATE_BACKGROUND);
@@ -1309,7 +1309,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationFirstFocuse
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
 
     /**
      * @tc.steps: step2. Initialize AppRunningManager instance
@@ -1338,7 +1338,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationFirstFocuse
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
 
     /**
      * @tc.steps: step2. Initialize AppRunningManager instance
@@ -1365,7 +1365,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationFirstFocuse
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     auto abilityInfo = std::make_shared<AbilityInfo>();
     auto ability = std::make_shared<AbilityRunningRecord>(abilityInfo, nullptr, 0);
     record->AbilityFocused(ability);
@@ -1397,7 +1397,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationFirstFocuse
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     auto abilityInfo = std::make_shared<AbilityInfo>();
     auto ability = std::make_shared<AbilityRunningRecord>(abilityInfo, nullptr, 0);
     record->AbilityFocused(ability);
@@ -1456,7 +1456,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationUnfocused_0
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
 
     /**
      * @tc.steps: step2. Initialize AppRunningManager instance
@@ -1483,7 +1483,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationUnfocused_0
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
 
     /**
      * @tc.steps: step2. Initialize AppRunningManager instance
@@ -1509,7 +1509,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_IsApplicationUnfocused_0
     auto appRunningManager = std::make_shared<AppRunningManager>();
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
-    auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+    auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
     auto abilityInfo = std::make_shared<AbilityInfo>();
     auto ability = std::make_shared<AbilityRunningRecord>(abilityInfo, nullptr, 0);
     record->AbilityFocused(ability);
@@ -1566,7 +1566,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_SignRestartAppFlag_0200,
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
 
     /**
      * @tc.steps: step2. Initialize AppRunningManager instance
@@ -1593,7 +1593,7 @@ HWTEST_F(AppRunningManagerSecondTest, AppRunningManager_SignRestartAppFlag_0300,
     EXPECT_NE(appRunningManager, nullptr);
     appInfo_->bundleName = BUNDLE_NAME;
     std::shared_ptr<AppRunningRecord> record =
-        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo);
+        appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
 
     /**
      * @tc.steps: step2. Initialize AppRunningManager instance

test/unittest/app_running_manager_test/app_running_manager_test.cpp

@@ -326,7 +326,7 @@ HWTEST_F(AppRunningManagerTest, RemoveAppRunningRecordById_0100, TestSize.Level1
     std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
     std::string processName = "test.ProcessName";
     BundleInfo bundleInfo;
-    auto appRecord = appRunningManager->CreateAppRunningRecord(appInfo, processName, bundleInfo);
+    auto appRecord = appRunningManager->CreateAppRunningRecord(appInfo, processName, bundleInfo, "");
     ASSERT_NE(appRecord, nullptr);
 
     int32_t uiExtensionAbilityId = 1000;
@@ -351,7 +351,7 @@ HWTEST_F(AppRunningManagerTest, AppRunningRecord_0100, TestSize.Level1)
         std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
         static std::string processName = "test.ProcessName";
         BundleInfo bundleInfo;
-        auto appRecord = appRunningManager_Record0100->CreateAppRunningRecord(appInfo, processName, bundleInfo);
+        auto appRecord = appRunningManager_Record0100->CreateAppRunningRecord(appInfo, processName, bundleInfo, "");
         ASSERT_NE(appRecord, nullptr);
         processName += "a";
 

test/unittest/app_running_processes_info_test/app_running_processes_info_test.cpp

@@ -218,8 +218,10 @@ HWTEST_F(AppRunningProcessesInfoTest, UpdateAppRunningRecord_001, TestSize.Level
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     EXPECT_TRUE(record != nullptr);
     record->SetState(ApplicationState::APP_STATE_FOREGROUND);
     record->SetApplicationClient(GetMockedAppSchedulerClient());
@@ -249,8 +251,10 @@ HWTEST_F(AppRunningProcessesInfoTest, UpdateAppRunningRecord_002, TestSize.Level
     BundleInfo bundleInfo;
     HapModuleInfo hapModuleInfo;
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     EXPECT_TRUE(record != nullptr);
 
     record->SetUid(uid);
@@ -309,8 +313,10 @@ HWTEST_F(AppRunningProcessesInfoTest, UpdateAppRunningRecord_004, TestSize.Level
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     EXPECT_TRUE(record != nullptr);
     record->SetState(ApplicationState::APP_STATE_BACKGROUND);
     record->SetApplicationClient(GetMockedAppSchedulerClient());
@@ -339,8 +345,10 @@ HWTEST_F(AppRunningProcessesInfoTest, UpdateAppRunningRecord_005, TestSize.Level
     HapModuleInfo hapModuleInfo;
     hapModuleInfo.moduleName = "module789";
     EXPECT_TRUE(service_ != nullptr);
+    auto loadParam = std::make_shared<AbilityRuntime::LoadParam>();
+    loadParam->token = GetMockToken();
     auto record = service_->CreateAppRunningRecord(
-        GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr, 0);
+        loadParam, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo, nullptr);
     EXPECT_TRUE(record != nullptr);
     record->SetState(ApplicationState::APP_STATE_BACKGROUND);
     record->SetApplicationClient(GetMockedAppSchedulerClient());

test/unittest/app_scheduler_test/app_scheduler_test.cpp

@@ -231,7 +231,7 @@ HWTEST_F(AppSchedulerTest, AppScheduler_oprator_004, TestSize.Level1)
     DelayedSingleton<AppScheduler>::GetInstance()->appMgrClient_ = nullptr;
     EXPECT_NE((int)ERR_OK,
         DelayedSingleton<AppScheduler>::GetInstance()->LoadAbility(
-            token, pretoken, record->GetAbilityInfo(), record->GetApplicationInfo(), record->GetWant(), 0));
+            token, pretoken, record->GetAbilityInfo(), record->GetApplicationInfo(), record->GetWant(), 0, ""));
 }
 
 /*
@@ -253,7 +253,7 @@ HWTEST_F(AppSchedulerTest, AppScheduler_LoadAbility_001, TestSize.Level1)
     Want want;
     DelayedSingleton<AppScheduler>::GetInstance()->appMgrClient_ = std::move(clientMock_);
     int res = DelayedSingleton<AppScheduler>::GetInstance()->LoadAbility(
-        token, preToken, abilityInfo, applicationInfo, want, 0);
+        token, preToken, abilityInfo, applicationInfo, want, 0, "");
     EXPECT_EQ(res, INNER_ERR);
 }
 

test/unittest/app_utils_test/app_utils_test.cpp

@@ -311,5 +311,25 @@ HWTEST_F(AppUtilsTest, AppUtilsTest_1400, TestSize.Level0)
     auto allow = AAFwk::AppUtils::GetInstance().IsAllowNativeChildProcess("com.test.demo");
     EXPECT_FALSE(allow);
 }
+
+/**
+ * @tc.number: AppUtilsTest_1500
+ * @tc.desc: Test IsSupportMultiInstance works
+ * @tc.type: FUNC
+ */
+HWTEST_F(AppUtilsTest, AppUtilsTest_1500, TestSize.Level0)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AppUtilsTest_1500 called.");
+    bool isSupportMultiInstance = AAFwk::AppUtils::GetInstance().IsSupportMultiInstance();
+    std::string deviceType = OHOS::system::GetDeviceType();
+    TAG_LOGI(AAFwkTag::TEST, "current deviceType is %{public}s", deviceType.c_str());
+    if (deviceType == "default") {
+        EXPECT_TRUE(isSupportMultiInstance == false);
+    } else if (deviceType == "phone") {
+        EXPECT_TRUE(isSupportMultiInstance == false);
+    } else if (deviceType == "2in1") {
+        EXPECT_TRUE(isSupportMultiInstance == true);
+    }
+}
 }  // namespace AbilityRuntime
 }  // namespace OHOS

utils/server/startup/include/param.h

@@ -38,10 +38,11 @@ struct LoadParam : public Parcelable {
     static LoadParam *Unmarshalling(Parcel &parcel);
     bool ReadFromParcel(Parcel &parcel);
 
-    int32_t abilityRecordId = 0;
+    int32_t abilityRecordId = -1;
     bool isShellCall = false;
     sptr<IRemoteObject> token = nullptr;
     sptr<IRemoteObject> preToken = nullptr;
+    std::string instanceKey = "";
 };
 }  // namespace AbilityRuntime
 }  // namespace OHOS

utils/server/startup/src/param.cpp

@@ -24,6 +24,9 @@ bool LoadParam::Marshalling(Parcel &parcel) const
     if (!parcel.WriteBool(isShellCall)) {
         return false;
     }
+    if (!parcel.WriteString(instanceKey)) {
+        return false;
+    }
     if (token == nullptr) {
         if (!parcel.WriteBool(false)) {
             return false;
@@ -55,6 +58,7 @@ bool LoadParam::ReadFromParcel(Parcel &parcel)
 {
     abilityRecordId = parcel.ReadInt32();
     isShellCall = parcel.ReadBool();
+    instanceKey = parcel.ReadString();
     if (parcel.ReadBool()) {
         token = (static_cast<MessageParcel*>(&parcel))->ReadRemoteObject();
         if (token == nullptr) {