openharmony/ability_ability_runtime
1
0
Fork 0
mirror of https://gitee.com/openharmony/ability_ability_runtime synced 2024-10-07 00:13:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

!10528 支持应用多实例

Browse Source 
Merge pull request !10528 from 于文泽/instance
This commit is contained in:
openharmony_ci 2024-09-20 15:50:10 +00:00 committed by Gitee
commit 101dc7eb1f
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
41 changed files with 993 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
frameworks/native/ability/native/ability_business_error/ability_business_error.cpp
View File

@ -90,6 +90,10 @@ constexpr const char* ERROR_MSG_EXTENSION_START_THIRD_PARTY_APP_CONTROLLED =
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;
@ -152,7 +156,11 @@ static std::unordered_map<AbilityErrorCode, const char*> ERR_CODE_MAP = {
{ 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_MULTI_INSTANCE_NOT_SUPPORTED, ERROR_MSG_MULTI_INSTANCE_NOT_SUPPORTED }
{ 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 {
@ -218,6 +226,11 @@ static std::unordered_map<int32_t, AbilityErrorCode> INNER_TO_JS_ERROR_CODE_MAP
{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},
};
}

12
interfaces/kits/native/ability/native/ability_business_error/ability_business_error.h
View File

@ -162,9 +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,

6
services/abilitymgr/include/ability_record.h
View File

@ -1092,6 +1092,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);
@ -1317,6 +1322,7 @@ private:
ffrt::mutex connectWantLock_;
bool isLaunching_ = true;
LaunchDebugInfo launchDebugInfo_;
std::string instanceKey_ = "";
};
} // namespace AAFwk
} // namespace OHOS

17
services/abilitymgr/include/ability_util.h
View File

@ -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);

2
services/abilitymgr/include/app_scheduler.h
View File

@ -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.

9
services/abilitymgr/include/utils/ability_permission_util.h
View File

@ -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

2
services/abilitymgr/src/ability_connect_manager.cpp
View File

@ -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);
}

58
services/abilitymgr/src/ability_manager_service.cpp
View File

@ -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();
@ -7186,6 +7215,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,
@ -8114,6 +8148,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;
@ -10174,6 +10218,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_) {
@ -10243,6 +10291,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);
@ -10693,6 +10747,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);
@ -10721,6 +10776,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();
@ -12067,7 +12123,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) ||

5
services/abilitymgr/src/ability_record.cpp
View File

@ -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);

3
services/abilitymgr/src/app_scheduler.cpp
View File

@ -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) {

12
services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp
View File

@ -85,9 +85,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()) {
@ -358,6 +358,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(
@ -1481,10 +1485,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)
@ -1860,6 +1865,7 @@ int UIAbilityLifecycleManager::StartAbilityBySpecifed(const AbilityRequest &abil
sessionInfo->want = abilityRequest.want;
sessionInfo->requestCode = abilityRequest.requestCode;
sessionInfo->processOptions = abilityRequest.processOptions;
sessionInfo->instanceKey = abilityRequest.want.GetStringParam(Want::APP_INSTANCE_KEY);
SpecifiedInfo specifiedInfo;
specifiedInfo.abilityName = abilityRequest.abilityInfo.name;
specifiedInfo.bundleName = abilityRequest.abilityInfo.bundleName;

92
services/abilitymgr/src/utils/ability_permission_util.cpp
View File

@ -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

4
services/appmgr/include/app_mgr_service_inner.h
View File

@ -476,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);
/**

6
services/appmgr/include/app_running_manager.h
View File

@ -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
/**

40
services/appmgr/src/app_mgr_service_inner.cpp
View File

@ -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) {
@ -2337,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))) {
@ -2349,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;
@ -2364,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));
@ -3876,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;
@ -4171,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);
@ -4298,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);
@ -4307,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;

8
services/appmgr/src/app_running_manager.cpp
View File

@ -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())) {

2
services/common/include/app_utils.h
View File

@ -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>>

11
services/common/src/app_utils.cpp
View File

@ -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

2
test/fuzztest/abilityappmgrapprunningmanager_fuzzer/abilityappmgrapprunningmanager_fuzzer.cpp
View File

@ -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);

2
test/mock/services_abilitymgr_test/libs/appexecfwk_core/src/appmgr/mock_app_scheduler.cpp
View File

@ -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) {

1
test/moduletest/common/ams/app_running_processes_info_module_test/BUILD.gn
View File

@ -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",

29
test/moduletest/common/ams/app_running_processes_info_module_test/app_running_processes_info_module_test.cpp
View File

@ -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);

1
test/moduletest/common/ams/app_service_flow_test/BUILD.gn
View File

@ -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",

5
test/moduletest/common/ams/app_service_flow_test/ams_app_service_flow_module_test.cpp
View File

@ -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);

1
test/unittest/BUILD.gn
View File

@ -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",

50
test/unittest/ability_permission_util_test/BUILD.gn Normal file
View File

@ -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" ]
}

263
test/unittest/ability_permission_util_test/ability_permission_util_test.cpp Normal file
View File

@ -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

15
test/unittest/ability_record_test/ability_record_test.cpp
View File

@ -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

138
test/unittest/ams_app_running_record_test/ams_app_running_record_test.cpp
View File

@ -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);

16
test/unittest/ams_service_load_ability_process_test/ams_service_load_ability_process_test.cpp
View File

@ -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);

85
test/unittest/app_mgr_service_inner_second_test/app_mgr_service_inner_second_test.cpp
View File

@ -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

20
test/unittest/app_mgr_service_inner_tdd_test/app_mgr_service_inner_tdd_test.cpp
View File

@ -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";

182
test/unittest/app_mgr_service_inner_test/app_mgr_service_inner_test.cpp
View File

@ -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";

2
test/unittest/app_mgr_service_test/app_mgr_service_test.cpp
View File

@ -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());

84
test/unittest/app_running_manager_second_test/app_running_manager_second_test.cpp
View File

@ -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

4
test/unittest/app_running_manager_test/app_running_manager_test.cpp
View File

@ -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";

16
test/unittest/app_running_processes_info_test/app_running_processes_info_test.cpp
View File

@ -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());

4
test/unittest/app_scheduler_test/app_scheduler_test.cpp
View File

@ -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);
}

20
test/unittest/app_utils_test/app_utils_test.cpp
View File

@ -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

3
utils/server/startup/include/param.h
View File

@ -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

4
utils/server/startup/src/param.cpp
View File

@ -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) {