diff --git a/interfaces/innerkits/appexecfwk_core/BUILD.gn b/interfaces/innerkits/appexecfwk_core/BUILD.gn index 2143c0d89da557cdf067bb4c1710c4b02820b9e4..d1e1f3ecd7f151b79ed6938aa5fed6787530973c 100644 --- a/interfaces/innerkits/appexecfwk_core/BUILD.gn +++ b/interfaces/innerkits/appexecfwk_core/BUILD.gn @@ -53,7 +53,6 @@ ohos_shared_library("appexecfwk_core") { "src/appmgr/app_mgr_stub.cpp", "src/appmgr/app_process_data.cpp", "src/appmgr/app_record_id.cpp", - "src/appmgr/app_resident_process_info.cpp", "src/appmgr/app_scheduler_host.cpp", "src/appmgr/app_scheduler_proxy.cpp", "src/appmgr/app_service_manager.cpp", diff --git a/interfaces/innerkits/appexecfwk_core/include/appmgr/app_process_data.h b/interfaces/innerkits/appexecfwk_core/include/appmgr/app_process_data.h index 48e3a991ad500f127deffc4b100643c8b530062c..751e18ce8695c682c88b84692ff063c05a08ac2f 100644 --- a/interfaces/innerkits/appexecfwk_core/include/appmgr/app_process_data.h +++ b/interfaces/innerkits/appexecfwk_core/include/appmgr/app_process_data.h @@ -24,6 +24,12 @@ namespace OHOS { namespace AppExecFwk { + +struct AppData { + std::string appName; + int32_t uid; +}; + struct AppProcessData : public Parcelable { /** * @brief read this Sequenceable object from a Parcel. @@ -47,11 +53,10 @@ struct AppProcessData : public Parcelable { */ static AppProcessData *Unmarshalling(Parcel &parcel); - std::string appName; std::string processName; ApplicationState appState = ApplicationState::APP_STATE_CREATE; pid_t pid = 0; - int32_t uid = 0; + std::vector appDatas; }; } // namespace AppExecFwk } // namespace OHOS diff --git a/interfaces/innerkits/appexecfwk_core/include/appmgr/app_resident_process_info.h b/interfaces/innerkits/appexecfwk_core/include/appmgr/app_resident_process_info.h deleted file mode 100644 index 26b373d1e8fdcf32301397ae672157a9dc469c05..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/appexecfwk_core/include/appmgr/app_resident_process_info.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef FOUNDATION_APPEXECFWK_INTERFACES_INNERKITS_APPEXECFWK_CORE_INCLUDE_APPMGR_APP_RESIDENT_PROCESS_INFO_H -#define FOUNDATION_APPEXECFWK_INTERFACES_INNERKITS_APPEXECFWK_CORE_INCLUDE_APPMGR_APP_RESIDENT_PROCESS_INFO_H - -#include "parcel.h" -#include "hap_module_info.h" - -namespace OHOS { -namespace AppExecFwk { -struct AppResidentProcessInfo : public Parcelable { - /** - * @brief read this Sequenceable object from a Parcel. - * - * @param inParcel Indicates the Parcel object into which the Sequenceable object has been marshaled. - * @return Returns true if read successed; returns false otherwise. - */ - bool ReadFromParcel(Parcel &parcel); - - /** - * @brief Marshals this Sequenceable object into a Parcel. - * - * @param outParcel Indicates the Parcel object to which the Sequenceable object will be marshaled. - */ - virtual bool Marshalling(Parcel &parcel) const override; - - /** - * @brief Unmarshals this Sequenceable object from a Parcel. - * - * @param inParcel Indicates the Parcel object into which the Sequenceable object has been marshaled. - */ - static AppResidentProcessInfo *Unmarshalling(Parcel &parcel); - - // This information should be needed right now - bool isKeepAliveApp_ = false; - std::vector abilityStage_; -}; -} // namespace AppExecFwk -} // namespace OHOS -#endif // FOUNDATION_APPEXECFWK_INTERFACES_INNERKITS_APPEXECFWK_CORE_INCLUDE_APPMGR_APP_RESIDENT_PROCESS_INFO_H \ No newline at end of file diff --git a/interfaces/innerkits/appexecfwk_core/include/appmgr/app_scheduler_interface.h b/interfaces/innerkits/appexecfwk_core/include/appmgr/app_scheduler_interface.h index 154b400f06fdce4cd0d2c788f03c5a4dc97cea95..bc9b9702616aa804025e44dc615c7c511bed7731 100644 --- a/interfaces/innerkits/appexecfwk_core/include/appmgr/app_scheduler_interface.h +++ b/interfaces/innerkits/appexecfwk_core/include/appmgr/app_scheduler_interface.h @@ -19,8 +19,8 @@ #include "iremote_broker.h" #include "ability_info.h" #include "app_launch_data.h" -#include "app_resident_process_info.h" #include "configuration.h" +#include "hap_module_info.h" namespace OHOS { namespace AppExecFwk { @@ -88,7 +88,7 @@ public: * * @return */ - virtual void ScheduleAbilityStageInfo(const AppResidentProcessInfo &) = 0; + virtual void ScheduleAbilityStageInfo(const HapModuleInfo &) = 0; /** * ScheduleLaunchAbility, call ScheduleLaunchAbility() through proxy project, diff --git a/interfaces/innerkits/appexecfwk_core/include/appmgr/app_scheduler_proxy.h b/interfaces/innerkits/appexecfwk_core/include/appmgr/app_scheduler_proxy.h index a39bb3b9e0673526042668a6c20373c3c50cb650..a6762b225d128a51fdc12a2ba590cbfe297d6181 100644 --- a/interfaces/innerkits/appexecfwk_core/include/appmgr/app_scheduler_proxy.h +++ b/interfaces/innerkits/appexecfwk_core/include/appmgr/app_scheduler_proxy.h @@ -83,7 +83,7 @@ public: * * @param The resident process data value. */ - virtual void ScheduleAbilityStageInfo(const AppResidentProcessInfo &residentProcessInfo) override; + virtual void ScheduleAbilityStageInfo(const HapModuleInfo &abilityStage) override; /** * ScheduleLaunchAbility, call ScheduleLaunchAbility() through proxy project, diff --git a/interfaces/innerkits/appexecfwk_core/src/appmgr/app_process_data.cpp b/interfaces/innerkits/appexecfwk_core/src/appmgr/app_process_data.cpp index 137b244ce97e8d21e9f96b1d7eef94d2467dddb3..a6297036e806011cde702dca91216c1b75807ce8 100644 --- a/interfaces/innerkits/appexecfwk_core/src/appmgr/app_process_data.cpp +++ b/interfaces/innerkits/appexecfwk_core/src/appmgr/app_process_data.cpp @@ -17,25 +17,62 @@ #include "app_log_wrapper.h" +#include +#include +#include +#include + +#include "nlohmann/json.hpp" +#include "string_ex.h" +#include "parcel_macro.h" + namespace OHOS { namespace AppExecFwk { +namespace { + +bool ReadFromParcelAppData(std::vector &appDatas, Parcel &parcel) +{ + int32_t appDataSize; + READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, appDataSize); + for (auto i = 0; i < appDataSize; i++) { + AppData appDataInfo; + std::string appName = Str16ToStr8(parcel.ReadString16()); + int32_t uid = parcel.ReadInt32(); + appDataInfo.appName = appName; + appDataInfo.uid = uid; + appDatas.emplace_back(appDataInfo); + } + return true; +} +} // namespace + bool AppProcessData::Marshalling(Parcel &parcel) const { - return (parcel.WriteString(appName) && parcel.WriteString(processName) && - parcel.WriteInt32(static_cast(appState)) && parcel.WriteInt32(pid) && parcel.WriteInt32(uid)); + WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(processName)); + + WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast(appState)); + + WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, pid); + + const auto appDataSize = static_cast(appDatas.size()); + WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, appDataSize); + for (auto i = 0; i < appDataSize; i++) { + WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(appDatas[i].appName)); + WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, appDatas[i].uid); + } + + return true; } bool AppProcessData::ReadFromParcel(Parcel &parcel) { - appName = parcel.ReadString(); - - processName = parcel.ReadString(); + processName = Str16ToStr8(parcel.ReadString16()); appState = static_cast(parcel.ReadInt32()); pid = parcel.ReadInt32(); - uid = parcel.ReadInt32(); + ReadFromParcelAppData(appDatas, parcel); return true; } diff --git a/interfaces/innerkits/appexecfwk_core/src/appmgr/app_resident_process_info.cpp b/interfaces/innerkits/appexecfwk_core/src/appmgr/app_resident_process_info.cpp deleted file mode 100644 index 9242a24ac7a79b0a0f74fa4d6d0af068846e8ba8..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/appexecfwk_core/src/appmgr/app_resident_process_info.cpp +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright (c) 2021 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 "app_resident_process_info.h" -#include "app_log_wrapper.h" - -namespace OHOS { -namespace AppExecFwk { -AppResidentProcessInfo *AppResidentProcessInfo::Unmarshalling(Parcel &parcel) -{ - AppResidentProcessInfo *residentProcess = new (std::nothrow) OHOS::AppExecFwk::AppResidentProcessInfo(); - if (residentProcess && !residentProcess->ReadFromParcel(parcel)) { - delete residentProcess; - residentProcess = nullptr; - } - return residentProcess; -} - -bool AppResidentProcessInfo::Marshalling(Parcel &parcel) const -{ - APP_LOGW("Marshalling"); - parcel.WriteBool(isKeepAliveApp_); - parcel.WriteInt32(abilityStage_.size()); - for (auto &info : abilityStage_) { - if (!parcel.WriteParcelable(&info)) { - return false; - } - } - return true; -} - -bool AppResidentProcessInfo::ReadFromParcel(Parcel &parcel) -{ - isKeepAliveApp_ = parcel.ReadBool(); - auto size = parcel.ReadInt32(); - for (int32_t i = 0; i < size; i++) { - std::unique_ptr hapModuleInfo(parcel.ReadParcelable()); - if (!hapModuleInfo) { - APP_LOGE("ReadParcelable failed"); - return false; - } - abilityStage_.emplace_back(*hapModuleInfo); - } - return true; -} -} // namespace AppExecFwk -} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/appexecfwk_core/src/appmgr/app_scheduler_host.cpp b/interfaces/innerkits/appexecfwk_core/src/appmgr/app_scheduler_host.cpp index 19259f5ebe73a9a3c9e2ec0b78b9027dca265369..5c0e2d1ed02b5aea7796ccb344f6e6e668cab5db 100644 --- a/interfaces/innerkits/appexecfwk_core/src/appmgr/app_scheduler_host.cpp +++ b/interfaces/innerkits/appexecfwk_core/src/appmgr/app_scheduler_host.cpp @@ -148,13 +148,14 @@ int32_t AppSchedulerHost::HandleScheduleLaunchApplication(MessageParcel &data, M int32_t AppSchedulerHost::HandleScheduleAbilityStageInfo(MessageParcel &data, MessageParcel &reply) { - std::unique_ptr appResidentProcessInfo(data.ReadParcelable()); - if (!appResidentProcessInfo) { + BYTRACE(BYTRACE_TAG_APP); + std::unique_ptr abilityStage(data.ReadParcelable()); + if (!abilityStage) { APP_LOGE("ReadParcelable failed"); return ERR_APPEXECFWK_PARCEL_ERROR; } - ScheduleAbilityStageInfo(*appResidentProcessInfo); + ScheduleAbilityStageInfo(*abilityStage); return NO_ERROR; } diff --git a/interfaces/innerkits/appexecfwk_core/src/appmgr/app_scheduler_proxy.cpp b/interfaces/innerkits/appexecfwk_core/src/appmgr/app_scheduler_proxy.cpp index cefaac1f2967df88fa86b47ed201c8d582f30439..b35b47272d00f6ad5014e5b6ffe6bc810d99e51f 100644 --- a/interfaces/innerkits/appexecfwk_core/src/appmgr/app_scheduler_proxy.cpp +++ b/interfaces/innerkits/appexecfwk_core/src/appmgr/app_scheduler_proxy.cpp @@ -214,7 +214,7 @@ void AppSchedulerProxy::ScheduleLaunchApplication(const AppLaunchData &launchDat APP_LOGI("AppSchedulerProxy ScheduleLaunchApplication end"); } -void AppSchedulerProxy::ScheduleAbilityStageInfo(const AppResidentProcessInfo &residentProcessInfo) +void AppSchedulerProxy::ScheduleAbilityStageInfo(const HapModuleInfo &abilityStage) { APP_LOGI("AppSchedulerProxy ScheduleAbilityStageInfo start"); MessageParcel data; @@ -224,7 +224,7 @@ void AppSchedulerProxy::ScheduleAbilityStageInfo(const AppResidentProcessInfo &r return; } - if (!data.WriteParcelable(&residentProcessInfo)) { + if (!data.WriteParcelable(&abilityStage)) { return ; } diff --git a/kits/appkit/native/app/include/main_thread.h b/kits/appkit/native/app/include/main_thread.h index 2b2bbda768b75d45821ab5654260580fce3e7e78..6e86bd69a2fbb5e22455dca1ef177c9fbe7f4704 100644 --- a/kits/appkit/native/app/include/main_thread.h +++ b/kits/appkit/native/app/include/main_thread.h @@ -158,7 +158,7 @@ public: * * @param The resident process data value. */ - void ScheduleAbilityStageInfo(const AppResidentProcessInfo &residentProcessInfo) override; + void ScheduleAbilityStageInfo(const HapModuleInfo &abilityStage) override; /** * @@ -251,7 +251,7 @@ private: * @param appLaunchData The launchdata of the application witch launced. * */ - void HandleAbilityStageInfo(const AppResidentProcessInfo &residentProcessInfo); + void HandleAbilityStageInfo(const HapModuleInfo &abilityStage); /** * diff --git a/kits/appkit/native/app/src/main_thread.cpp b/kits/appkit/native/app/src/main_thread.cpp index 1a7e7e7189a881b4bc92f00b47d76210bea663e2..a3fb31d212a8dc56d41e5ad3487f8a3b54a5de5d 100644 --- a/kits/appkit/native/app/src/main_thread.cpp +++ b/kits/appkit/native/app/src/main_thread.cpp @@ -353,10 +353,10 @@ void MainThread::ScheduleLaunchApplication(const AppLaunchData &data) APP_LOGI("MainThread::scheduleLaunchApplication end."); } -void MainThread::ScheduleAbilityStageInfo(const AppResidentProcessInfo &residentProcessInfo) +void MainThread::ScheduleAbilityStageInfo(const HapModuleInfo &abilityStage) { APP_LOGI("MainThread::ScheduleAbilityStageInfo start"); - auto task = [appThread = this, residentProcessInfo]() { appThread->HandleAbilityStageInfo(residentProcessInfo);}; + auto task = [appThread = this, abilityStage]() { appThread->HandleAbilityStageInfo(abilityStage);}; if (!mainHandler_->PostTask(task)) { APP_LOGE("MainThread::ScheduleAbilityStageInfo PostTask task failed"); } @@ -794,7 +794,7 @@ void MainThread::HandleLaunchApplication(const AppLaunchData &appLaunchData) APP_LOGI("MainThread::handleLaunchApplication called end."); } -void MainThread::HandleAbilityStageInfo(const AppResidentProcessInfo &residentProcessInfo) +void MainThread::HandleAbilityStageInfo(const HapModuleInfo &abilityStage) {} /** diff --git a/services/appmgr/BUILD.gn b/services/appmgr/BUILD.gn index 33fb2bd6d911ea746943a5bf3d2f1bb73f327843..8faea3607c9bab225990e6a45da79f7a1ffa597a 100644 --- a/services/appmgr/BUILD.gn +++ b/services/appmgr/BUILD.gn @@ -89,6 +89,7 @@ ohos_shared_library("libams") { "src/app_spawn_socket.cpp", "src/cgroup_manager.cpp", "src/lmks_client.cpp", + "src/module_running_record.cpp", "src/process_optimizer.cpp", "src/process_optimizer_uba.cpp", "src/remote_client_manager.cpp", diff --git a/services/appmgr/include/app_lifecycle_deal.h b/services/appmgr/include/app_lifecycle_deal.h index 42eaffda64505881be072d33661ad8d925d50585..8f35c1a4a233c4fbb89c2a1557b12230fa6a3f11 100644 --- a/services/appmgr/include/app_lifecycle_deal.h +++ b/services/appmgr/include/app_lifecycle_deal.h @@ -18,8 +18,8 @@ #include "app_scheduler_proxy.h" #include "app_launch_data.h" -#include "app_resident_process_info.h" #include "ability_running_record.h" +#include "hap_module_info.h" namespace OHOS { namespace AppExecFwk { @@ -46,7 +46,7 @@ public: * * @return */ - void AddAbilityStageInfo(const AppResidentProcessInfo &residentProcessInfo); + void AddAbilityStageInfo(const HapModuleInfo &abilityStage); /** * LaunchAbility, call ScheduleLaunchAbility() through proxy project, diff --git a/services/appmgr/include/app_mgr_service_inner.h b/services/appmgr/include/app_mgr_service_inner.h index 13c3733bb211aadef794b62dada19dbffd10de43..90d4d066b7938b761fa832f4803f10d4867676b6 100644 --- a/services/appmgr/include/app_mgr_service_inner.h +++ b/services/appmgr/include/app_mgr_service_inner.h @@ -19,6 +19,7 @@ #include #include #include +#include #include "iremote_object.h" #include "refbase.h" @@ -241,7 +242,7 @@ public: // If error occurs, error code is in |result| /** - * GetOrCreateAppRunningRecord, Get or create application record information. + * CreateAppRunningRecord, create application record information. * * @param token, the unique identification to the ability. * @param abilityInfo, ability information. @@ -250,13 +251,17 @@ public: * @param uid, app uid in Application record. * @param result, If error occurs, error code is in |result|. * - * @return AppRunningRecord pointer if success get or create. + * @return AppRunningRecord pointer if success create. */ - std::shared_ptr GetOrCreateAppRunningRecord(const sptr &token, - const std::shared_ptr &appInfo, const std::shared_ptr &abilityInfo, - const std::string &processName, const int32_t uid, RecordQueryResult &result); + std::shared_ptr CreateAppRunningRecord( + const sptr &token, + const sptr &preToken, + const std::shared_ptr &appInfo, + const std::shared_ptr &abilityInfo, + const std::string &processName, + const BundleInfo &bundleInfo, + const HapModuleInfo &hapModuleInfo); - std::shared_ptr GetOrCreateAppRunningRecord(const ApplicationInfo &appInfo, bool &appExist); /** * OnStop, Application management service stopped. * @@ -319,28 +324,6 @@ public: */ const std::map> &GetRecordMap() const; - // functions to get special AppRunningRecord - /** - * GetAppRunningRecordByAppName, Get process record by application name. - * - * @param appName, the application name. - * - * @return process record. - */ - std::shared_ptr GetAppRunningRecordByAppName(const std::string &appName) const; - - /** - * GetAppRunningRecordByProcessName, Get process record by application name and process name. - * - * @param appName, the application name. - * @param processName, the process name. - * @param uid, the process uid. - * - * @return process record. - */ - std::shared_ptr GetAppRunningRecordByProcessName( - const std::string &appName, const std::string &processName, const int uid) const; - /** * GetAppRunningRecordByPid, Get process record by application pid. * @@ -499,7 +482,7 @@ public: */ void LoadResidentProcess(); - void StartResidentProcess(const std::vector &v); + void StartResidentProcess(const std::vector &v, int restartCount); bool CheckRemoteClient(); @@ -526,11 +509,17 @@ public: private: - void StartEmptyResidentProcess(const std::string &appName, const std::string &processName, - const std::shared_ptr &appRecord, const int uid); + void StartEmptyResidentProcess(const BundleInfo &info, const std::string &processName, int restartCount); void RestartResidentProcess(std::shared_ptr appRecord); + bool CheckLoadabilityConditions(const sptr &token, + const std::shared_ptr &abilityInfo, const std::shared_ptr &appInfo); + + bool GetBundleInfo(const std::string &bundelName, BundleInfo &bundleInfo); + + void MakeProcessName(std::string &processName, const std::shared_ptr &abilityInfo, + const std::shared_ptr &appInfo); /** * StartAbility, load the ability that needed to be started(Start on the basis of the original process). * Start on a new boot process @@ -542,7 +531,8 @@ private: * @return */ void StartAbility(const sptr &token, const sptr &preToken, - const std::shared_ptr &abilityInfo, const std::shared_ptr &appRecord); + const std::shared_ptr &abilityInfo, const std::shared_ptr &appRecord, + const HapModuleInfo &hapModuleInfo); /** * UnsuspendApplication, Application process state switch to unsuspend. @@ -600,12 +590,13 @@ private: * @param processName, the process name. * @param appRecord, the app information. * @param uid, the process uid. + * @param bundleName, the app bundleName. * * @return */ void StartProcess( const std::string &appName, const std::string &processName, const std::shared_ptr &appRecord, - const int uid); + const int uid, const std::string &bundleName); /** * PushAppFront, Adjust the latest application record to the top level. @@ -709,6 +700,10 @@ private: int32_t KillApplicationByUserId(const std::string &bundleName, const int userId); + void ClipStringContent(const std::regex &re, const std::string &sorce, std::string &afferCutStr); + + bool GetBundleAndHapInfo(const AbilityInfo &abilityInfo, const std::shared_ptr &appInfo, + BundleInfo &bundleInfo, HapModuleInfo &hapModuleInfo); AppProcessData WrapAppProcessData(const std::shared_ptr &appRecord, const ApplicationState state); diff --git a/services/appmgr/include/app_running_manager.h b/services/appmgr/include/app_running_manager.h index 9042f0666bd2051dd2b8d22121336556d9a6b36d..d03a13c27007c24dc8e4d5221100dfb905df0802 100644 --- a/services/appmgr/include/app_running_manager.h +++ b/services/appmgr/include/app_running_manager.h @@ -18,6 +18,7 @@ #include #include +#include #include "iremote_object.h" #include "refbase.h" @@ -27,6 +28,7 @@ #include "application_info.h" #include "app_state_data.h" #include "record_query_result.h" +#include "bundle_info.h" namespace OHOS { namespace AppExecFwk { @@ -35,7 +37,7 @@ public: AppRunningManager(); virtual ~AppRunningManager(); /** - * GetOrCreateAppRunningRecord, Get or create application record information. + * CreateAppRunningRecord, Get or create application record information. * * @param token, the unique identification to start the ability. * @param abilityInfo, ability information. @@ -46,23 +48,11 @@ public: * * @return AppRunningRecord pointer if success get or create. */ - std::shared_ptr GetOrCreateAppRunningRecord(const sptr &token, - const std::shared_ptr &appInfo, const std::shared_ptr &abilityInfo, - const std::string &processName, const int32_t uid, RecordQueryResult &result); - - std::shared_ptr GetOrCreateAppRunningRecord(const ApplicationInfo &appInfo, bool &appExist); - - /** - * GetAppRunningRecordByAppName, Get process record by application name. - * - * @param appName, the application name. - * - * @return process record. - */ - std::shared_ptr GetAppRunningRecordByAppName(const std::string &appName); + std::shared_ptr CreateAppRunningRecord( + const std::shared_ptr &appInfo, const std::string &processName, const BundleInfo &bundleInfo); /** - * GetAppRunningRecordByProcessName, Get process record by application name and process Name. + * CheckAppRunningRecordIsExist, Get process record by application name and process Name. * * @param appName, the application name. * @param processName, the process name. @@ -70,8 +60,8 @@ public: * * @return process record. */ - std::shared_ptr GetAppRunningRecordByProcessName( - const std::string &appName, const std::string &processName, const int uid); + std::shared_ptr CheckAppRunningRecordIsExist(const std::string &appName, + const std::string &processName, const int uid, const BundleInfo &bundleInfo); /** * GetAppRunningRecordByPid, Get process record by application pid. @@ -121,6 +111,12 @@ public: */ void ClearAppRunningRecordMap(); + /** + * Get the pid of a non-resident process. + * + * @return Return true if found, otherwise return false. + */ + bool ProcessExitByBundleName(const std::string &bundleName, std::list &pids); /** * Get Foreground Applications. * @@ -132,15 +128,12 @@ public: void HandleAbilityAttachTimeOut(const sptr &token); std::shared_ptr GetAppRunningRecord(const int64_t eventId); void TerminateAbility(const sptr &token); - bool GetPidsByBundleName(const std::string &bundleName, std::list &pids); - bool GetPidsByBundleNameByUid(const std::string &bundleName, const int uid, std::list &pids); + bool ProcessExitByBundleNameAndUid(const std::string &bundleName, const int uid, std::list &pids); void PrepareTerminate(const sptr &token); std::shared_ptr GetTerminatingAppRunningRecord(const sptr &abilityToken); - bool CanRestartResidentProcCount(const std::string &processName); - bool InitRestartResidentProcRecord(const std::string &processName); - std::shared_ptr GetAppRunningRecordByBundleName(const std::string &bundleName); + void ClipStringContent(const std::regex &re, const std::string &sorce, std::string &afferCutStr); private: std::shared_ptr GetAbilityRunningRecord(const int64_t eventId); diff --git a/services/appmgr/include/app_running_record.h b/services/appmgr/include/app_running_record.h index 7a6df0b4cb52692611ebf83fd194636586579492..66b309ce538c6f8ade83b85f1f330085a6c0cf57 100644 --- a/services/appmgr/include/app_running_record.h +++ b/services/appmgr/include/app_running_record.h @@ -20,9 +20,7 @@ #include #include #include - #include "iremote_object.h" - #include "ability_running_record.h" #include "ability_state_data.h" #include "application_info.h" @@ -34,10 +32,13 @@ #include "profile.h" #include "priority_object.h" #include "app_lifecycle_deal.h" -#include "app_resident_process_info.h" +#include "module_running_record.h" namespace OHOS { namespace AppExecFwk { +namespace { +const int RESTART_RESIDENT_PROCESS_MAX_TIMES = 15; +} class AbilityRunningRecord; class AppMgrServiceInner; class AppRunningRecord : public std::enable_shared_from_this { @@ -51,7 +52,7 @@ public: * * @return Returns app record bundleName. */ - std::string GetBundleName() const; + const std::string &GetBundleName() const; /** * @brief Obtains the app record isLauncherApp flag. @@ -88,6 +89,34 @@ public: */ const std::string &GetProcessName() const; + /** + * @brief Obtains the sign code. + * + * @return Returns the sign code. + */ + const std::string &GetSignCode() const; + + /** + * @brief Setting the sign code. + * + * @param code, the sign code. + */ + void SetSignCode(const std::string &signCode); + + /** + * @brief Obtains the jointUserId. + * + * @return Returns the jointUserId. + */ + const std::string &GetJointUserId() const; + + /** + * @brief Setting the jointUserId. + * + * @param jointUserId, the jointUserId. + */ + void SetJointUserId(const std::string &jointUserId); + /** * @brief Obtains the application uid. * @@ -126,7 +155,7 @@ public: * * @return Returns the abilitys info for the application record. */ - const std::map, std::shared_ptr> &GetAbilities() const; + const std::map, std::shared_ptr> GetAbilities(); // Update appThread with appThread /** @@ -143,17 +172,28 @@ public: */ sptr GetApplicationClient() const; - // Add new ability instance to current running abilities list managed by this process + // Add new module instance to current running modules list managed by this process /** - * AddAbility, Add new ability instance to current running abilities list managed by this process. + * AddModule, Add new module instance to current running modules list managed by this process. * + * @param appInfo, the app info. * @param token, the unique identification to the ability. * @param abilityInfo, the ability info. + * @param hapModuleInfo, the hapModule info. * * @return the ability record. */ - std::shared_ptr AddAbility( - const sptr &token, const std::shared_ptr &abilityInfo); + void AddModule(const std::shared_ptr &appInfo, const std::shared_ptr &abilityInfo, + const sptr &token, const HapModuleInfo &hapModuleInfo); + + void AddModules(const std::shared_ptr &appInfo, const std::vector &moduleInfos); + + std::shared_ptr GetModuleRecordByModuleName( + const std::string bundleName, const std::string &moduleName); + + std::shared_ptr GetModuleRunningRecordByToken(const sptr &token) const; + + std::shared_ptr GetModuleRunningRecordByTerminateLists(const sptr &token) const; // It can only used in SINGLETON mode. /** @@ -257,20 +297,6 @@ public: */ void ScheduleTerminate(); - /** - * ScheduleForegroundRunning, Notify application to switch to foreground. - * - * @return - */ - void ScheduleForegroundRunning(); - - /** - * ScheduleBackgroundRunning, Notify application to switch to background. - * - * @return - */ - void ScheduleBackgroundRunning(); - /** * ScheduleTerminate, Notify application process exit safely. * @@ -376,6 +402,22 @@ public: bool IsTerminating(); + bool IsKeepAliveApp() const; + + // Please use with caution, it may affect the ability to start. + void SetKeepAliveAppState(); + + std::list> GetAllModuleRecord() const; + + std::map>> &GetModules(); + + const std::list> GetAppInfoList(); + + void SetRestartResidentProcCount(int count); + void DecRestartResidentProcCount(); + int GetRestartResidentProcCount() const; + bool CanRestartResidentProc(); + /** * Notify observers when state change. * @@ -384,73 +426,67 @@ public: */ void StateChangedNotifyObserver(const std::shared_ptr &ability, int32_t state, bool isAbility); - bool IsKeepAliveApp() const; - - // Please use with caution, it may affect the ability to start. - void SetKeepAliveAppState(); - - bool CanRestartResidentProc(); void insertAbilityStageInfo(std::vector moduleInfos); private: - // drive application state changes when ability state changes. /** - * OnAbilityStateChanged, Call ability state change. + * SearchTheModuleInfoNeedToUpdated, Get an uninitialized abilitystage data. * - * @param ability, the ability info. - * @param state, the ability state. + * @return If an uninitialized data is found return true,Otherwise return false. + */ + bool GetTheModuleInfoNeedToUpdated(const std::string bundleName, HapModuleInfo &info); + + // drive application state changes when ability state changes. + /** + * ScheduleForegroundRunning, Notify application to switch to foreground. * * @return */ - void OnAbilityStateChanged(const std::shared_ptr &ability, const AbilityState state); + void ScheduleForegroundRunning(); /** - * AbilityForeground, Handling the ability process when switching to the foreground. - * - * @param ability, the ability info. + * ScheduleBackgroundRunning, Notify application to switch to background. * * @return */ - void AbilityForeground(const std::shared_ptr &ability); + void ScheduleBackgroundRunning(); /** - * AbilityBackground, Handling the ability process when switching to the background. + * AbilityForeground, Handling the ability process when switching to the foreground. * * @param ability, the ability info. * * @return */ - void AbilityBackground(const std::shared_ptr &ability); + void AbilityForeground(const std::shared_ptr &ability); /** - * OptimizerAbilityStateChanged, Optimizer processing ability state changes. + * AbilityBackground, Handling the ability process when switching to the background. * * @param ability, the ability info. - * @param state, the ability state. * * @return */ - void OptimizerAbilityStateChanged(const std::shared_ptr &ability, const AbilityState state); + void AbilityBackground(const std::shared_ptr &ability); + // drive application state changes when ability state changes. - void SendEvent(uint32_t msg, int64_t timeOut, const std::shared_ptr &abilityRecord); void SendEvent(uint32_t msg, int64_t timeOut); + void RemoveModuleRecord(const std::shared_ptr &record); + +public: + static int64_t appEventId_; + private: - bool isKeepAliveApp = false; // Only resident processes can be set to true, please choose carefully + bool isKeepAliveApp = false; // Only resident processes can be set to true, please choose carefully ApplicationState curState_ = ApplicationState::APP_STATE_CREATE; // current state of this process std::shared_ptr appInfo_ = nullptr; // the application's info of this process int32_t appRecordId_ = 0; std::string appName_; std::string processName_; // the name of this process - int32_t uid_ = 0; - static int64_t appEventId_; int64_t eventId_ = 0; - // List of abilities running in the process - std::map, std::shared_ptr> abilities_; - std::map, std::shared_ptr> terminateAbilitys_; - std::map> abilityStage_; std::list> foregroundingAbilityTokens_; std::weak_ptr appMgrServiceInner_; sptr appDeathRecipient_ = nullptr; @@ -458,6 +494,16 @@ private: std::shared_ptr appLifeCycleDeal_ = nullptr; std::shared_ptr eventHandler_ = nullptr; bool isTerminating = false; + std::string signCode_; // the sign of this hap + std::string jointUserId_; + std::map> appInfos_; + std::map>> hapModules_; + int32_t mainUid_; + std::string mainBundleName_; + bool isLauncherApp_; + bool isClonedApp_; + std::string mainAppName_; + int restartResidentProcCount_ = RESTART_RESIDENT_PROCESS_MAX_TIMES; int restartCount_ = 15; }; } // namespace AppExecFwk diff --git a/services/appmgr/include/module_running_record.h b/services/appmgr/include/module_running_record.h new file mode 100644 index 0000000000000000000000000000000000000000..961a218022fa9e6a8d9460d5d9bcb8b9084b4d1d --- /dev/null +++ b/services/appmgr/include/module_running_record.h @@ -0,0 +1,206 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FOUNDATION_APPEXECFWK_SERVICES_APPMGR_INCLUDE_MODULE_RUNNING_RECORD_H +#define FOUNDATION_APPEXECFWK_SERVICES_APPMGR_INCLUDE_MODULE_RUNNING_RECORD_H + +#include +#include +#include +#include +#include "iremote_object.h" + +#include "ability_info.h" +#include "application_info.h" +#include "ability_running_record.h" +#include "app_mgr_constants.h" +#include "app_lifecycle_deal.h" +#include "app_mgr_service_event_handler.h" + +namespace OHOS { +namespace AppExecFwk { + +enum class ModuleRecordState { + UNKNOWN_STATE, + INITIALIZED_STATE, + RUNNING_STATE, +}; + +class AppMgrServiceInner; +class ModuleRunningRecord { +public: + ModuleRunningRecord( + const std::shared_ptr &info, const std::shared_ptr &eventHandler); + virtual ~ModuleRunningRecord(); + + /** + * @brief Obtains module moduleName. + * + * @return Returns module moduleName. + */ + const std::string &GetModuleName() const; + + /** + * @param name, the module mainability name. + * + * @return + */ + void GetMainAbilityName(const std::string &name); + + void Init(const HapModuleInfo &info); + + const HapModuleInfo GetModuleInfo(); + + /** + * GetAbilityRunningRecordByToken, Obtaining the ability record through token. + * + * @param token, the unique identification to the ability. + * + * @return + */ + std::shared_ptr GetAbilityRunningRecordByToken(const sptr &token) const; + + // Add new ability instance to current running abilities list managed by this process + /** + * AddAbility, Add new ability instance to current running abilities list managed by this process. + * + * @param token, the unique identification to the ability. + * @param abilityInfo, the ability info. + * + * @return the ability record. + */ + std::shared_ptr AddAbility( + const sptr &token, const std::shared_ptr &abilityInfo); + + bool IsLastAbilityRecord(const sptr &token); + + // Get abilities_ for this process + /** + * @brief Obtains the abilitys info for the application record. + * + * @return Returns the abilitys info for the application record. + */ + const std::map, std::shared_ptr> &GetAbilities() const; + + std::shared_ptr GetAbilityByTerminateLists(const sptr &token) const; + + // Clear(remove) the specified ability record from the list + + /** + * ClearAbility, Clear ability record by record info. + * + * @param record, the ability record. + * + * @return + */ + void ClearAbility(const std::shared_ptr &record); + // It can only used in SINGLETON mode. + /** + * GetAbilityRunningRecord, Get ability record by the ability Name. + * + * @param abilityName, the ability name. + * + * @return the ability record. + */ + std::shared_ptr GetAbilityRunningRecord(const std::string &abilityName) const; + + std::shared_ptr GetAbilityRunningRecord(const int64_t eventId) const; + + /** + * LaunchAbility, Notify application to launch ability. + * + * @param ability, the ability record. + * + * @return + */ + void LaunchAbility(const std::shared_ptr &ability); + + /** + * LaunchPendingAbilities, Launch Pending Abilities. + * + * @return + */ + void LaunchPendingAbilities(); + + /** + * TerminateAbility, terminate the token ability. + * + * @param token, he unique identification to terminate the ability. + * + * @return + */ + void TerminateAbility(const sptr &token, const bool isForce); + + /** + * AbilityTerminated, terminate the ability. + * + * @param token, the unique identification to terminated the ability. + * + * @return + */ + void AbilityTerminated(const sptr &token); + + /** + * @brief Setting application service internal handler instance. + * + * @param serviceInner, application service internal handler instance. + */ + void SetAppMgrServiceInner(const std::weak_ptr &inner); + + // drive application state changes when ability state changes. + /** + * OnAbilityStateChanged, Call ability state change. + * + * @param ability, the ability info. + * @param state, the ability state. + * + * @return + */ + void OnAbilityStateChanged(const std::shared_ptr &ability, const AbilityState state); + + ModuleRecordState GetModuleRecordState(); + + void GetHapModuleInfo(HapModuleInfo &info); + + void SetApplicationClient(std::shared_ptr &appLifeCycleDeal); + + const std::shared_ptr GetAppInfo(); + +private: + /** + * OptimizerAbilityStateChanged, Optimizer processing ability state changes. + * + * @param ability, the ability info. + * @param state, the ability state. + * + * @return + */ + void OptimizerAbilityStateChanged(const std::shared_ptr &ability, const AbilityState state); + + void SendEvent(uint32_t msg, int64_t timeOut, const std::shared_ptr &abilityRecord); + +private: + std::map, std::shared_ptr> abilities_; + std::map, std::shared_ptr> terminateAbilitys_; + std::weak_ptr appMgrServiceInner_; + std::shared_ptr appLifeCycleDeal_; + std::shared_ptr appInfo_; // the application's info + std::shared_ptr eventHandler_; + HapModuleInfo owenInfo_; + ModuleRecordState owenState_ = ModuleRecordState::UNKNOWN_STATE; +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif // FOUNDATION_APPEXECFWK_SERVICES_APPMGR_INCLUDE_MODULE_RUNNING_RECORD_H diff --git a/services/appmgr/src/ams_mgr_scheduler.cpp b/services/appmgr/src/ams_mgr_scheduler.cpp index 9f6c1e5c809ba39dab1bff2877f2271d4bc51488..f2c026ea9b73fce582d9d09854e48680b4dbafb6 100644 --- a/services/appmgr/src/ams_mgr_scheduler.cpp +++ b/services/appmgr/src/ams_mgr_scheduler.cpp @@ -122,9 +122,13 @@ void AmsMgrScheduler::AbilityBehaviorAnalysis(const sptr &token, if (!IsReady()) { return; } - std::function abilityBehaviorAnalysisFunc = - std::bind(&AppMgrServiceInner::AbilityBehaviorAnalysis, amsMgrServiceInner_, token, preToken, visibility, - perceptibility, connectionState); + std::function abilityBehaviorAnalysisFunc = std::bind(&AppMgrServiceInner::AbilityBehaviorAnalysis, + amsMgrServiceInner_, + token, + preToken, + visibility, + perceptibility, + connectionState); amsHandler_->PostTask(abilityBehaviorAnalysisFunc, TASK_ABILITY_BEHAVIOR_ANALYSIS); } @@ -146,7 +150,6 @@ void AmsMgrScheduler::AbilityAttachTimeOut(const sptr &token) } auto task = [=]() { amsMgrServiceInner_->HandleAbilityAttachTimeOut(token); }; amsHandler_->PostTask(task); - APP_LOGI("AmsMgrScheduler AttachTimeOut end"); } void AmsMgrScheduler::PrepareTerminate(const sptr &token) @@ -157,7 +160,6 @@ void AmsMgrScheduler::PrepareTerminate(const sptr &token) } auto task = [=]() { amsMgrServiceInner_->PrepareTerminate(token); }; amsHandler_->PostTask(task); - APP_LOGI("AmsMgrScheduler PrepareTerminate end"); } int32_t AmsMgrScheduler::KillApplication(const std::string &bundleName) diff --git a/services/appmgr/src/app_lifecycle_deal.cpp b/services/appmgr/src/app_lifecycle_deal.cpp index 578114e0666c2238a0e1dca7a807cc59dc4a67b9..91c5b639925bf015e72f04762b8270f9cee750c0 100644 --- a/services/appmgr/src/app_lifecycle_deal.cpp +++ b/services/appmgr/src/app_lifecycle_deal.cpp @@ -32,11 +32,14 @@ void AppLifeCycleDeal::LaunchApplication(const AppLaunchData &launchData_) } } -void AppLifeCycleDeal::AddAbilityStageInfo(const AppResidentProcessInfo &residentProcessInfo) +void AppLifeCycleDeal::AddAbilityStageInfo(const HapModuleInfo &abilityStage) { - if (appThread_) { - appThread_->ScheduleAbilityStageInfo(residentProcessInfo); + if (!appThread_) { + APP_LOGE("appThread_ is nullptr"); + return; } + + appThread_->ScheduleAbilityStageInfo(abilityStage); } void AppLifeCycleDeal::LaunchAbility(const std::shared_ptr &ability) @@ -48,51 +51,71 @@ void AppLifeCycleDeal::LaunchAbility(const std::shared_ptr void AppLifeCycleDeal::ScheduleTerminate() { - if (appThread_) { - appThread_->ScheduleTerminateApplication(); + if (!appThread_) { + APP_LOGE("appThread_ is nullptr"); + return; } + + appThread_->ScheduleTerminateApplication(); } void AppLifeCycleDeal::ScheduleForegroundRunning() { - if (appThread_) { - appThread_->ScheduleForegroundApplication(); + if (!appThread_) { + APP_LOGE("appThread_ is nullptr"); + return; } + + appThread_->ScheduleForegroundApplication(); } void AppLifeCycleDeal::ScheduleBackgroundRunning() { - if (appThread_) { - appThread_->ScheduleBackgroundApplication(); + if (!appThread_) { + APP_LOGE("appThread_ is nullptr"); + return; } + + appThread_->ScheduleBackgroundApplication(); } void AppLifeCycleDeal::ScheduleTrimMemory(int32_t timeLevel) { - if (appThread_) { - appThread_->ScheduleShrinkMemory(timeLevel); + if (!appThread_) { + APP_LOGE("appThread_ is nullptr"); + return; } + + appThread_->ScheduleShrinkMemory(timeLevel); } void AppLifeCycleDeal::LowMemoryWarning() { - if (appThread_) { - appThread_->ScheduleLowMemory(); + if (!appThread_) { + APP_LOGE("appThread_ is nullptr"); + return; } + + appThread_->ScheduleLowMemory(); } void AppLifeCycleDeal::ScheduleCleanAbility(const sptr &token) { - if (appThread_) { - appThread_->ScheduleCleanAbility(token); + if (!appThread_) { + APP_LOGE("appThread_ is nullptr"); + return; } + appThread_->ScheduleCleanAbility(token); } void AppLifeCycleDeal::ScheduleProcessSecurityExit() { - if (appThread_) { - appThread_->ScheduleProcessSecurityExit(); + if (!appThread_) { + APP_LOGE("appThread_ is nullptr"); + return; } + + appThread_->ScheduleProcessSecurityExit(); } void AppLifeCycleDeal::SetApplicationClient(const sptr &thread) diff --git a/services/appmgr/src/app_mgr_service.cpp b/services/appmgr/src/app_mgr_service.cpp index b25333c54f69e1809ce021657c02141be9ab9e44..4c79e2725c7c5f4c48e22a988d784f88e3f9718e 100755 --- a/services/appmgr/src/app_mgr_service.cpp +++ b/services/appmgr/src/app_mgr_service.cpp @@ -318,7 +318,7 @@ void AppMgrService::GetSystemMemoryAttr(SystemMemoryAttr &memoryInfo, std::strin APP_LOGE("%{public}s, memThreshold = %{public}d", __func__, EXPERIENCE_MEM_THRESHOLD); } else { memThreshold = memJson.at("memorythreshold").get(); - APP_LOGI("%{public}s, memThreshold = %{public}d", __func__, memThreshold); + APP_LOGI("memThreshold = %{public}d", memThreshold); } } diff --git a/services/appmgr/src/app_mgr_service_event_handler.cpp b/services/appmgr/src/app_mgr_service_event_handler.cpp index 2953bb75f300ed65c7daa33cb8c4958f59675eb4..a341764f5143c88ce3f07627cf3594256717cb53 100644 --- a/services/appmgr/src/app_mgr_service_event_handler.cpp +++ b/services/appmgr/src/app_mgr_service_event_handler.cpp @@ -41,7 +41,7 @@ void AMSEventHandler::ProcessEvent(const InnerEvent::Pointer &event) auto appManager = appMgr_.lock(); if (!appManager) { - APP_LOGE("%{public}s, app manager is nullptr", __func__); + APP_LOGE("app manager is nullptr"); return; } appManager->HandleTimeOut(event); diff --git a/services/appmgr/src/app_mgr_service_inner.cpp b/services/appmgr/src/app_mgr_service_inner.cpp index 69d1ba26f9d489c2a63d9f4521c58d4bab321ac4..8c20863423fbf32ec0cee2a413a45d449cbf49fa 100644 --- a/services/appmgr/src/app_mgr_service_inner.cpp +++ b/services/appmgr/src/app_mgr_service_inner.cpp @@ -74,49 +74,107 @@ void AppMgrServiceInner::LoadAbility(const sptr &token, const spt const std::shared_ptr &abilityInfo, const std::shared_ptr &appInfo) { BYTRACE(BYTRACE_TAG_APP); - if (!token || !abilityInfo || !appInfo) { - APP_LOGE("param error"); + if (!CheckLoadabilityConditions(token, abilityInfo, appInfo)) { return; } - if (abilityInfo->name.empty() || appInfo->name.empty()) { - APP_LOGE("error abilityInfo or appInfo"); + + if (!appRunningManager_) { + APP_LOGE("appRunningManager_ is nullptr"); return; } - if (abilityInfo->applicationName != appInfo->name) { - APP_LOGE("abilityInfo and appInfo have different appName, don't load for it"); + + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + if (!GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)) { return; } - auto processName = abilityInfo->process.empty() ? appInfo->bundleName : abilityInfo->process; + std::string processName; + MakeProcessName(processName, abilityInfo, appInfo); APP_LOGI("processName = [%{public}s]", processName.c_str()); - auto appRecord = GetAppRunningRecordByProcessName(appInfo->name, processName, appInfo->uid); + auto appRecord = + appRunningManager_->CheckAppRunningRecordIsExist(appInfo->name, processName, appInfo->uid, bundleInfo); if (!appRecord) { - RecordQueryResult result; - int32_t defaultUid = 0; - appRecord = GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, processName, defaultUid, result); - if (FAILED(result.error)) { - APP_LOGE("create appRunningRecord failed"); + appRecord = + CreateAppRunningRecord(token, preToken, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo); + if (!appRecord) { + APP_LOGI("appRecord is nullptr"); return; } - appRecord->SetEventHandler(eventHandler_); - if (preToken != nullptr) { - auto abilityRecord = appRecord->GetAbilityRunningRecordByToken(token); - abilityRecord->SetPreToken(preToken); - } - APP_LOGI("LoadAbility StartProcess appname [%{public}s] | bundename [%{public}s]", appRecord->GetName().c_str(), - appRecord->GetBundleName().c_str()); - StartProcess(abilityInfo->applicationName, processName, appRecord, abilityInfo->applicationInfo.uid); + StartProcess(abilityInfo->applicationName, + processName, + appRecord, + abilityInfo->applicationInfo.uid, + abilityInfo->applicationInfo.bundleName); } else { - APP_LOGI("LoadAbility StartAbility appname [%{public}s] | bundename [%{public}s]", appRecord->GetName().c_str(), - appRecord->GetBundleName().c_str()); - StartAbility(token, preToken, abilityInfo, appRecord); + StartAbility(token, preToken, abilityInfo, appRecord, hapModuleInfo); } PerfProfile::GetInstance().SetAbilityLoadEndTime(GetTickCount()); PerfProfile::GetInstance().Dump(); PerfProfile::GetInstance().Reset(); } +bool AppMgrServiceInner::CheckLoadabilityConditions(const sptr &token, + const std::shared_ptr &abilityInfo, const std::shared_ptr &appInfo) +{ + if (!token || !abilityInfo || !appInfo) { + APP_LOGE("param error"); + return false; + } + if (abilityInfo->name.empty() || appInfo->name.empty()) { + APP_LOGE("error abilityInfo or appInfo"); + return false; + } + if (abilityInfo->applicationName != appInfo->name) { + APP_LOGE("abilityInfo and appInfo have different appName, don't load for it"); + return false; + } + + return true; +} + +void AppMgrServiceInner::MakeProcessName(std::string &processName, const std::shared_ptr &abilityInfo, + const std::shared_ptr &appInfo) +{ + if (!abilityInfo || !appInfo) { + return; + } + if (!abilityInfo->process.empty()) { + processName = abilityInfo->process; + return; + } + if (!appInfo->process.empty()) { + processName = appInfo->process; + return; + } + processName = appInfo->bundleName; +} + +bool AppMgrServiceInner::GetBundleAndHapInfo(const AbilityInfo &abilityInfo, + const std::shared_ptr &appInfo, BundleInfo &bundleInfo, HapModuleInfo &hapModuleInfo) +{ + APP_LOGI("AppMgrServiceInner GetBundleAndHapInfo start!"); + auto bundleMgr_ = remoteClientManager_->GetBundleManager(); + if (bundleMgr_ == nullptr) { + APP_LOGE("GetBundleManager fail"); + return false; + } + + bool bundleMgrResult = bundleMgr_->GetBundleInfo(appInfo->bundleName, BundleFlag::GET_BUNDLE_DEFAULT, bundleInfo); + if (!bundleMgrResult) { + APP_LOGE("GetBundleInfo is fail"); + return false; + } + bundleMgrResult = bundleMgr_->GetHapModuleInfo(abilityInfo, hapModuleInfo); + if (!bundleMgrResult) { + APP_LOGE("GetHapModuleInfo is fail"); + return false; + } + + return true; +} + void AppMgrServiceInner::AttachApplication(const pid_t pid, const sptr &app) { BYTRACE(BYTRACE_TAG_APP); @@ -160,7 +218,7 @@ void AppMgrServiceInner::LaunchApplication(const std::shared_ptrIsKeepAliveApp()) { appRecord->AddAbilityStage(); - return ; + return; } appRecord->LaunchPendingAbilities(); } @@ -261,17 +319,11 @@ int32_t AppMgrServiceInner::KillApplication(const std::string &bundleName) return ERR_NO_INIT; } - // All means can not kill the resident process - auto appRecord = appRunningManager_->GetAppRunningRecordByBundleName(bundleName); - if (appRecord && appRecord->IsKeepAliveApp()) { - return ERR_INVALID_VALUE; - } - int result = ERR_OK; int64_t startTime = SystemTimeMillis(); std::list pids; - if (!appRunningManager_->GetPidsByBundleName(bundleName, pids)) { + if (!appRunningManager_->ProcessExitByBundleName(bundleName, pids)) { APP_LOGI("The process corresponding to the package name did not start"); return result; } @@ -310,7 +362,7 @@ int32_t AppMgrServiceInner::KillApplicationByUid(const std::string &bundleName, return ERR_NO_INIT; } APP_LOGI("uid value is %{public}d", uid); - if (!appRunningManager_->GetPidsByBundleNameByUid(bundleName, uid, pids)) { + if (!appRunningManager_->ProcessExitByBundleNameAndUid(bundleName, uid, pids)) { APP_LOGI("The process corresponding to the package name did not start"); return result; } @@ -349,7 +401,7 @@ int32_t AppMgrServiceInner::KillApplicationByUserId(const std::string &bundleNam APP_LOGI("userId value is %{public}d", userId); int uid = bundleMgr_->GetUidByBundleName(bundleName, userId); APP_LOGI("uid value is %{public}d", uid); - if (!appRunningManager_->GetPidsByBundleNameByUid(bundleName, uid, pids)) { + if (!appRunningManager_->ProcessExitByBundleNameAndUid(bundleName, uid, pids)) { APP_LOGI("The process corresponding to the package name did not start"); return result; } @@ -373,8 +425,8 @@ void AppMgrServiceInner::ClearUpApplicationData(const std::string &bundleName, i ClearUpApplicationDataByUserId(bundleName, callerUid, callerPid, Constants::DEFAULT_USERID); } -void AppMgrServiceInner::ClearUpApplicationDataByUserId(const std::string &bundleName, - int32_t callerUid, pid_t callerPid, const int userId) +void AppMgrServiceInner::ClearUpApplicationDataByUserId( + const std::string &bundleName, int32_t callerUid, pid_t callerPid, const int userId) { if (callerPid <= 0) { APP_LOGE("invalid callerPid:%{public}d", callerPid); @@ -436,7 +488,7 @@ int32_t AppMgrServiceInner::GetAllRunningProcesses(std::vectorGetAppRunningRecordMap()) { const auto &appRecord = item.second; RunningProcessInfo runningProcessInfo; - runningProcessInfo.processName_ = appRecord->GetName(); + runningProcessInfo.processName_ = appRecord->GetProcessName(); runningProcessInfo.pid_ = appRecord->GetPriorityObject()->GetPid(); runningProcessInfo.uid_ = appRecord->GetUid(); runningProcessInfo.state_ = static_cast(appRecord->GetState()); @@ -522,34 +574,39 @@ int64_t AppMgrServiceInner::SystemTimeMillis() return (int64_t)((t.tv_sec) * NANOSECONDS + t.tv_nsec) / MICROSECONDS; } -std::shared_ptr AppMgrServiceInner::GetAppRunningRecordByAppName(const std::string &appName) const -{ - return appRunningManager_->GetAppRunningRecordByAppName(appName); -} - -std::shared_ptr AppMgrServiceInner::GetAppRunningRecordByProcessName( - const std::string &appName, const std::string &processName, const int uid) const -{ - return appRunningManager_->GetAppRunningRecordByProcessName(appName, processName, uid); -} - std::shared_ptr AppMgrServiceInner::GetAppRunningRecordByPid(const pid_t pid) const { return appRunningManager_->GetAppRunningRecordByPid(pid); } -std::shared_ptr AppMgrServiceInner::GetOrCreateAppRunningRecord(const sptr &token, - const std::shared_ptr &appInfo, const std::shared_ptr &abilityInfo, - const std::string &processName, const int32_t uid, RecordQueryResult &result) +std::shared_ptr AppMgrServiceInner::CreateAppRunningRecord(const sptr &token, + const sptr &preToken, const std::shared_ptr &appInfo, + const std::shared_ptr &abilityInfo, const std::string &processName, const BundleInfo &bundleInfo, + const HapModuleInfo &hapModuleInfo) { BYTRACE(BYTRACE_TAG_APP); - return appRunningManager_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, processName, uid, result); -} + if (!appRunningManager_) { + return nullptr; + } + auto appRecord = appRunningManager_->CreateAppRunningRecord(appInfo, processName, bundleInfo); + if (!appRecord) { + return nullptr; + } + // TODO 这里有需要在返回 result 吧，估计这个没什么用了。 + // result.appRecordId = record->GetRecordId(); + // auto abilityRecord = record->GetAbilityRunningRecordByToken(token); + // result.abilityExists = !!abilityRecord; + appRecord->SetEventHandler(eventHandler_); + appRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); -std::shared_ptr AppMgrServiceInner::GetOrCreateAppRunningRecord( - const ApplicationInfo &appInfo, bool &appExist) -{ - return appRunningManager_->GetOrCreateAppRunningRecord(appInfo, appExist); + if (preToken) { + auto abilityRecord = appRecord->GetAbilityRunningRecordByToken(token); + if (abilityRecord) { + abilityRecord->SetPreToken(preToken); + } + } + + return appRecord; } void AppMgrServiceInner::TerminateAbility(const sptr &token) @@ -573,7 +630,6 @@ void AppMgrServiceInner::TerminateAbility(const sptr &token) if (appRunningManager_) { appRunningManager_->TerminateAbility(token); } - APP_LOGD("AppMgrServiceInner::TerminateAbility end"); } void AppMgrServiceInner::UpdateAbilityState(const sptr &token, const AbilityState state) @@ -607,7 +663,6 @@ void AppMgrServiceInner::UpdateAbilityState(const sptr &token, co } appRecord->UpdateAbilityState(token, state); - APP_LOGD("end"); } void AppMgrServiceInner::UpdateExtensionState(const sptr &token, const ExtensionState state) @@ -762,7 +817,8 @@ void AppMgrServiceInner::KillProcessByAbilityToken(const sptr &to } void AppMgrServiceInner::StartAbility(const sptr &token, const sptr &preToken, - const std::shared_ptr &abilityInfo, const std::shared_ptr &appRecord) + const std::shared_ptr &abilityInfo, const std::shared_ptr &appRecord, + const HapModuleInfo &hapModuleInfo) { BYTRACE(BYTRACE_TAG_APP); APP_LOGI("already create appRecord, just start ability"); @@ -792,7 +848,15 @@ void AppMgrServiceInner::StartAbility(const sptr &token, const sp OptimizerAppStateChanged(appRecord, ApplicationState::APP_STATE_SUSPENDED); } - ability = appRecord->AddAbility(token, abilityInfo); + auto appInfo = std::make_shared(abilityInfo->applicationInfo); + appRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + auto moduleRecord = appRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + if (!moduleRecord) { + APP_LOGE("add moduleRecord failed"); + return; + } + + ability = moduleRecord->GetAbilityRunningRecordByToken(token); if (!ability) { APP_LOGE("add ability failed"); return; @@ -822,10 +886,7 @@ void AppMgrServiceInner::UnsuspendApplication(const std::shared_ptrGetName().c_str(), - appRecord->GetUid()); + APP_LOGI("app name is %{public}s , Uid is %{public}d", appRecord->GetName().c_str(), appRecord->GetUid()); // Resume subscription via UID DelayedSingleton::GetInstance()->Unfreeze(appRecord->GetUid()); } @@ -836,10 +897,7 @@ void AppMgrServiceInner::SuspendApplication(const std::shared_ptrGetName().c_str(), - appRecord->GetUid()); + APP_LOGD("app name is %{public}s , Uid is %{public}d", appRecord->GetName().c_str(), appRecord->GetUid()); // Temporary unsubscribe via UID appRecord->SetState(ApplicationState::APP_STATE_SUSPENDED); OptimizerAppStateChanged(appRecord, ApplicationState::APP_STATE_BACKGROUND); @@ -910,7 +968,6 @@ void AppMgrServiceInner::AbilityTerminated(const sptr &token) } appRecord->AbilityTerminated(token); - APP_LOGD("end"); } std::shared_ptr AppMgrServiceInner::GetAppRunningRecordByAppRecordId(const int32_t recordId) const @@ -948,18 +1005,22 @@ void AppMgrServiceInner::OnAppStateChanged( } } } - APP_LOGD("end"); } AppProcessData AppMgrServiceInner::WrapAppProcessData(const std::shared_ptr &appRecord, const ApplicationState state) { AppProcessData processData; - processData.appName = appRecord->GetName(); + auto appInfoList = appRecord->GetAppInfoList(); + for (const auto &list : appInfoList) { + AppData data; + data.appName = list->name; + data.uid = list->uid; + processData.appDatas.push_back(data); + } processData.processName = appRecord->GetProcessName(); processData.pid = appRecord->GetPriorityObject()->GetPid(); processData.appState = state; - processData.uid = appRecord->GetUid(); return processData; } @@ -995,7 +1056,6 @@ void AppMgrServiceInner::OnAbilityStateChanged( callback->OnAbilityRequestDone(ability->GetToken(), state); } } - APP_LOGD("end"); } void AppMgrServiceInner::StateChangedNotifyObserver(const AbilityStateData abilityStateData, bool isAbility) @@ -1054,7 +1114,7 @@ void AppMgrServiceInner::OnProcessDied(const std::shared_ptr & } void AppMgrServiceInner::StartProcess(const std::string &appName, const std::string &processName, - const std::shared_ptr &appRecord, const int uid) + const std::shared_ptr &appRecord, const int uid, const std::string &bundleName) { BYTRACE(BYTRACE_TAG_APP); if (!remoteClientManager_->GetSpawnClient() || !appRecord) { @@ -1076,7 +1136,7 @@ void AppMgrServiceInner::StartProcess(const std::string &appName, const std::str APP_LOGE("GetBundleInfo is fail"); return; } - std::string bundleName = appRecord->GetBundleName(); + auto isExist = [&bundleName, &uid](const AppExecFwk::BundleInfo &bundleInfo) { return bundleInfo.name == bundleName && bundleInfo.uid == uid; }; @@ -1088,7 +1148,7 @@ void AppMgrServiceInner::StartProcess(const std::string &appName, const std::str startMsg.uid = (*bundleInfoIter).uid; startMsg.gid = (*bundleInfoIter).gid; - bundleMgrResult = bundleMgr_->GetBundleGidsByUid(appRecord->GetBundleName(), uid, startMsg.gids); + bundleMgrResult = bundleMgr_->GetBundleGidsByUid(bundleName, uid, startMsg.gids); if (!bundleMgrResult) { APP_LOGE("GetBundleGids is fail"); return; @@ -1178,6 +1238,7 @@ void AppMgrServiceInner::ClearRecentAppList() void AppMgrServiceInner::OnRemoteDied(const wptr &remote) { + APP_LOGE("On remote died."); auto appRecord = appRunningManager_->OnRemoteDied(remote); if (appRecord) { for (const auto &item : appRecord->GetAbilities()) { @@ -1192,17 +1253,18 @@ void AppMgrServiceInner::OnRemoteDied(const wptr &remote) } if (appRecord && appRecord->IsKeepAliveApp()) { - std::string bundleName = appRecord->GetBundleName(); - APP_LOGI("[%{public}s] will be restartProcss!", bundleName.c_str()); - auto restartProcss = [appRecord, innerService = shared_from_this()]() { - innerService->RestartResidentProcess(appRecord); - }; - - if (!eventHandler_) { - APP_LOGE("eventHandler_ is nullptr"); - return; + appRecord->DecRestartResidentProcCount(); + if (appRecord->CanRestartResidentProc()) { + auto restartProcss = [appRecord, innerService = shared_from_this()]() { + innerService->RestartResidentProcess(appRecord); + }; + + if (!eventHandler_) { + APP_LOGE("eventHandler_ is nullptr"); + return; + } + eventHandler_->PostTask(restartProcss, "RestartResidentProcess"); } - eventHandler_->PostTask(restartProcss, "RestartResidentProcess"); } } @@ -1357,7 +1419,7 @@ void AppMgrServiceInner::GetAppFreezingTime(int &time) void AppMgrServiceInner::HandleTimeOut(const InnerEvent::Pointer &event) { - APP_LOGI("%{public}s", __func__); + APP_LOGI("handle time out"); if (!appRunningManager_ || event == nullptr) { APP_LOGE("appRunningManager or event is nullptr"); return; @@ -1395,7 +1457,7 @@ void AppMgrServiceInner::HandleAbilityAttachTimeOut(const sptr &t void AppMgrServiceInner::PrepareTerminate(const sptr &token) { - APP_LOGI("%{public}s called", __func__); + APP_LOGI("Prepare terminate"); if (!appRunningManager_) { APP_LOGE("appRunningManager_ is nullptr"); return; @@ -1405,7 +1467,7 @@ void AppMgrServiceInner::PrepareTerminate(const sptr &token) void AppMgrServiceInner::HandleTerminateApplicationTimeOut(const int64_t eventId) { - APP_LOGI("%{public}s called", __func__); + APP_LOGI("handle terminate application time out"); if (!appRunningManager_) { APP_LOGE("appRunningManager_ is nullptr"); return; @@ -1434,15 +1496,15 @@ void AppMgrServiceInner::HandleTerminateApplicationTimeOut(const int64_t eventId void AppMgrServiceInner::HandleAddAbilityStageTimeOut(const int64_t eventId) { - APP_LOGI("%{public}s called add ability stage info time out!", __func__); + APP_LOGI("called add ability stage info time out!"); } int AppMgrServiceInner::CompelVerifyPermission(const std::string &permission, int pid, int uid, std::string &message) { - APP_LOGI("%{public}s called", __func__); + APP_LOGI("compel verify permission"); message = ENUM_TO_STRING(PERMISSION_NOT_GRANTED); if (!remoteClientManager_) { - APP_LOGE("%{public}s remoteClientManager_ is nullptr", __func__); + APP_LOGE("remoteClientManager_ is nullptr"); return ERR_NO_INIT; } if (permission.empty()) { @@ -1458,7 +1520,7 @@ int AppMgrServiceInner::CompelVerifyPermission(const std::string &permission, in int userId = Constants::DEFAULT_USERID; auto appRecord = GetAppRunningRecordByPid(pid); if (!appRecord) { - APP_LOGE("%{public}s app record is nullptr", __func__); + APP_LOGE("app record is nullptr"); return PERMISSION_NOT_GRANTED; } auto bundleName = appRecord->GetBundleName(); @@ -1467,7 +1529,7 @@ int AppMgrServiceInner::CompelVerifyPermission(const std::string &permission, in } auto bundleMgr = remoteClientManager_->GetBundleManager(); if (bundleMgr == nullptr) { - APP_LOGE("%{public}s GetBundleManager fail", __func__); + APP_LOGE("GetBundleManager fail"); return ERR_NO_INIT; } auto bmsUid = bundleMgr->GetUidByBundleName(bundleName, userId); @@ -1491,7 +1553,7 @@ int AppMgrServiceInner::CompelVerifyPermission(const std::string &permission, in void AppMgrServiceInner::LoadResidentProcess() { if (!CheckRemoteClient()) { - APP_LOGE("%{public}s GetBundleManager fail", __func__); + APP_LOGE("GetBundleManager fail"); return; } @@ -1500,64 +1562,74 @@ void AppMgrServiceInner::LoadResidentProcess() std::vector infos; auto funRet = remoteClientManager_->GetBundleManager()->QueryKeepAliveBundleInfos(infos); if (!funRet) { - APP_LOGE("%{public}s QueryKeepAliveBundleInfos fail!", __func__); + APP_LOGE("QueryKeepAliveBundleInfos fail!"); return; } APP_LOGI("Get KeepAlive BundleInfo Size : [%{public}d]", static_cast(infos.size())); - StartResidentProcess(infos); + StartResidentProcess(infos, -1); } -void AppMgrServiceInner::StartResidentProcess(const std::vector &infos) +void AppMgrServiceInner::StartResidentProcess(const std::vector &infos, int restartCount) { - APP_LOGI("%{public}s", __func__); + APP_LOGI("start resident process"); if (infos.empty()) { - APP_LOGE("%{public}s infos is empty!", __func__); + APP_LOGE("infos is empty!"); return; } - // Later, when distinguishing here, there is a process with ability and time and space. - std::shared_ptr appRecord(nullptr); - auto CheckProcessIsExist = [&appRecord, innerService = shared_from_this()](const BundleInfo &iter) { - bool appExist = false; - appRecord = innerService->GetOrCreateAppRunningRecord(iter.applicationInfo, appExist); - APP_LOGI("CheckProcessIsExist appExist : [%{public}d]", appExist); - return appExist; - }; + if (!appRunningManager_) { + APP_LOGE("appRunningManager_ is nullptr"); + return; + } - for (auto &iter : infos) { - if (!CheckProcessIsExist(iter) && appRecord) { - APP_LOGI("start bundle [%{public}s]", iter.applicationInfo.bundleName.c_str()); - // todo Should it be time-consuming, should it be made asynchronous? - auto processName = iter.applicationInfo.process.empty() ? iter.applicationInfo.bundleName : - iter.applicationInfo.process; - APP_LOGI("processName = [%{public}s]", processName.c_str()); - StartEmptyResidentProcess(iter.applicationInfo.name, processName, appRecord, iter.applicationInfo.uid); - appRecord->insertAbilityStageInfo(iter.hapModuleInfos); + for (auto &bundle : infos) { + auto processName = + bundle.applicationInfo.process.empty() ? bundle.applicationInfo.bundleName : bundle.applicationInfo.process; + APP_LOGI("processName = [%{public}s]", processName.c_str()); + // Inspection records + auto appRecord = appRunningManager_->CheckAppRunningRecordIsExist( + bundle.applicationInfo.name, processName, bundle.applicationInfo.uid, bundle); + if (appRecord) { + APP_LOGI("processName [%{public}s] Already exists ", processName.c_str()); + continue; } + StartEmptyResidentProcess(bundle, processName, restartCount); } } -void AppMgrServiceInner::StartEmptyResidentProcess(const std::string &appName, const std::string &processName, - const std::shared_ptr &appRecord, const int uid) +void AppMgrServiceInner::StartEmptyResidentProcess( + const BundleInfo &info, const std::string &processName, int restartCount) { - APP_LOGI("%{public}s appName [%{public}s] | processName [%{public}s]", - __func__, appName.c_str(), processName.c_str()); + APP_LOGI("start bundle [%{public}s | processName [%{public}s]]", info.name.c_str(), processName.c_str()); + if (!CheckRemoteClient() || !appRunningManager_) { + APP_LOGI("Failed to start resident process!"); + return; + } - if (!CheckRemoteClient()) { + auto appInfo = std::make_shared(info.applicationInfo); + auto appRecord = appRunningManager_->CreateAppRunningRecord(appInfo, processName, info); + if (!appRecord) { + APP_LOGE("start process [%{public}s] failed!", processName.c_str()); return; } - StartProcess(appName, processName, appRecord, uid); + StartProcess(appInfo->name, processName, appRecord, appInfo->uid, appInfo->bundleName); // If it is empty, the startup failed - if (!appRecord || !appRunningManager_) { + if (!appRecord) { APP_LOGE("start process [%{public}s] failed!", processName.c_str()); return; } + appRecord->SetKeepAliveAppState(); + + if (restartCount > 0) { + appRecord->SetRestartResidentProcCount(restartCount); + } + appRecord->SetEventHandler(eventHandler_); - appRunningManager_->InitRestartResidentProcRecord(appRecord->GetProcessName()); + appRecord->AddModules(appInfo, info.hapModuleInfos); APP_LOGI("StartEmptyResidentProcess oK pid : [%{public}d], ", appRecord->GetPriorityObject()->GetPid()); } @@ -1583,24 +1655,19 @@ bool AppMgrServiceInner::CheckRemoteClient() void AppMgrServiceInner::RestartResidentProcess(std::shared_ptr appRecord) { if (!CheckRemoteClient() || !appRecord || !appRunningManager_) { - APP_LOGE("%{public}s failed!", __func__); + APP_LOGE("restart resident process failed!"); return; } - if (!appRunningManager_->CanRestartResidentProcCount(appRecord->GetProcessName())) { - APP_LOGE("%{public}s no restart times!", appRecord->GetProcessName().c_str()); - return ; - } - auto bundleMgr = remoteClientManager_->GetBundleManager(); BundleInfo bundleInfo; if (!bundleMgr->GetBundleInfo(appRecord->GetBundleName(), BundleFlag::GET_BUNDLE_DEFAULT, bundleInfo)) { - APP_LOGE("%{public}s GetBundleInfo fail", __func__); + APP_LOGE("GetBundleInfo fail"); return; } std::vector infos; infos.emplace_back(bundleInfo); - StartResidentProcess(infos); + StartResidentProcess(infos, appRecord->GetRestartResidentProcCount()); } void AppMgrServiceInner::NotifyAppStatus(const std::string &bundleName, const std::string &eventData) diff --git a/services/appmgr/src/app_running_manager.cpp b/services/appmgr/src/app_running_manager.cpp index a91a618fd37eedec3f5ad88f9ae6f1b06899a8a4..004acd74feba970ade0b0744ae475c5daeb82e39 100644 --- a/services/appmgr/src/app_running_manager.cpp +++ b/services/appmgr/src/app_running_manager.cpp @@ -24,112 +24,85 @@ namespace OHOS { namespace AppExecFwk { -namespace { -bool CheckUid(const int32_t uid) -{ - return uid >= 0 && uid < std::numeric_limits::max(); -} - -const int RESTART_RESIDENT_PROCESS_MAX_TIMES = 15; -} // namespace - AppRunningManager::AppRunningManager() {} AppRunningManager::~AppRunningManager() {} -std::shared_ptr AppRunningManager::GetOrCreateAppRunningRecord(const sptr &token, - const std::shared_ptr &appInfo, const std::shared_ptr &abilityInfo, - const std::string &processName, const int32_t uid, RecordQueryResult &result) +std::shared_ptr AppRunningManager::CreateAppRunningRecord( + const std::shared_ptr &appInfo, const std::string &processName, const BundleInfo &bundleInfo) { - APP_LOGI("GetOrCreateAppRunningRecord processName : %{public}s | uid : %{public}d", - processName.c_str(), uid); - std::lock_guard guard(lock_); - result.Reset(); - if (!token || !appInfo || !abilityInfo) { + if (!appInfo) { APP_LOGE("param error"); - result.error = ERR_INVALID_VALUE; - return nullptr; - } - if (!CheckUid(uid)) { - APP_LOGE("uid invalid"); - result.error = ERR_APPEXECFWK_INVALID_UID; return nullptr; } + if (processName.empty()) { APP_LOGE("processName error"); - result.error = ERR_INVALID_VALUE; return nullptr; } - auto record = GetAppRunningRecordByProcessName(appInfo->name, processName, appInfo->uid); - if (!record) { - APP_LOGI("no app record, create"); - auto recordId = AppRecordId::Create(); - record = std::make_shared(appInfo, recordId, processName); - appRunningRecordMap_.emplace(recordId, record); - } else { - result.appExists = true; - } - - result.appRecordId = record->GetRecordId(); - auto abilityRecord = record->GetAbilityRunningRecordByToken(token); - result.abilityExists = !!abilityRecord; - if (!abilityRecord) { - APP_LOGI("no ability record, create"); - abilityRecord = record->AddAbility(token, abilityInfo); - } - return record; -} - -std::shared_ptr AppRunningManager::GetOrCreateAppRunningRecord( - const ApplicationInfo &appInfo, bool &appExist) -{ - if (appInfo.bundleName.empty() || !CheckUid(appInfo.uid)) { - APP_LOGE("processName error"); + auto recordId = AppRecordId::Create(); + auto appRecord = std::make_shared(appInfo, recordId, processName); + if (!appRecord) { return nullptr; } - auto processName = appInfo.process.empty() ? appInfo.bundleName : appInfo.process; - APP_LOGI("processName = [%{public}s]", processName.c_str()); - auto record = GetAppRunningRecordByProcessName(appInfo.name, processName, appInfo.uid); - if (!record) { - APP_LOGI("no app record, create"); - auto recordId = AppRecordId::Create(); - auto app = std::make_shared(appInfo); - APP_LOGI("app is create : [%{public}d]", app != nullptr); - record = std::make_shared(app, recordId, processName); - record->SetUid(appInfo.uid); - appRunningRecordMap_.emplace(recordId, record); - appExist = false; - } else { - appExist = true; - } - return record; -} + std::regex rule("[a-zA-Z.]+[-_#]{1}"); + std::string signCode; + ClipStringContent(rule, bundleInfo.appId, signCode); -std::shared_ptr AppRunningManager::GetAppRunningRecordByAppName(const std::string &appName) -{ - std::lock_guard guard(lock_); - auto iter = std::find_if(appRunningRecordMap_.begin(), appRunningRecordMap_.end(), [&appName](const auto &pair) { - return pair.second->GetName() == appName; - }); - return ((iter == appRunningRecordMap_.end()) ? nullptr : iter->second); + APP_LOGI("Create processName : %{public}s | recordId : %{public}d | signCode : %{public}s", + processName.c_str(), recordId, signCode.c_str()); + appRecord->SetSignCode(signCode); + appRecord->SetJointUserId(bundleInfo.jointUserId); + appRunningRecordMap_.emplace(recordId, appRecord); + return appRecord; } -std::shared_ptr AppRunningManager::GetAppRunningRecordByProcessName( - const std::string &appName, const std::string &processName, const int uid) +std::shared_ptr AppRunningManager::CheckAppRunningRecordIsExist(const std::string &appName, + const std::string &processName, const int uid, const BundleInfo &bundleInfo) { - APP_LOGI("GetAppRunningRecordByProcessName appName : %{public}s | processName : %{public}s | uid : %{public}d", + APP_LOGI("CheckAppRunningRecordIsExist appName : %{public}s | processName : %{public}s | uid : %{public}d", appName.c_str(), processName.c_str(), uid); std::lock_guard guard(lock_); - auto iter = std::find_if( - appRunningRecordMap_.begin(), appRunningRecordMap_.end(), [&appName, &processName, &uid](const auto &pair) { - return ((pair.second->GetName() == appName) && (pair.second->GetProcessName() == processName) && - (pair.second->GetUid() == uid) && !(pair.second->IsTerminating())); - }); - APP_LOGI("find result : %{public}d", iter != appRunningRecordMap_.end()); + + std::regex rule("[a-zA-Z.]+[-_#]{1}"); + std::string signCode; + auto jointUserId = bundleInfo.jointUserId; + APP_LOGI("jointUserId : %{public}s", jointUserId.c_str()); + ClipStringContent(rule, bundleInfo.appId, signCode); + + auto FindSameProcess = [signCode, processName, jointUserId](const auto &pair) { + return ((pair.second->GetSignCode() == signCode) && + (pair.second->GetProcessName() == processName) && + (pair.second->GetJointUserId() == jointUserId) && + !(pair.second->IsTerminating())); + }; + + // If it is not empty, look for whether it can come in the same process + if (jointUserId.empty()) { + for (const auto &item : appRunningRecordMap_) { + const auto &appRecord = item.second; + APP_LOGI("appRecord->GetProcessName() : %{public}s", appRecord->GetProcessName().c_str()); + if (appRecord && appRecord->GetProcessName() == processName && !(appRecord->IsTerminating())) { + auto appInfoList = appRecord->GetAppInfoList(); + APP_LOGI("appInfoList : %{public}zu", appInfoList.size()); + auto isExist = [&appName, &uid](const std::shared_ptr &appInfo) { + APP_LOGI("appInfo->name : %{public}s", appInfo->name.c_str()); + return appInfo->name == appName && appInfo->uid == uid; + }; + auto appInfoIter = std::find_if(appInfoList.begin(), appInfoList.end(), isExist); + if (appInfoIter != appInfoList.end()) { + return appRecord; + } + } + } + return nullptr; + } + + auto iter = std::find_if(appRunningRecordMap_.begin(), appRunningRecordMap_.end(), FindSameProcess); return ((iter == appRunningRecordMap_.end()) ? nullptr : iter->second); } @@ -149,37 +122,51 @@ std::shared_ptr AppRunningManager::GetAppRunningRecordByAbilit for (const auto &item : appRunningRecordMap_) { const auto &appRecord = item.second; if (appRecord && appRecord->GetAbilityRunningRecordByToken(abilityToken)) { + APP_LOGI("appRecord is exit"); return appRecord; } } return nullptr; } -bool AppRunningManager::GetPidsByBundleName(const std::string &bundleName, std::list &pids) +bool AppRunningManager::ProcessExitByBundleName(const std::string &bundleName, std::list &pids) { std::lock_guard guard(lock_); for (const auto &item : appRunningRecordMap_) { const auto &appRecord = item.second; - if (appRecord && appRecord->GetBundleName() == bundleName && appRecord->GetCloneInfo() == false) { + // condition [!appRecord->IsKeepAliveApp()] Is to not kill the resident process. + // Before using this method, consider whether you need. + if (appRecord && !appRecord->IsKeepAliveApp()) { pid_t pid = appRecord->GetPriorityObject()->GetPid(); - if (pid > 0) { + auto appInfoList = appRecord->GetAppInfoList(); + auto isExist = [&bundleName](const std::shared_ptr &appInfo) { + return appInfo->bundleName == bundleName; + }; + auto iter = std::find_if(appInfoList.begin(), appInfoList.end(), isExist); + if (iter != appInfoList.end() && pid > 0) { pids.push_back(pid); appRecord->ScheduleProcessSecurityExit(); } } } - return (pids.empty() ? false : true); + return !pids.empty(); } -bool AppRunningManager::GetPidsByBundleNameByUid(const std::string &bundleName, const int uid, std::list &pids) +bool AppRunningManager::ProcessExitByBundleNameAndUid( + const std::string &bundleName, const int uid, std::list &pids) { std::lock_guard guard(lock_); for (const auto &item : appRunningRecordMap_) { const auto &appRecord = item.second; - if (appRecord && appRecord->GetBundleName() == bundleName && appRecord->GetUid() == uid) { + if (appRecord) { + auto appInfoList = appRecord->GetAppInfoList(); + auto isExist = [&bundleName, &uid](const std::shared_ptr &appInfo) { + return appInfo->bundleName == bundleName && appInfo->uid == uid; + }; + auto iter = std::find_if(appInfoList.begin(), appInfoList.end(), isExist); pid_t pid = appRecord->GetPriorityObject()->GetPid(); - if (pid > 0) { + if (iter != appInfoList.end() && pid > 0) { pids.push_back(pid); appRecord->ScheduleProcessSecurityExit(); } @@ -210,6 +197,7 @@ std::shared_ptr AppRunningManager::OnRemoteDied(const wptrsecond; + appRecord->SetApplicationClient(nullptr); appRunningRecordMap_.erase(iter); if (appRecord) { return appRecord; @@ -238,20 +226,19 @@ void AppRunningManager::ClearAppRunningRecordMap() void AppRunningManager::HandleTerminateTimeOut(int64_t eventId) { - APP_LOGI("%{public}s, called", __func__); + APP_LOGI("Handle terminate timeout."); auto abilityRecord = GetAbilityRunningRecord(eventId); if (!abilityRecord) { - APP_LOGE("%{public}s, abilityRecord is nullptr", __func__); + APP_LOGE("abilityRecord is nullptr."); return; } auto abilityToken = abilityRecord->GetToken(); auto appRecord = GetTerminatingAppRunningRecord(abilityToken); if (!appRecord) { - APP_LOGE("%{public}s, appRecord is nullptr", __func__); + APP_LOGE("appRecord is nullptr."); return; } appRecord->AbilityTerminated(abilityToken); - APP_LOGI("%{public}s, end", __func__); } std::shared_ptr AppRunningManager::GetTerminatingAppRunningRecord( @@ -269,7 +256,7 @@ std::shared_ptr AppRunningManager::GetTerminatingAppRunningRec std::shared_ptr AppRunningManager::GetAbilityRunningRecord(const int64_t eventId) { - APP_LOGI("%{public}s, called", __func__); + APP_LOGI("Get ability running record by eventId."); std::lock_guard guard(lock_); for (auto &item : appRunningRecordMap_) { if (item.second) { @@ -284,7 +271,7 @@ std::shared_ptr AppRunningManager::GetAbilityRunningRecord std::shared_ptr AppRunningManager::GetAppRunningRecord(const int64_t eventId) { - APP_LOGI("%{public}s, called", __func__); + APP_LOGI("Get app running record by eventId."); std::lock_guard guard(lock_); auto iter = std::find_if(appRunningRecordMap_.begin(), appRunningRecordMap_.end(), [&eventId](const auto &pair) { return pair.second->GetEventId() == eventId; @@ -294,15 +281,15 @@ std::shared_ptr AppRunningManager::GetAppRunningRecord(const i void AppRunningManager::HandleAbilityAttachTimeOut(const sptr &token) { - APP_LOGI("%{public}s, called", __func__); + APP_LOGI("Handle ability attach timeOut."); if (token == nullptr) { - APP_LOGE("%{public}s, token is nullptr", __func__); + APP_LOGE("token is nullptr."); return; } auto appRecord = GetAppRunningRecordByAbilityToken(token); if (!appRecord) { - APP_LOGE("%{public}s, appRecord is nullptr", __func__); + APP_LOGE("appRecord is nullptr."); return; } @@ -320,15 +307,15 @@ void AppRunningManager::HandleAbilityAttachTimeOut(const sptr &to void AppRunningManager::PrepareTerminate(const sptr &token) { - APP_LOGI("%{public}s, called", __func__); + APP_LOGI("Prepare terminate."); if (token == nullptr) { - APP_LOGE("%{public}s, token is nullptr", __func__); + APP_LOGE("token is nullptr."); return; } auto appRecord = GetAppRunningRecordByAbilityToken(token); if (!appRecord) { - APP_LOGE("%{public}s, appRecord is nullptr", __func__); + APP_LOGE("appRecord is nullptr."); return; } @@ -339,15 +326,15 @@ void AppRunningManager::PrepareTerminate(const sptr &token) void AppRunningManager::TerminateAbility(const sptr &token) { - APP_LOGI("%{public}s, called", __func__); + APP_LOGI("Terminate ability."); if (!token) { - APP_LOGE("%{public}s, token is nullptr", __func__); + APP_LOGE("token is nullptr."); return; } auto appRecord = GetAppRunningRecordByAbilityToken(token); if (!appRecord) { - APP_LOGE("%{public}s, appRecord is nullptr", __func__); + APP_LOGE("appRecord is nullptr."); return; } @@ -358,49 +345,14 @@ void AppRunningManager::TerminateAbility(const sptr &token) appRecord->TerminateAbility(token, false); } -bool AppRunningManager::CanRestartResidentProcCount(const std::string &processName) -{ - if (processName.empty()) { - APP_LOGE("processName is empty!"); - return false; - } - - auto iter = processRestartRecord_.find(processName); - if (iter != processRestartRecord_.end()) { - if (iter->second > 0) { - APP_LOGI("restart count processName : [%{public}s] | num : [%{public}d]", - processName.c_str(), iter->second); - processRestartRecord_[processName] = --(iter->second); - return true; - } - } - return false; -} - -bool AppRunningManager::InitRestartResidentProcRecord(const std::string &processName) +void AppRunningManager::ClipStringContent(const std::regex &re, const std::string &sorce, std::string &afferCutStr) { - if (processName.empty()) { - APP_LOGE("processName is empty!"); - return false; + std::smatch basket; + if (std::regex_search(sorce, basket, re)) { + APP_LOGI("prefix str: [%{public}s]", basket.prefix().str().c_str()); + APP_LOGI("suffix str: [%{public}s]", basket.suffix().str().c_str()); + afferCutStr = basket.prefix().str() + basket.suffix().str(); } - - // Not counting the number of connection attempts of app spwan, - // the number of restart attempts of a resident process is set to 15 - auto pair = processRestartRecord_.insert(std::make_pair(processName, RESTART_RESIDENT_PROCESS_MAX_TIMES)); - return pair.second; -} - -std::shared_ptr AppRunningManager::GetAppRunningRecordByBundleName(const std::string &bundleName) -{ - APP_LOGI("%{public}s, kill bundle : [%{public}s]", __func__, bundleName.c_str()); - std::lock_guard guard(lock_); - for (const auto &item : appRunningRecordMap_) { - const auto &appRecord = item.second; - if (appRecord && appRecord->GetBundleName() == bundleName) { - return appRecord; - } - } - return nullptr; } void AppRunningManager::GetForegroundApplications(std::vector &list) diff --git a/services/appmgr/src/app_running_record.cpp b/services/appmgr/src/app_running_record.cpp index 55c702c4b44ca8f67ea1d3a54557907959655b46..597413e48fc364dba67b0e67d10169d25c1a4239 100644 --- a/services/appmgr/src/app_running_record.cpp +++ b/services/appmgr/src/app_running_record.cpp @@ -14,8 +14,6 @@ */ #include "app_running_record.h" - -#include "ability_running_record.h" #include "app_log_wrapper.h" #include "app_mgr_service_inner.h" #include "bytrace.h" @@ -25,10 +23,13 @@ namespace AppExecFwk { int64_t AppRunningRecord::appEventId_ = 0; AppRunningRecord::AppRunningRecord( const std::shared_ptr &info, const int32_t recordId, const std::string &processName) - : appInfo_(info), appRecordId_(recordId), processName_(processName) + : appRecordId_(recordId), processName_(processName) { - if (appInfo_) { - appName_ = appInfo_->name; + if (info) { + mainBundleName_ = info->bundleName; + isLauncherApp_ = info->isLauncherApp; + isClonedApp_ = info->isCloned; + mainAppName_ = info->name; } } @@ -40,14 +41,14 @@ void AppRunningRecord::SetApplicationClient(const sptr &thread) appLifeCycleDeal_->SetApplicationClient(thread); } -std::string AppRunningRecord::GetBundleName() const +const std::string &AppRunningRecord::GetBundleName() const { - return appInfo_ ? appInfo_->bundleName : ""; + return mainBundleName_; } bool AppRunningRecord::IsLauncherApp() const { - return appInfo_ ? appInfo_->isLauncherApp : false; + return isLauncherApp_; } int32_t AppRunningRecord::GetRecordId() const @@ -57,12 +58,32 @@ int32_t AppRunningRecord::GetRecordId() const const std::string &AppRunningRecord::GetName() const { - return appName_; + return mainAppName_; } bool AppRunningRecord::GetCloneInfo() const { - return appInfo_->isCloned; + return isClonedApp_; +} + +const std::string &AppRunningRecord::GetSignCode() const +{ + return signCode_; +} + +void AppRunningRecord::SetSignCode(const std::string &signCode) +{ + signCode_ = signCode; +} + +const std::string &AppRunningRecord::GetJointUserId() const +{ + return jointUserId_; +} + +void AppRunningRecord::SetJointUserId(const std::string &jointUserId) +{ + jointUserId_ = jointUserId; } const std::string &AppRunningRecord::GetProcessName() const @@ -72,12 +93,12 @@ const std::string &AppRunningRecord::GetProcessName() const int32_t AppRunningRecord::GetUid() const { - return uid_; + return mainUid_; } void AppRunningRecord::SetUid(const int32_t uid) { - uid_ = uid; + mainUid_ = uid; } ApplicationState AppRunningRecord::GetState() const @@ -94,56 +115,61 @@ void AppRunningRecord::SetState(const ApplicationState state) curState_ = state; } -const std::map, std::shared_ptr> &AppRunningRecord::GetAbilities() const +const std::list> AppRunningRecord::GetAppInfoList() { - return abilities_; + std::list> appInfoList; + for (const auto &item : appInfos_) { + appInfoList.push_back(item.second); + } + return appInfoList; } -sptr AppRunningRecord::GetApplicationClient() const +const std::map, std::shared_ptr> AppRunningRecord::GetAbilities() { - return (appLifeCycleDeal_ ? appLifeCycleDeal_->GetApplicationClient() : nullptr); + std::map, std::shared_ptr> abilitysMap; + auto moduleRecordList = GetAllModuleRecord(); + for (const auto &moduleRecord : moduleRecordList) { + auto abilities = moduleRecord->GetAbilities(); + abilitysMap.insert(abilities.begin(), abilities.end()); + } + return abilitysMap; } -std::shared_ptr AppRunningRecord::AddAbility( - const sptr &token, const std::shared_ptr &abilityInfo) +std::map>> &AppRunningRecord::GetModules() { - if (!token || !abilityInfo) { - APP_LOGE("Param abilityInfo or token is null"); - return nullptr; - } - if (GetAbilityRunningRecordByToken(token)) { - APP_LOGE("AbilityRecord already exists and no need to add"); - return nullptr; - } - auto abilityRecord = std::make_shared(abilityInfo, token); - abilities_.emplace(token, abilityRecord); - return abilityRecord; + return hapModules_; +} + +sptr AppRunningRecord::GetApplicationClient() const +{ + return (appLifeCycleDeal_ ? appLifeCycleDeal_->GetApplicationClient() : nullptr); } std::shared_ptr AppRunningRecord::GetAbilityRunningRecord(const std::string &abilityName) const { - const auto &iter = std::find_if(abilities_.begin(), abilities_.end(), [&abilityName](const auto &pair) { - return pair.second->GetName() == abilityName && !(pair.second->IsTerminating()); - }); - return ((iter == abilities_.end()) ? nullptr : iter->second); + APP_LOGD("Get ability running record by ability name."); + auto moduleRecordList = GetAllModuleRecord(); + for (const auto &moduleRecord : moduleRecordList) { + auto abilityRecord = moduleRecord->GetAbilityRunningRecord(abilityName); + if (abilityRecord) { + return abilityRecord; + } + } + + return nullptr; } std::shared_ptr AppRunningRecord::GetAbilityRunningRecord(const int64_t eventId) const { - APP_LOGI("%{public}s, called", __func__); - const auto &iter = std::find_if(abilities_.begin(), abilities_.end(), [eventId](const auto &pair) { - return pair.second->GetEventId() == eventId; - }); - if (iter != abilities_.end()) { - return iter->second; + APP_LOGI("Get ability running record by eventId."); + auto moduleRecordList = GetAllModuleRecord(); + for (const auto &moduleRecord : moduleRecordList) { + auto abilityRecord = moduleRecord->GetAbilityRunningRecord(eventId); + if (abilityRecord) { + return abilityRecord; + } } - const auto &finder = std::find_if(terminateAbilitys_.begin(), - terminateAbilitys_.end(), - [eventId](const auto &pair) { return pair.second->GetEventId() == eventId; }); - if (finder != terminateAbilitys_.end()) { - return finder->second; - } return nullptr; } @@ -153,11 +179,37 @@ void AppRunningRecord::ClearAbility(const std::shared_ptr APP_LOGE("Param record is null"); return; } - if (!GetAbilityRunningRecordByToken(record->GetToken())) { - APP_LOGE("Param record is not exist"); + + auto moduleRecord = GetModuleRunningRecordByToken(record->GetToken()); + if (!moduleRecord) { + APP_LOGE("moduleRecord is not exit"); return; } - abilities_.erase(record->GetToken()); + + moduleRecord->ClearAbility(record); + + if (moduleRecord->GetAbilities().empty()) { + RemoveModuleRecord(moduleRecord); + } +} + +void AppRunningRecord::RemoveModuleRecord(const std::shared_ptr &moudleRecord) +{ + APP_LOGD("Remove module record."); + + for (auto &item : hapModules_) { + auto iter = std::find_if(item.second.begin(), + item.second.end(), + [&moudleRecord](const std::shared_ptr &record) { return moudleRecord == record; }); + if (iter != item.second.end()) { + iter = item.second.erase(iter); + if (item.second.empty()) { + hapModules_.erase(item.first); + appInfos_.erase(item.first); + } + return; + } + } } void AppRunningRecord::ForceKillApp([[maybe_unused]] const std::string &reason) const @@ -172,35 +224,43 @@ void AppRunningRecord::LaunchApplication() APP_LOGE("appLifeCycleDeal_ is null"); return; } - if (!appInfo_ || !appLifeCycleDeal_->GetApplicationClient()) { - APP_LOGE("appInfo or appThread is null"); + if (!appLifeCycleDeal_->GetApplicationClient()) { + APP_LOGE("appThread is null"); return; } AppLaunchData launchData; - launchData.SetApplicationInfo(*appInfo_); + auto moduleRecords = appInfos_.find(mainBundleName_); + if (moduleRecords != appInfos_.end()) { + launchData.SetApplicationInfo(*(moduleRecords->second)); + } ProcessInfo processInfo(processName_, GetPriorityObject()->GetPid()); launchData.SetProcessInfo(processInfo); launchData.SetRecordId(appRecordId_); - launchData.SetUId(uid_); + launchData.SetUId(mainUid_); + APP_LOGI("ScheduleLaunchApplication app:%{public}s", GetName().c_str()); appLifeCycleDeal_->LaunchApplication(launchData); } void AppRunningRecord::AddAbilityStage() { - AppResidentProcessInfo residentInfo; - residentInfo.isKeepAliveApp_ = true; - auto iter = abilityStage_.find(appRecordId_); - if (iter != abilityStage_.end()) { - residentInfo.abilityStage_ = iter->second; + HapModuleInfo abilityStage; + if (GetTheModuleInfoNeedToUpdated(mainBundleName_, abilityStage)) { + SendEvent(AMSEventHandler::ADD_ABILITY_STAGE_INFO_TIMEOUT_MSG, AMSEventHandler::ADD_ABILITY_STAGE_INFO_TIMEOUT); + APP_LOGI("Current Informed module : [%{public}s]", abilityStage.moduleName.c_str()); + appLifeCycleDeal_->AddAbilityStageInfo(abilityStage); + return; } - SendEvent(AMSEventHandler::ADD_ABILITY_STAGE_INFO_TIMEOUT_MSG, AMSEventHandler::ADD_ABILITY_STAGE_INFO_TIMEOUT); - appLifeCycleDeal_->AddAbilityStageInfo(residentInfo); + + APP_LOGI("The current process[%{public}s] is updated", processName_.c_str()); } void AppRunningRecord::AddAbilityStageDone() { + APP_LOGI("Add ability stage done."); eventHandler_->RemoveEvent(AMSEventHandler::TERMINATE_ABILITY_TIMEOUT_MSG, appRecordId_); + // Should proceed to the next notification + AddAbilityStage(); } void AppRunningRecord::LaunchAbility(const std::shared_ptr &ability) @@ -210,25 +270,17 @@ void AppRunningRecord::LaunchAbility(const std::shared_ptr return; } if (!ability || !ability->GetToken()) { - APP_LOGE("null abilityRecord or abilityToken"); + APP_LOGE("abilityRecord or abilityToken is nullptr."); return; } - const auto &iter = abilities_.find(ability->GetToken()); - if (iter != abilities_.end() && appLifeCycleDeal_->GetApplicationClient()) { - APP_LOGI("ScheduleLaunchAbility ability:%{public}s", ability->GetName().c_str()); - appLifeCycleDeal_->LaunchAbility(ability); - ability->SetState(AbilityState::ABILITY_STATE_READY); - OptimizerAbilityStateChanged(ability, AbilityState::ABILITY_STATE_CREATE); - } -} -void AppRunningRecord::LaunchPendingAbilities() -{ - for (auto item : abilities_) { - if (item.second->GetState() == AbilityState::ABILITY_STATE_CREATE) { - LaunchAbility(item.second); - } + auto moduleRecord = GetModuleRunningRecordByToken(ability->GetToken()); + if (!moduleRecord) { + APP_LOGE("moduleRecord is nullptr"); + return; } + + moduleRecord->LaunchAbility(ability); } void AppRunningRecord::ScheduleTerminate() @@ -239,8 +291,22 @@ void AppRunningRecord::ScheduleTerminate() } } -void AppRunningRecord::ScheduleForegroundRunning() +void AppRunningRecord::LaunchPendingAbilities() { + APP_LOGD("Launch pending abilities."); + + auto moduleRecordList = GetAllModuleRecord(); + if (moduleRecordList.empty()) { + APP_LOGE("moduleRecordList is empty"); + return; + } + for (const auto &moduleRecord : moduleRecordList) { + moduleRecord->SetApplicationClient(appLifeCycleDeal_); + moduleRecord->LaunchPendingAbilities(); + } +} +void AppRunningRecord::ScheduleForegroundRunning(){ + if (appLifeCycleDeal_) { appLifeCycleDeal_->ScheduleForegroundRunning(); } @@ -274,20 +340,80 @@ void AppRunningRecord::LowMemoryWarning() } } -void AppRunningRecord::OnAbilityStateChanged( - const std::shared_ptr &ability, const AbilityState state) +void AppRunningRecord::AddModules( + const std::shared_ptr &appInfo, const std::vector &moduleInfos) { - if (!ability) { - APP_LOGE("ability is null"); + APP_LOGD("Add modules"); + + if (moduleInfos.empty()) { + APP_LOGD("moduleInfos is empty."); return; } - AbilityState oldState = ability->GetState(); - ability->SetState(state); - OptimizerAbilityStateChanged(ability, oldState); - auto serviceInner = appMgrServiceInner_.lock(); - if (serviceInner) { - serviceInner->OnAbilityStateChanged(ability, state); + + for (auto &iter : moduleInfos) { + AddModule(appInfo, nullptr, nullptr, iter); + } +} + +void AppRunningRecord::AddModule(const std::shared_ptr &appInfo, + const std::shared_ptr &abilityInfo, const sptr &token, + const HapModuleInfo &hapModuleInfo) +{ + APP_LOGD("Add module."); + + if (!appInfo) { + APP_LOGE("appInfo is null"); + return; + } + + std::shared_ptr moduleRecord; + std::vector> moduleList; + + auto initModuleRecord = [=](const std::shared_ptr &moduleRecord) { + moduleRecord->Init(hapModuleInfo); + moduleRecord->SetAppMgrServiceInner(appMgrServiceInner_); + moduleRecord->SetApplicationClient(appLifeCycleDeal_); + }; + + const auto &iter = hapModules_.find(appInfo->bundleName); + if (iter != hapModules_.end()) { + moduleRecord = GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + if (!moduleRecord) { + moduleRecord = std::make_shared(appInfo, eventHandler_); + iter->second.push_back(moduleRecord); + initModuleRecord(moduleRecord); + } + } else { + moduleRecord = std::make_shared(appInfo, eventHandler_); + moduleList.push_back(moduleRecord); + hapModules_.emplace(appInfo->bundleName, moduleList); + appInfos_.emplace(appInfo->bundleName, appInfo); + initModuleRecord(moduleRecord); + } + + if (!abilityInfo || !token) { + APP_LOGE("abilityinfo or token is nullptr"); + return; + } + moduleRecord->AddAbility(token, abilityInfo); + + return; +} + +std::shared_ptr AppRunningRecord::GetModuleRecordByModuleName( + const std::string bundleName, const std::string &moduleName) +{ + APP_LOGD("Get module record by module name."); + auto moduleRecords = hapModules_.find(bundleName); + if (moduleRecords != hapModules_.end()) { + for (auto &iter : moduleRecords->second) { + if (iter->GetModuleName() == moduleName) { + return iter; + } + } } + + return nullptr; } void AppRunningRecord::StateChangedNotifyObserver( @@ -316,34 +442,64 @@ void AppRunningRecord::StateChangedNotifyObserver( } } -std::shared_ptr AppRunningRecord::GetAbilityRunningRecordByToken( +std::shared_ptr AppRunningRecord::GetModuleRunningRecordByToken( const sptr &token) const { if (!token) { APP_LOGE("token is null"); return nullptr; } - const auto &iter = abilities_.find(token); - if (iter != abilities_.end()) { - return iter->second; + + auto moduleRecordList = GetAllModuleRecord(); + for (const auto &moduleRecord : moduleRecordList) { + if (moduleRecord && moduleRecord->GetAbilityRunningRecordByToken(token)) { + return moduleRecord; + } } + return nullptr; } -std::shared_ptr AppRunningRecord::GetAbilityByTerminateLists( +std::shared_ptr AppRunningRecord::GetModuleRunningRecordByTerminateLists( const sptr &token) const { if (!token) { APP_LOGE("token is null"); return nullptr; } - const auto &iter = terminateAbilitys_.find(token); - if (iter != terminateAbilitys_.end()) { - return iter->second; + + auto moduleRecordList = GetAllModuleRecord(); + for (const auto &moduleRecord : moduleRecordList) { + if (moduleRecord && moduleRecord->GetAbilityByTerminateLists(token)) { + return moduleRecord; + } } + return nullptr; } +std::shared_ptr AppRunningRecord::GetAbilityRunningRecordByToken( + const sptr &token) const +{ + auto moduleRecord = GetModuleRunningRecordByToken(token); + if (!moduleRecord) { + APP_LOGE("moduleRecord is not exit"); + return nullptr; + } + return moduleRecord->GetAbilityRunningRecordByToken(token); +} + +std::shared_ptr AppRunningRecord::GetAbilityByTerminateLists( + const sptr &token) const +{ + auto moduleRecord = GetModuleRunningRecordByTerminateLists(token); + if (!moduleRecord) { + APP_LOGE("moduleRecord is not exit"); + return nullptr; + } + return moduleRecord->GetAbilityByTerminateLists(token); +} + void AppRunningRecord::UpdateAbilityState(const sptr &token, const AbilityState state) { APP_LOGD("state is :%{public}d", static_cast(state)); @@ -389,7 +545,8 @@ void AppRunningRecord::AbilityForeground(const std::shared_ptrGetToken()); + moduleRecord->OnAbilityStateChanged(ability, AbilityState::ABILITY_STATE_FOREGROUND); StateChangedNotifyObserver(ability, static_cast(AbilityState::ABILITY_STATE_FOREGROUND), true); auto serviceInner = appMgrServiceInner_.lock(); if (serviceInner) { @@ -413,11 +570,13 @@ void AppRunningRecord::AbilityBackground(const std::shared_ptrGetToken()); + moduleRecord->OnAbilityStateChanged(ability, AbilityState::ABILITY_STATE_BACKGROUND); StateChangedNotifyObserver(ability, static_cast(AbilityState::ABILITY_STATE_BACKGROUND), true); if (curState_ == ApplicationState::APP_STATE_FOREGROUND) { int32_t foregroundSize = 0; - for (const auto &item : abilities_) { + auto abilitysMap = GetAbilities(); + for (const auto &item : abilitysMap) { const auto &abilityRecord = item.second; if (abilityRecord && abilityRecord->GetState() == AbilityState::ABILITY_STATE_FOREGROUND) { foregroundSize++; @@ -434,22 +593,14 @@ void AppRunningRecord::AbilityBackground(const std::shared_ptr &ability, const AbilityState state) -{ - auto serviceInner = appMgrServiceInner_.lock(); - if (serviceInner) { - serviceInner->OptimizerAbilityStateChanged(ability, state); - } -} - void AppRunningRecord::PopForegroundingAbilityTokens() { APP_LOGD("size:%{public}d", static_cast(foregroundingAbilityTokens_.size())); while (!foregroundingAbilityTokens_.empty()) { const auto &token = foregroundingAbilityTokens_.front(); auto ability = GetAbilityRunningRecordByToken(token); - OnAbilityStateChanged(ability, AbilityState::ABILITY_STATE_FOREGROUND); + auto moduleRecord = GetModuleRunningRecordByToken(token); + moduleRecord->OnAbilityStateChanged(ability, AbilityState::ABILITY_STATE_FOREGROUND); StateChangedNotifyObserver(ability, static_cast(AbilityState::ABILITY_STATE_FOREGROUND), true); foregroundingAbilityTokens_.pop_front(); } @@ -457,66 +608,54 @@ void AppRunningRecord::PopForegroundingAbilityTokens() void AppRunningRecord::TerminateAbility(const sptr &token, const bool isForce) { - APP_LOGD("AppRunningRecord::TerminateAbility begin"); - auto abilityRecord = GetAbilityRunningRecordByToken(token); - if (!abilityRecord) { - APP_LOGE("AppRunningRecord::TerminateAbility can not find ability record"); - return; - } + APP_LOGD("Terminate ability, isForce: %{public}d", static_cast(isForce)); - terminateAbilitys_.emplace(token, abilityRecord); - abilities_.erase(token); - - SendEvent( - AMSEventHandler::TERMINATE_ABILITY_TIMEOUT_MSG, AMSEventHandler::TERMINATE_ABILITY_TIMEOUT, abilityRecord); - - if (!isForce) { - auto curAbilityState = abilityRecord->GetState(); - if (curAbilityState != AbilityState::ABILITY_STATE_BACKGROUND) { - APP_LOGE("AppRunningRecord::TerminateAbility current state(%{public}d) error", - static_cast(curAbilityState)); - return; - } + auto moduleRecord = GetModuleRunningRecordByToken(token); + if (!moduleRecord) { + APP_LOGE("can not find module record"); + return; } - - OptimizerAbilityStateChanged(abilityRecord, AbilityState::ABILITY_STATE_TERMINATED); + + auto abilityRecord = GetAbilityRunningRecordByToken(token); StateChangedNotifyObserver(abilityRecord, static_cast(AbilityState::ABILITY_STATE_TERMINATED), true); - if (appLifeCycleDeal_) { - appLifeCycleDeal_->ScheduleCleanAbility(token); - } else { - APP_LOGE("appLifeCycleDeal_ is null"); - } - + moduleRecord->TerminateAbility(token, isForce); APP_LOGD("AppRunningRecord::TerminateAbility end"); } void AppRunningRecord::AbilityTerminated(const sptr &token) { - APP_LOGI("%{public}s, called", __func__); - if (!token) { - APP_LOGE("token is null"); + APP_LOGI("Ability terminated."); + + auto moduleRecord = GetModuleRunningRecordByTerminateLists(token); + + if (!moduleRecord) { + APP_LOGE("Can not find module record"); return; } + moduleRecord->AbilityTerminated(token); - if (!eventHandler_) { - APP_LOGE("eventHandler_ is nullptr"); - return; + if (moduleRecord->GetAbilities().empty()) { + RemoveModuleRecord(moduleRecord); } - auto abilityRecord = GetAbilityByTerminateLists(token); - if (!abilityRecord) { - APP_LOGE("AppRunningRecord::AbilityTerminated can not find ability record"); - return; + auto moduleRecordList = GetAllModuleRecord(); + if (moduleRecordList.empty()) { + ScheduleTerminate(); } +} - eventHandler_->RemoveEvent(AMSEventHandler::TERMINATE_ABILITY_TIMEOUT_MSG, abilityRecord->GetEventId()); - terminateAbilitys_.erase(token); +std::list> AppRunningRecord::GetAllModuleRecord() const +{ + APP_LOGD("Get all module record."); - // The resident process won't let him die - // It’s important not to let the process die - if (abilities_.empty() && !isKeepAliveApp) { - ScheduleTerminate(); + std::list> moduleRecordList; + for (const auto &item : hapModules_) { + for (const auto &list : item.second) { + moduleRecordList.push_back(list); + } } + APP_LOGD("GetAllModuleRecord size:%{public}zu", moduleRecordList.size()); + return moduleRecordList; } void AppRunningRecord::RegisterAppDeathRecipient() const @@ -526,7 +665,7 @@ void AppRunningRecord::RegisterAppDeathRecipient() const return; } if (!appLifeCycleDeal_->GetApplicationClient()) { - APP_LOGE("appThread is null"); + APP_LOGE("appThread is nullptr"); return; } auto object = appLifeCycleDeal_->GetApplicationClient()->AsObject(); @@ -542,7 +681,7 @@ void AppRunningRecord::RemoveAppDeathRecipient() const return; } if (!appLifeCycleDeal_->GetApplicationClient()) { - APP_LOGE("appThread is null"); + APP_LOGE("appThread is nullptr."); return; } auto object = appLifeCycleDeal_->GetApplicationClient()->AsObject(); @@ -554,6 +693,16 @@ void AppRunningRecord::RemoveAppDeathRecipient() const void AppRunningRecord::SetAppMgrServiceInner(const std::weak_ptr &inner) { appMgrServiceInner_ = inner; + + auto moduleRecordList = GetAllModuleRecord(); + if (moduleRecordList.empty()) { + APP_LOGE("moduleRecordList is empty"); + return; + } + + for (const auto &moduleRecord : moduleRecordList) { + moduleRecord->SetAppMgrServiceInner(appMgrServiceInner_); + } } void AppRunningRecord::SetAppDeathRecipient(const sptr &appDeathRecipient) @@ -570,25 +719,13 @@ std::shared_ptr AppRunningRecord::GetPriorityObject() return priorityObject_; } -void AppRunningRecord::SendEvent( - uint32_t msg, int64_t timeOut, const std::shared_ptr &abilityRecord) -{ - if (!eventHandler_) { - APP_LOGE("eventHandler_ is nullptr"); - return; - } - - appEventId_++; - abilityRecord->SetEventId(appEventId_); - eventHandler_->SendEvent(msg, appEventId_, timeOut); -} - void AppRunningRecord::SendEvent(uint32_t msg, int64_t timeOut) { if (!eventHandler_) { APP_LOGE("eventHandler_ is nullptr"); return; } + appEventId_++; eventId_ = appEventId_; eventHandler_->SendEvent(msg, appEventId_, timeOut); @@ -607,11 +744,22 @@ void AppRunningRecord::SetEventHandler(const std::shared_ptr &h bool AppRunningRecord::IsLastAbilityRecord(const sptr &token) { if (!token) { - APP_LOGE("%{public}s, token is nullptr", __func__); + APP_LOGE("token is nullptr"); + return false; + } + + auto moduleRecord = GetModuleRunningRecordByToken(token); + if (!moduleRecord) { + APP_LOGE("can not find module record"); return false; } - return ((abilities_.size() == 1) && (abilities_.find(token) != abilities_.end())); + auto moduleRecordList = GetAllModuleRecord(); + if(moduleRecordList.size() == 1){ + return moduleRecord->IsLastAbilityRecord(token); + } + + return false; } void AppRunningRecord::SetTerminating() @@ -634,13 +782,47 @@ void AppRunningRecord::SetKeepAliveAppState() isKeepAliveApp = true; } -void AppRunningRecord::insertAbilityStageInfo(std::vector moduleInfos) +bool AppRunningRecord::GetTheModuleInfoNeedToUpdated(const std::string bundleName, HapModuleInfo &info) { - if (moduleInfos.empty()) { - return; + bool result = false; + auto moduleInfoVectorIter = hapModules_.find(bundleName); + if (moduleInfoVectorIter == hapModules_.end() || moduleInfoVectorIter->second.empty()) { + return result; + } + auto findCondition = [](const std::shared_ptr &record) { + if (record) { + return record->GetModuleRecordState() == ModuleRecordState::INITIALIZED_STATE; + } + return false; + }; + auto moduleRecordIter = + std::find_if(moduleInfoVectorIter->second.begin(), moduleInfoVectorIter->second.end(), findCondition); + if (moduleRecordIter != moduleInfoVectorIter->second.end()) { + (*moduleRecordIter)->GetHapModuleInfo(info); + result = true; } - abilityStage_.emplace(appRecordId_, moduleInfos); + return result; +} + +void AppRunningRecord::SetRestartResidentProcCount(int count) +{ + restartResidentProcCount_ = count; +} + +void AppRunningRecord::DecRestartResidentProcCount() +{ + restartResidentProcCount_--; +} + +int AppRunningRecord::GetRestartResidentProcCount() const +{ + return restartResidentProcCount_; +} + +bool AppRunningRecord::CanRestartResidentProc() +{ + return (restartResidentProcCount_ > 0); } } // namespace AppExecFwk } // namespace OHOS diff --git a/services/appmgr/src/cgroup_manager.cpp b/services/appmgr/src/cgroup_manager.cpp index 7371ed9565b6dded8b1e10a32aa56b90579c43d9..1344ed3959c448746b41b3f60ad295f5269b9466 100644 --- a/services/appmgr/src/cgroup_manager.cpp +++ b/services/appmgr/src/cgroup_manager.cpp @@ -74,7 +74,7 @@ int WriteValue(int fd, std::string_view v) int ret = TEMP_FAILURE_RETRY(write(fd, v.data(), v.size())); if (ret != 0) { - APP_LOGE("%{public}s(%{public}d) err: %{public}s.", __func__, __LINE__, strerror(errno)); + APP_LOGE("err: %{public}s.", strerror(errno)); } fsync(fd); @@ -129,15 +129,15 @@ CgroupManager::~CgroupManager() bool CgroupManager::Init() { - APP_LOGE("%{public}s(%{public}d) Init enter.", __func__, __LINE__); + APP_LOGI("Init enter."); if (IsInited()) { - APP_LOGE("%{public}s(%{public}d) already inited.", __func__, __LINE__); + APP_LOGE("already inited."); return false; } auto eventHandler = std::make_shared(EventRunner::Create()); if (!eventHandler) { - APP_LOGE("%{public}s(%{public}d) failed to get event handler.", __func__, __LINE__); + APP_LOGE("failed to get event handler."); return false; } @@ -219,53 +219,41 @@ bool CgroupManager::IsInited() const bool CgroupManager::SetThreadSchedPolicy(int tid, SchedPolicy schedPolicy) { if (!IsInited()) { - APP_LOGE("%{public}s(%{public}d) not inited.", __func__, __LINE__); + APP_LOGE("not inited."); return false; } if (tid < 1) { - APP_LOGE("%{public}s(%{public}d) invalid tid %{public}d.", __func__, __LINE__, tid); + APP_LOGE("invalid tid %{public}d.", tid); return false; } if (schedPolicy < 0 || schedPolicy >= SchedPolicy::SCHED_POLICY_MAX) { - APP_LOGE("%{public}s(%{public}d) invalid sched policy %{public}d.", __func__, __LINE__, schedPolicy); + APP_LOGE("invalid sched policy %{public}d.", schedPolicy); return false; } if (schedPolicy == SchedPolicy::SCHED_POLICY_FREEZED) { // set frozen of freezer if (!SetFreezerSubsystem(tid, SchedPolicyFreezer::SCHED_POLICY_FREEZER_FROZEN)) { - APP_LOGE("%{public}s(%{public}d) set freezer subsystem failed sched policy %{public}d.", - __func__, - __LINE__, - schedPolicy); + APP_LOGE("set freezer subsystem failed sched policy %{public}d.", schedPolicy); return false; } } else { // set cpuset if (!SetCpusetSubsystem(tid, schedPolicy)) { - APP_LOGE("%{public}s(%{public}d) set cpuset subsystem failed sched policy %{public}d.", - __func__, - __LINE__, - schedPolicy); + APP_LOGE("set cpuset subsystem failed sched policy %{public}d.", schedPolicy); return false; } // set cpuctl if (!SetCpuctlSubsystem(tid, schedPolicy)) { - APP_LOGE("%{public}s(%{public}d) set cpuctl subsystem failed sched policy %{public}d.", - __func__, - __LINE__, - schedPolicy); + APP_LOGE("set cpuctl subsystem failed sched policy %{public}d.", schedPolicy); return false; } // set thawed of freezer if (!SetFreezerSubsystem(tid, SchedPolicyFreezer::SCHED_POLICY_FREEZER_THAWED)) { - APP_LOGE("%{public}s(%{public}d) set freezer subsystem failed sched policy %{public}d.", - __func__, - __LINE__, - schedPolicy); + APP_LOGE("set freezer subsystem failed sched policy %{public}d.", schedPolicy); return false; } } @@ -276,17 +264,17 @@ bool CgroupManager::SetThreadSchedPolicy(int tid, SchedPolicy schedPolicy) bool CgroupManager::SetProcessSchedPolicy(int pid, SchedPolicy schedPolicy) { if (!IsInited()) { - APP_LOGE("%{public}s(%{public}d) not inited.", __func__, __LINE__); + APP_LOGE("not inited."); return false; } if (pid < 1) { - APP_LOGE("%{public}s(%{public}d) invalid pid %{public}d", __func__, __LINE__, pid); + APP_LOGE("invalid pid %{public}d", pid); return false; } if (schedPolicy < 0 && schedPolicy >= SCHED_POLICY_MAX) { - APP_LOGE("%{public}s(%{public}d) invalid sched policy %{public}d", __func__, __LINE__, schedPolicy); + APP_LOGE("invalid sched policy %{public}d", schedPolicy); return false; } @@ -298,9 +286,7 @@ bool CgroupManager::SetProcessSchedPolicy(int pid, SchedPolicy schedPolicy) DIR *dir = opendir(taskDir); if (dir == nullptr) { - APP_LOGE("%{public}s(%{public}d) failed to opendir invalid pid %{public}d taskDir %{public}s , %{public}s", - __func__, - __LINE__, + APP_LOGE("failed to opendir invalid pid %{public}d taskDir %{public}s , %{public}s", pid, taskDir, strerror(errno)); @@ -322,29 +308,27 @@ bool CgroupManager::SetProcessSchedPolicy(int pid, SchedPolicy schedPolicy) void CgroupManager::OnReadable(int32_t fd) { - APP_LOGW("%{public}s(%{public}d) system low memory alert.", __func__, __LINE__); + APP_LOGW("system low memory alert."); if (!LowMemoryAlert) { - APP_LOGE("%{public}s(%{public}d) 'LowMemoryAlert' not available.", __func__, __LINE__); + APP_LOGE("'LowMemoryAlert' not available."); return; } auto TryToRaiseLowMemoryAlert = [=](LowMemoryLevel level) { if (fd == memoryEventFds_[level]) { - APP_LOGW("%{public}s(%{public}d) checking level %{public}d", __func__, __LINE__, level); + APP_LOGW("checking level %{public}d", level); uint64_t count = 0; int ret = TEMP_FAILURE_RETRY(read(fd, &count, sizeof(uint64_t))); if (ret <= 0) { - APP_LOGW("%{public}s(%{public}d) failed to read eventfd %{public}d.", __func__, __LINE__, errno); + APP_LOGW("failed to read eventfd %{public}d.", errno); return false; } if (count < 1) { - APP_LOGW( - "%{public}s(%{public}d) invalid eventfd count %{public}" PRIu64 ".", __func__, __LINE__, count); + APP_LOGW("invalid eventfd count %{public}" PRIu64 ".", count); return false; } - APP_LOGW( - "%{public}s(%{public}d) raising low memory alert for level %{public}d...", __func__, __LINE__, level); + APP_LOGW("raising low memory alert for level %{public}d...", level); LowMemoryAlert(level); return true; } @@ -364,7 +348,7 @@ void CgroupManager::OnReadable(int32_t fd) } // Should not reach here! - APP_LOGE("%{public}s(%{public}d) Unknown fd %{public}d.", __func__, __LINE__, fd); + APP_LOGE("Unknown fd %{public}d.", fd); } bool CgroupManager::RegisterLowMemoryMonitor(const int memoryEventFds[LOW_MEMORY_LEVEL_MAX], @@ -402,7 +386,7 @@ bool CgroupManager::InitCpusetTasksFds(UniqueFd cpusetTasksFds[SCHED_POLICY_CPU_ cpusetTasksFds[SCHED_POLICY_CPU_DEFAULT] = UniqueFd(open(CG_CPUSET_DEFAULT_TASKS_PATH.data(), O_RDWR)); cpusetTasksFds[SCHED_POLICY_CPU_BACKGROUND] = UniqueFd(open(CG_CPUSET_BACKGROUND_TASKS_PATH.data(), O_RDWR)); if (cpusetTasksFds[SCHED_POLICY_CPU_DEFAULT].Get() < 0 || cpusetTasksFds[SCHED_POLICY_CPU_BACKGROUND].Get() < 0) { - APP_LOGE("%{public}s(%{public}d) cannot open cpuset cgroups %{public}d.", __func__, __LINE__, errno); + APP_LOGE("cannot open cpuset cgroups %{public}d.", errno); return false; } @@ -416,7 +400,7 @@ bool CgroupManager::InitCpuctlTasksFds(UniqueFd cpuctlTasksFds[SCHED_POLICY_CPU_ cpuctlTasksFds[SCHED_POLICY_CPU_DEFAULT] = UniqueFd(open(CG_CPUCTL_DEFAULT_TASKS_PATH.data(), O_RDWR)); cpuctlTasksFds[SCHED_POLICY_CPU_BACKGROUND] = UniqueFd(open(CG_CPUCTL_BACKGROUND_TASKS_PATH.data(), O_RDWR)); if (cpuctlTasksFds[SCHED_POLICY_CPU_DEFAULT].Get() < 0 || cpuctlTasksFds[SCHED_POLICY_CPU_BACKGROUND].Get() < 0) { - APP_LOGE("%{public}s(%{public}d) cannot open cpuctl cgroups %{public}d.", __func__, __LINE__, errno); + APP_LOGE("cannot open cpuctl cgroups %{public}d.", errno); return false; } @@ -431,7 +415,7 @@ bool CgroupManager::InitFreezerTasksFds(UniqueFd freezerTasksFds[SCHED_POLICY_FR freezerTasksFds[SCHED_POLICY_FREEZER_THAWED] = UniqueFd(open(CG_FREEZER_THAWED_TASKS_PATH.data(), O_RDWR)); if (freezerTasksFds[SCHED_POLICY_FREEZER_FROZEN].Get() < 0 || freezerTasksFds[SCHED_POLICY_FREEZER_THAWED].Get() < 0) { - APP_LOGE("%{public}s(%{public}d) cannot open freezer cgroups %{public}d.", __func__, __LINE__, errno); + APP_LOGE("cannot open freezer cgroups %{public}d.", errno); return false; } @@ -444,8 +428,7 @@ bool CgroupManager::InitMemoryEventControlFd(UniqueFd &memoryEventControlFd) { memoryEventControlFd = UniqueFd(open(CG_MEM_EVTCTL_PATH.data(), O_WRONLY)); if (memoryEventControlFd.Get() < 0) { - APP_LOGE( - "%{pubid}s(%{publid}d) failed to open memory event control node %{public}d.", __func__, __LINE__, errno); + APP_LOGE("failed to open memory event control node %{public}d.", errno); return false; } @@ -460,7 +443,7 @@ bool CgroupManager::InitMemoryEventFds(UniqueFd memoryEventFds[LOW_MEMORY_LEVEL_ memoryEventFds[LOW_MEMORY_LEVEL_CRITICAL] = UniqueFd(eventfd(0, EFD_NONBLOCK)); if (memoryEventFds[LOW_MEMORY_LEVEL_LOW].Get() < 0 || memoryEventFds[LOW_MEMORY_LEVEL_MEDIUM].Get() < 0 || memoryEventFds[LOW_MEMORY_LEVEL_CRITICAL].Get() < 0) { - APP_LOGE("%{public}s(${public}d) failed to create memory eventfd %{public}d.", __func__, __LINE__, errno); + APP_LOGE("failed to create memory eventfd %{public}d.", errno); return false; } @@ -477,7 +460,7 @@ bool CgroupManager::InitMemoryPressureFds(UniqueFd memoryPressureFds[LOW_MEMORY_ memoryPressureFds[LOW_MEMORY_LEVEL_CRITICAL] = UniqueFd(open(CG_MEM_PRESSURE_LEVEL_PATH.data(), O_RDONLY)); if (memoryPressureFds[LOW_MEMORY_LEVEL_LOW].Get() < 0 || memoryPressureFds[LOW_MEMORY_LEVEL_MEDIUM].Get() < 0 || memoryPressureFds[LOW_MEMORY_LEVEL_CRITICAL].Get() < 0) { - APP_LOGE("%{public}s(${public}d) failed to open memory pressure fd %{public}d.", __func__, __LINE__, errno); + APP_LOGE("failed to open memory pressure fd %{public}d.", errno); return false; } @@ -491,13 +474,13 @@ bool CgroupManager::SetCpusetSubsystem(const int tid, const SchedPolicy schedPol { int fd = cpusetTasksFds_[schedPolicy]; if (fd < 0) { - APP_LOGE("%{public}s(%{public}d) invalid cpuset fd for policy %{public}d.", __func__, __LINE__, schedPolicy); + APP_LOGE("invalid cpuset fd for policy %{public}d.", schedPolicy); return false; } int ret = WriteValue(fd, tid); if (ret < 0) { - APP_LOGE("%{public}s(%{public}d) write cpuset tid failed %{public}d.", __func__, __LINE__, errno); + APP_LOGE("write cpuset tid failed %{public}d.", errno); return false; } @@ -508,13 +491,13 @@ bool CgroupManager::SetCpuctlSubsystem(const int tid, const SchedPolicy schedPol { int fd = cpuctlTasksFds_[schedPolicy]; if (fd < 0) { - APP_LOGE("%{public}s(%{public}d) invalid cpuctl fd for policy %{public}d.", __func__, __LINE__, schedPolicy); + APP_LOGE("invalid cpuctl fd for policy %{public}d.", schedPolicy); return false; } int ret = WriteValue(fd, tid); if (ret < 0) { - APP_LOGE("%{public}s(%{public}d) write cpuctl tid failed %{public}d.", __func__, __LINE__, errno); + APP_LOGE("write cpuctl tid failed %{public}d.", errno); return false; } @@ -525,13 +508,13 @@ bool CgroupManager::SetFreezerSubsystem(const int tid, const SchedPolicyFreezer { int fd = freezerTasksFds_[state]; if (fd < 0) { - APP_LOGE("%{public}s(%{public}d) invalid freezer fd for state %{public}d.", __func__, __LINE__, state); + APP_LOGE("invalid freezer fd for state %{public}d.", state); return false; } int ret = WriteValue(fd, tid); if (ret < 0) { - APP_LOGE("%{public}s(%{public}d) write freezer tid failed %{public}d.", __func__, __LINE__, errno); + APP_LOGE("write freezer tid failed %{public}d.", errno); return false; } diff --git a/services/appmgr/src/lmks_client.cpp b/services/appmgr/src/lmks_client.cpp index f16cd1f143b711164502214dcd2c2485e74507db..c7a7d49f5769fd4f8335036a292c9d6579a5033e 100644 --- a/services/appmgr/src/lmks_client.cpp +++ b/services/appmgr/src/lmks_client.cpp @@ -63,31 +63,28 @@ LmksClient::~LmksClient() int32_t LmksClient::Open() { - APP_LOGI("%{public}s(%{public}d) connecting lmks.", __func__, __LINE__); + APP_LOGI("connecting lmks."); if (socket_ >= 0) { - APP_LOGE("%{public}s(%{public}d) already connected.", __func__, __LINE__); + APP_LOGE("already connected."); return -1; } UniqueFd sk(socket(PF_LOCAL, SOCK_SEQPACKET, 0)); if (sk.Get() < 0) { - APP_LOGE("%{public}s(%{public}d) failed to create local socket %{public}d.", __func__, __LINE__, errno); + APP_LOGE("failed to create local socket %{public}d.", errno); return (-errno); } struct timeval timeOut = {.tv_sec = LMKS_SOCKET_TIMEOUT, .tv_usec = 0}; int fd = sk.Get(); if (fd < 0) { - APP_LOGE("%{public}s(%{public}d) fd is negative.", __func__, __LINE__); + APP_LOGE("fd is negative."); return -1; } if ((setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeOut, sizeof(timeOut)) != 0) || (setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeOut, sizeof(timeOut)) != 0)) { - APP_LOGE("%{public}s(%{public}d) failed to set local socket timeout %{public}s.", - __func__, - __LINE__, - strerror(errno)); + APP_LOGE("failed to set local socket timeout %{public}s.", strerror(errno)); return (-errno); } @@ -95,20 +92,20 @@ int32_t LmksClient::Open() int32_t ret; ret = memset_s(&addr, sizeof(addr), 0, sizeof(addr)); if (ret != EOK) { - APP_LOGE("%{public}s(%{public}d) failed to clear local socket addr.", __func__, __LINE__); + APP_LOGE("failed to clear local socket addr."); return ret; } ret = memcpy_s(addr.sun_path, LMKS_SOCKET_PATH_MAX, LMKS_SOCKET_PATH.data(), LMKS_SOCKET_PATH.size()); if (ret != EOK) { - APP_LOGE("%{public}s(%{public}d) failed to make local socket path.", __func__, __LINE__); + APP_LOGE("failed to make local socket path."); return ret; } addr.sun_family = AF_LOCAL; socklen_t addrLen = offsetof(struct sockaddr_un, sun_path) + LMKS_SOCKET_PATH.size() + 1; if (connect(sk, reinterpret_cast(&addr), addrLen) < 0) { - APP_LOGE("%{public}s(%{public}d) failed to connect to lmks %{public}s.", __func__, __LINE__, strerror(errno)); + APP_LOGE("failed to connect to lmks %{public}s.", strerror(errno)); return (-errno); } @@ -119,10 +116,10 @@ int32_t LmksClient::Open() void LmksClient::Close() { - APP_LOGI("%{public}s(%{public}d) closing lmks.", __func__, __LINE__); + APP_LOGI("closing lmks."); if (socket_ < 0) { - APP_LOGE("%{public}s(%{public}d) not connected.", __func__, __LINE__); + APP_LOGE("not connected."); return; } @@ -140,8 +137,7 @@ int32_t LmksClient::Target(const Targets &targets) APP_LOGI("Target enter"); if (targets.empty() || targets.size() > LMKS_MAX_TARGETS) { - APP_LOGE( - "%{public}s(%{public}d) empty target or too many targets. %{public}zu", __func__, __LINE__, targets.size()); + APP_LOGE("empty target or too many targets. %{public}zu", targets.size()); return (-EINVAL); } @@ -151,11 +147,7 @@ int32_t LmksClient::Target(const Targets &targets) for (auto target : targets) { if (target.first < 0 || !CheckOomAdj(target.second)) { - APP_LOGE("%{public}s(%{public}d) invalid target: %{public}d %{public}d", - __func__, - __LINE__, - target.first, - target.second); + APP_LOGE("invalid target: %{public}d %{public}d", target.first, target.second); return (-EINVAL); } buf[i++] = target.first; @@ -170,12 +162,7 @@ int32_t LmksClient::ProcPrio(pid_t pid, uid_t uid, int oomAdj) APP_LOGI("ProcPrio enter"); if (pid < 0 || uid < 0 || !CheckOomAdj(oomAdj)) { - APP_LOGE("%{public}s(%{public}d) invalid parameter: %{public}d %{public}d %{public}d.", - __func__, - __LINE__, - pid, - uid, - oomAdj); + APP_LOGE("invalid parameter: %{public}d %{public}d %{public}d.", pid, uid, oomAdj); return (-EINVAL); } @@ -189,7 +176,7 @@ int32_t LmksClient::ProcRemove(pid_t pid) APP_LOGI("ProcRemove enter"); if (pid < 1) { - APP_LOGE("%{public}s(%{public}d) invalid pid %{public}d.", __func__, __LINE__, pid); + APP_LOGE("invalid pid %{public}d.", pid); return (-EINVAL); } @@ -231,7 +218,7 @@ bool LmksClient::CheckOomAdj(int v) bool LmksClient::Write(const void *buf, size_t len) { if (buf == nullptr || len < 1) { - APP_LOGE("%{public}s(%{public}d) invalid parameter.", __func__, __LINE__); + APP_LOGE("invalid parameter."); return false; } diff --git a/services/appmgr/src/module_running_record.cpp b/services/appmgr/src/module_running_record.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d25abb3a8aba30cea5b1170fa6958d1cacc1374a --- /dev/null +++ b/services/appmgr/src/module_running_record.cpp @@ -0,0 +1,303 @@ +/* + * Copyright (c) 2021 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 "module_running_record.h" +#include "app_log_wrapper.h" +#include "app_mgr_service_inner.h" + +namespace OHOS { +namespace AppExecFwk { +ModuleRunningRecord::ModuleRunningRecord( + const std::shared_ptr &info, const std::shared_ptr &eventHandler) + : appInfo_(info), eventHandler_(eventHandler) +{} + +ModuleRunningRecord::~ModuleRunningRecord() +{} + +void ModuleRunningRecord::Init(const HapModuleInfo &info) +{ + owenInfo_ = info; + owenState_ = ModuleRecordState::INITIALIZED_STATE; +} + +const std::string &ModuleRunningRecord::GetModuleName() const +{ + return owenInfo_.moduleName; +} + +const std::shared_ptr ModuleRunningRecord::GetAppInfo() +{ + return appInfo_; +} + +std::shared_ptr ModuleRunningRecord::GetAbilityRunningRecordByToken( + const sptr &token) const +{ + APP_LOGD("Get ability running record by token."); + if (!token) { + APP_LOGE("token is null"); + return nullptr; + } + const auto &iter = abilities_.find(token); + if (iter != abilities_.end()) { + return iter->second; + } + return nullptr; +} + +std::shared_ptr ModuleRunningRecord::AddAbility( + const sptr &token, const std::shared_ptr &abilityInfo) +{ + APP_LOGD("Add ability."); + if (!token || !abilityInfo) { + APP_LOGE("Param abilityInfo or token is null"); + return nullptr; + } + if (GetAbilityRunningRecordByToken(token)) { + APP_LOGE("AbilityRecord already exists and no need to add"); + return nullptr; + } + auto abilityRecord = std::make_shared(abilityInfo, token); + abilities_.emplace(token, abilityRecord); + return abilityRecord; +} + +bool ModuleRunningRecord::IsLastAbilityRecord(const sptr &token) +{ + APP_LOGD("Is last ability record."); + if (!token) { + APP_LOGE("token is nullptr"); + return false; + } + + return ((abilities_.size() == 1) && (abilities_.find(token) != abilities_.end())); +} + +const std::map, std::shared_ptr> + &ModuleRunningRecord::GetAbilities() const +{ + return abilities_; +} + +std::shared_ptr ModuleRunningRecord::GetAbilityByTerminateLists( + const sptr &token) const +{ + APP_LOGD("Get ability by terminateLists."); + if (!token) { + APP_LOGE("token is null"); + return nullptr; + } + const auto &iter = terminateAbilitys_.find(token); + if (iter != terminateAbilitys_.end()) { + return iter->second; + } + return nullptr; +} + +void ModuleRunningRecord::ClearAbility(const std::shared_ptr &record) +{ + APP_LOGD("Clear ability."); + if (!record) { + APP_LOGE("Param record is null"); + return; + } + if (!GetAbilityRunningRecordByToken(record->GetToken())) { + APP_LOGE("Param record is not exist"); + return; + } + abilities_.erase(record->GetToken()); +} + +std::shared_ptr ModuleRunningRecord::GetAbilityRunningRecord(const std::string &abilityName) const +{ + APP_LOGD("Get ability running record by ability name."); + const auto &iter = std::find_if(abilities_.begin(), abilities_.end(), [&abilityName](const auto &pair) { + return pair.second->GetName() == abilityName; + }); + return ((iter == abilities_.end()) ? nullptr : iter->second); +} + +std::shared_ptr ModuleRunningRecord::GetAbilityRunningRecord(const int64_t eventId) const +{ + APP_LOGI("Get ability running record by eventId."); + const auto &iter = std::find_if(abilities_.begin(), abilities_.end(), [eventId](const auto &pair) { + return pair.second->GetEventId() == eventId; + }); + if (iter != abilities_.end()) { + return iter->second; + } + + const auto &finder = std::find_if(terminateAbilitys_.begin(), + terminateAbilitys_.end(), + [eventId](const auto &pair) { return pair.second->GetEventId() == eventId; }); + if (finder != terminateAbilitys_.end()) { + return finder->second; + } + return nullptr; +} + +void ModuleRunningRecord::OnAbilityStateChanged( + const std::shared_ptr &ability, const AbilityState state) +{ + APP_LOGD("On ability state changed."); + if (!ability) { + APP_LOGE("ability is null"); + return; + } + AbilityState oldState = ability->GetState(); + ability->SetState(state); + OptimizerAbilityStateChanged(ability, oldState); + APP_LOGI("OnAbilityStateChanged oldState:%{public}d, state:%{public}d", oldState, state); + auto serviceInner = appMgrServiceInner_.lock(); + if (serviceInner) { + serviceInner->OnAbilityStateChanged(ability, state); + } +} + +void ModuleRunningRecord::OptimizerAbilityStateChanged( + const std::shared_ptr &ability, const AbilityState state) +{ + APP_LOGD("Optimizer ability state changed."); + auto serviceInner = appMgrServiceInner_.lock(); + if (serviceInner) { + serviceInner->OptimizerAbilityStateChanged(ability, state); + } +} + +void ModuleRunningRecord::LaunchAbility(const std::shared_ptr &ability) +{ + APP_LOGD("Launch ability."); + if (!ability || !ability->GetToken()) { + APP_LOGE("null abilityRecord or abilityToken"); + return; + } + const auto &iter = abilities_.find(ability->GetToken()); + if (iter != abilities_.end() && appLifeCycleDeal_->GetApplicationClient()) { + APP_LOGI("ScheduleLaunchAbility ability:%{public}s", ability->GetName().c_str()); + appLifeCycleDeal_->LaunchAbility(ability); + ability->SetState(AbilityState::ABILITY_STATE_READY); + OptimizerAbilityStateChanged(ability, AbilityState::ABILITY_STATE_CREATE); + } +} + +void ModuleRunningRecord::LaunchPendingAbilities() +{ + APP_LOGD("Launch pending abilities."); + + if (abilities_.empty()) { + APP_LOGE("abilities_ is empty"); + return; + } + + for (auto item : abilities_) { + APP_LOGI("state : %{public}d", item.second->GetState()); + if (item.second->GetState() == AbilityState::ABILITY_STATE_CREATE) { + LaunchAbility(item.second); + } + } +} + +void ModuleRunningRecord::TerminateAbility(const sptr &token, const bool isForce) +{ + APP_LOGD("Terminate ability."); + auto abilityRecord = GetAbilityRunningRecordByToken(token); + if (!abilityRecord) { + APP_LOGE("abilityRecord is nullptr"); + return; + } + + terminateAbilitys_.emplace(token, abilityRecord); + abilities_.erase(token); + + SendEvent( + AMSEventHandler::TERMINATE_ABILITY_TIMEOUT_MSG, AMSEventHandler::TERMINATE_ABILITY_TIMEOUT, abilityRecord); + + if (!isForce) { + auto curAbilityState = abilityRecord->GetState(); + if (curAbilityState != AbilityState::ABILITY_STATE_BACKGROUND) { + APP_LOGE("current state(%{public}d) error", static_cast(curAbilityState)); + return; + } + } + + OptimizerAbilityStateChanged(abilityRecord, AbilityState::ABILITY_STATE_TERMINATED); + if (appLifeCycleDeal_) { + appLifeCycleDeal_->ScheduleCleanAbility(token); + } else { + APP_LOGE("appLifeCycleDeal_ is null"); + } + + APP_LOGD("ModuleRunningRecord::TerminateAbility end"); +} + +void ModuleRunningRecord::SendEvent( + uint32_t msg, int64_t timeOut, const std::shared_ptr &abilityRecord) +{ + APP_LOGD("Send event"); + if (!eventHandler_) { + APP_LOGE("eventHandler_ is nullptr"); + return; + } + + AppRunningRecord::appEventId_++; + abilityRecord->SetEventId(AppRunningRecord::appEventId_); + eventHandler_->SendEvent(msg, AppRunningRecord::appEventId_, timeOut); +} + +void ModuleRunningRecord::AbilityTerminated(const sptr &token) +{ + APP_LOGI("Ability terminated."); + if (!token) { + APP_LOGE("token is null"); + return; + } + + if (!eventHandler_) { + APP_LOGE("eventHandler_ is nullptr"); + return; + } + + auto abilityRecord = GetAbilityByTerminateLists(token); + if (!abilityRecord) { + APP_LOGE("ModuleRunningRecord::AbilityTerminated can not find ability record"); + return; + } + + eventHandler_->RemoveEvent(AMSEventHandler::TERMINATE_ABILITY_TIMEOUT_MSG, abilityRecord->GetEventId()); + terminateAbilitys_.erase(token); +} + +void ModuleRunningRecord::SetAppMgrServiceInner(const std::weak_ptr &inner) +{ + appMgrServiceInner_ = inner; +} + +ModuleRecordState ModuleRunningRecord::GetModuleRecordState() +{ + return owenState_; +} + +void ModuleRunningRecord::GetHapModuleInfo(HapModuleInfo &info) +{ + info = owenInfo_; +} + +void ModuleRunningRecord::SetApplicationClient(std::shared_ptr &appLifeCycleDeal) +{ + appLifeCycleDeal_ = appLifeCycleDeal; +} +} // namespace AppExecFwk +} // namespace OHOS diff --git a/services/appmgr/src/process_optimizer.cpp b/services/appmgr/src/process_optimizer.cpp index c70eab64f146a809c3520ad3d506630b444e81aa..3af3f1c3d8062e3f7acaeb6e1bb31e8413ab4419 100644 --- a/services/appmgr/src/process_optimizer.cpp +++ b/services/appmgr/src/process_optimizer.cpp @@ -74,44 +74,40 @@ constexpr int G_MEMORY_LEVEL[] = {LMKS_OOM_ADJ_LOW, LMKS_OOM_ADJ_MEDIUM, LMKS_OO ProcessOptimizer::ProcessOptimizer(const LmksClientPtr &lmksClient, int suspendTimeout) : lmksClient_(lmksClient), suspendTimeout_(suspendTimeout) -{ - APP_LOGI("%{public}s(%{public}d) constructed.", __func__, __LINE__); -} +{} ProcessOptimizer::~ProcessOptimizer() { if (lmksClient_) { lmksClient_->ProcPurge(); } - - APP_LOGI("%{public}s(%{public}d) destructed.", __func__, __LINE__); } bool ProcessOptimizer::Init() { - APP_LOGI("%{public}s(%{public}d) initializing...", __func__, __LINE__); + APP_LOGI("initializing..."); if (suspendTimeout_ < 0) { - APP_LOGE("%{public}s(%{public}d) invalid suspend timeout.", __func__, __LINE__); + APP_LOGE("invalid suspend timeout."); return false; } if (eventHandler_) { - APP_LOGE("%{public}s(%{public}d) already inited.", __func__, __LINE__); + APP_LOGE("already inited."); return false; } // Initializing cgroup manager. if (!DelayedSingleton::GetInstance()->IsInited()) { - APP_LOGW("%{public}s(%{public}d) cgroup manager not inited.", __func__, __LINE__); + APP_LOGW("cgroup manager not inited."); if (!DelayedSingleton::GetInstance()->Init()) { - APP_LOGE("%{public}s(%{public}d) cannot init cgroup manager.", __func__, __LINE__); + APP_LOGE("cannot init cgroup manager."); return false; } } if (DelayedSingleton::GetInstance()->LowMemoryAlert) { - APP_LOGW("%{public}s(%{public}d) cgroup manager 'LowMemoryWarning' already registered.", __func__, __LINE__); + APP_LOGW("cgroup manager 'LowMemoryWarning' already registered."); } DelayedSingleton::GetInstance()->LowMemoryAlert = @@ -132,28 +128,28 @@ bool ProcessOptimizer::Init() if (!lmksClientLocal) { lmksClientLocal = std::make_shared(); if (!lmksClientLocal) { - APP_LOGE("%{public}s(%{public}d) failed to create lmks client.", __func__, __LINE__); + APP_LOGE("failed to create lmks client."); return false; } } if (!lmksClientLocal->IsOpen()) { if (lmksClientLocal->Open()) { - APP_LOGE("%{public}s(%{public}d) cannot open lmks connection.", __func__, __LINE__); + APP_LOGE("cannot open lmks connection."); return false; } } if (lmksClientLocal->Target(targets) != ERR_OK) { // print warning when lmks server not implement. - APP_LOGW("%{public}s(%{public}d) cannot init lmks.", __func__, __LINE__); + APP_LOGW("cannot init lmks."); } lmksClient_ = lmksClientLocal; // Save initialized states. auto eventHandler = std::make_shared(EventRunner::Create()); if (!eventHandler) { - APP_LOGE("%{public}s(%{public}d) no available event handler for current thread.", __func__, __LINE__); + APP_LOGE("no available event handler for current thread."); return false; } @@ -165,15 +161,14 @@ bool ProcessOptimizer::Init() void ProcessOptimizer::OnAppAdded(const AppPtr &app) { if (!app) { - APP_LOGE("%{public}s(%{public}d) invalid app.", __func__, __LINE__); + APP_LOGE("invalid app."); return; } if (app != appLru_.front()) { auto it = std::find(appLru_.begin(), appLru_.end(), app); if (it != appLru_.end()) { - APP_LOGE( - "%{public}s(%{public}d) app '%{public}s' already existed.", __func__, __LINE__, app->GetName().c_str()); + APP_LOGE("app '%{public}s' already existed.", app->GetName().c_str()); appLru_.erase(it); } if (app->GetState() == ApplicationState::APP_STATE_FOREGROUND) { @@ -189,12 +184,12 @@ void ProcessOptimizer::OnAppAdded(const AppPtr &app) void ProcessOptimizer::OnAppRemoved(const AppPtr &app) { if (!app) { - APP_LOGE("%{public}s(%{public}d) invalid app.", __func__, __LINE__); + APP_LOGE("invalid app."); return; } if (!lmksClient_) { - APP_LOGE("%{public}s(%{public}d) invalid lmks client.", __func__, __LINE__); + APP_LOGE("invalid lmks client."); return; } @@ -205,19 +200,17 @@ void ProcessOptimizer::OnAppRemoved(const AppPtr &app) if (it != appLru_.end()) { appLru_.erase(it); } else { - APP_LOGE("%{pulbid}s(%{publid}d) app '%{public}s' is not existed.", __func__, __LINE__, app->GetName().c_str()); + APP_LOGE("app '%{public}s' is not existed.", app->GetName().c_str()); } auto priorityObject = app->GetPriorityObject(); if (!priorityObject) { - APP_LOGE("%{public}s(%{public}d) invalid priority object.", __func__, __LINE__); + APP_LOGE("invalid priority object."); return; } if (lmksClient_->ProcRemove(priorityObject->GetPid()) != ERR_OK) { - APP_LOGE("%{public}s(%{public}d) failed to remove app '%{public}s'(%{publid}d) from lmks.", - __func__, - __LINE__, + APP_LOGE("failed to remove app '%{public}s'(%{publid}d) from lmks.", app->GetName().c_str(), priorityObject->GetPid()); } @@ -226,20 +219,20 @@ void ProcessOptimizer::OnAppRemoved(const AppPtr &app) void ProcessOptimizer::OnAppStateChanged(const AppPtr &app, const ApplicationState oldState) { if (!app) { - APP_LOGE("%{public}s(%{public}d) invalid app.", __func__, __LINE__); + APP_LOGE("invalid app."); return; } auto priorityObject = app->GetPriorityObject(); if (!priorityObject) { - APP_LOGE("%{public}s(%{public}d) invalid priority object.", __func__, __LINE__); + APP_LOGE("invalid priority object."); return; } auto curState = app->GetState(); - APP_LOGD("%{public}s(%{pubic}d) ability state changed to %{public}d.", __func__, __LINE__, curState); + APP_LOGD("ability state changed to %{public}d.", curState); if (curState == oldState) { - APP_LOGW("%{public}s(%{public}d) no change.", __func__, __LINE__); + APP_LOGW("no change."); return; } @@ -249,10 +242,7 @@ void ProcessOptimizer::OnAppStateChanged(const AppPtr &app, const ApplicationSta if (it != appLru_.end()) { appLru_.erase(it); } else { - APP_LOGE("%{pulbid}s(%{publid}d) app '%{public}s' is not existed.", - __func__, - __LINE__, - app->GetName().c_str()); + APP_LOGE("app '%{public}s' is not existed.", app->GetName().c_str()); } appLru_.push_front(app); } @@ -275,113 +265,113 @@ void ProcessOptimizer::OnAppStateChanged(const AppPtr &app, const ApplicationSta void ProcessOptimizer::OnAbilityStarted(const AbilityPtr &ability) { if (!ability) { - APP_LOGE("%{public}s(%{public}d) invalid ability.", __func__, __LINE__); + APP_LOGE("invalid ability."); return; } - APP_LOGI("%{public}s(%{public}d) OnAbilityStarted.", __func__, __LINE__); + APP_LOGI("OnAbilityStarted."); } void ProcessOptimizer::OnAbilityConnected(const AbilityPtr &ability, const AbilityPtr &targetAbility) { if (!ability) { - APP_LOGE("%{public}s(%{public}d) invalid ability.", __func__, __LINE__); + APP_LOGE("invalid ability."); return; } if (!targetAbility) { - APP_LOGE("%{public}s(%{public}d) invalid targetAbility.", __func__, __LINE__); + APP_LOGE("invalid targetAbility."); return; } - APP_LOGI("%{public}s(%{public}d) OnAbilityConnected.", __func__, __LINE__); + APP_LOGI("OnAbilityConnected end."); } void ProcessOptimizer::OnAbilityDisconnected(const AbilityPtr &ability, const AbilityPtr &targetAbility) { if (!ability) { - APP_LOGE("%{public}s(%{public}d) invalid ability.", __func__, __LINE__); + APP_LOGE("invalid ability."); return; } if (!targetAbility) { - APP_LOGE("%{public}s(%{public}d) invalid targetAbility.", __func__, __LINE__); + APP_LOGE("invalid targetAbility."); return; } - APP_LOGI("%{public}s(%{public}d) OnAbilityDisconnected.", __func__, __LINE__); + APP_LOGI("OnAbilityDisconnected end."); } void ProcessOptimizer::OnAbilityStateChanged(const AbilityPtr &ability, const AbilityState oldState) { if (!ability) { - APP_LOGE("%{public}s(%{public}d) invalid ability.", __func__, __LINE__); + APP_LOGE("invalid ability."); return; } - APP_LOGI("%{public}s(%{public}d) OnAbilityStateChanged.", __func__, __LINE__); + APP_LOGI("OnAbilityStateChanged end."); } void ProcessOptimizer::OnAbilityVisibleChanged(const AbilityPtr &ability) { if (!ability) { - APP_LOGE("%{public}s(%{public}d) invalid ability.", __func__, __LINE__); + APP_LOGE("invalid ability."); return; } - APP_LOGI("%{public}s(%{public}d) OnAbilityVisibleChanged.", __func__, __LINE__); + APP_LOGI("OnAbilityVisibleChanged end."); } void ProcessOptimizer::OnAbilityPerceptibleChanged(const AbilityPtr &ability) { if (!ability) { - APP_LOGE("%{public}s(%{public}d) invalid ability.", __func__, __LINE__); + APP_LOGE("invalid ability."); } - APP_LOGI("%{public}s(%{public}d) OnAbilityPerceptibleChanged.", __func__, __LINE__); + APP_LOGI("OnAbilityPerceptibleChanged end."); } void ProcessOptimizer::OnAbilityRemoved(const AbilityPtr &ability) { if (!ability) { - APP_LOGE("%{public}s(%{public}d) invalid ability.", __func__, __LINE__); + APP_LOGE("invalid ability."); return; } - APP_LOGI("%{public}s(%{public}d) OnAbilityRemoved.", __func__, __LINE__); + APP_LOGI("OnAbilityRemoved end."); } bool ProcessOptimizer::SetAppOomAdj(const AppPtr &app, int oomAdj) { if (!app) { - APP_LOGE("%{public}s(%{public}d) invalid app.", __func__, __LINE__); + APP_LOGE("invalid app."); return false; } if (!LmksClient::CheckOomAdj(oomAdj)) { - APP_LOGE("%{public}s(%{public}d) invalid oom adj %{public}d.", __func__, __LINE__, oomAdj); + APP_LOGE("invalid oom adj %{public}d.", oomAdj); return false; } if (!lmksClient_) { - APP_LOGE("%{public}s(%{public}d) invalid lmks client.", __func__, __LINE__); + APP_LOGE("invalid lmks client."); return false; } auto priorityObject = app->GetPriorityObject(); if (!priorityObject) { - APP_LOGE("%{public}s(%{public}d) invalid priority object.", __func__, __LINE__); + APP_LOGE("invalid priority object."); return false; } if (priorityObject->GetCurAdj() == oomAdj) { - APP_LOGW("%{public}s(%{public}d) oom adj has no change.", __func__, __LINE__); + APP_LOGW("oom adj has no change."); return true; } if (lmksClient_->ProcPrio(priorityObject->GetPid(), app->GetUid(), oomAdj) != ERR_OK) { // print warning when lmks server not implement. - APP_LOGW("%{public}s(%{public}d) lmks proc prio failed.", __func__, __LINE__); + APP_LOGW("lmks proc prio failed."); } priorityObject->SetCurAdj(oomAdj); @@ -392,19 +382,19 @@ bool ProcessOptimizer::SetAppOomAdj(const AppPtr &app, int oomAdj) bool ProcessOptimizer::SetAppSchedPolicy(const AppPtr &app, const CgroupManager::SchedPolicy schedPolicy) { if (!app) { - APP_LOGE("%{public}s(%{public}d) invalid app.", __func__, __LINE__); + APP_LOGE("invalid app."); return false; } auto priorityObject = app->GetPriorityObject(); if (!priorityObject) { - APP_LOGE("%{public}s(%{public}d) invalid priority object.", __func__, __LINE__); + APP_LOGE("invalid priority object."); return false; } auto oldSchedPolicy = priorityObject->GetCurCgroup(); if (oldSchedPolicy == schedPolicy) { - APP_LOGW("%{public}s(%{public}d) no change.", __func__, __LINE__); + APP_LOGW("no change."); return true; } @@ -470,7 +460,7 @@ void ProcessOptimizer::OnLowMemoryAlert(const CgroupManager::LowMemoryLevel leve bool ProcessOptimizer::UpdateAppOomAdj(const AppPtr &app) { if (!app) { - APP_LOGE("%{public}s(%{public}d) invalid app.", __func__, __LINE__); + APP_LOGE("invalid app."); return false; } APP_LOGI("UpdateAppOomAdj bundleName[%{public}s] state[%{public}d] pid[%{public}d] curadj[%{public}d]", @@ -481,7 +471,7 @@ bool ProcessOptimizer::UpdateAppOomAdj(const AppPtr &app) auto priorityObject = app->GetPriorityObject(); if (!priorityObject) { - APP_LOGE("%{public}s(%{public}d) invalid priority object.", __func__, __LINE__); + APP_LOGE("invalid priority object."); return false; } // special set launcher and systemui adj @@ -497,7 +487,7 @@ bool ProcessOptimizer::UpdateAppOomAdj(const AppPtr &app) int oomAdj; int oomAdjMax; - if(!GetAppOomAdj(app,state,oomAdj, oomAdjMax)){ + if (!GetAppOomAdj(app, state, oomAdj, oomAdjMax)) { return false; } @@ -518,11 +508,11 @@ bool ProcessOptimizer::UpdateAppOomAdj(const AppPtr &app) return true; } -bool ProcessOptimizer::GetAppOomAdj(const AppPtr &app,ApplicationState state,int &oomAdj,int &oomAdjMax) +bool ProcessOptimizer::GetAppOomAdj(const AppPtr &app, ApplicationState state, int &oomAdj, int &oomAdjMax) { auto priorityObject = app->GetPriorityObject(); if (!priorityObject) { - APP_LOGE("%{public}s(%{public}d) invalid priority object.", __func__, __LINE__); + APP_LOGE("invalid priority object."); return false; } @@ -558,7 +548,7 @@ bool ProcessOptimizer::GetAppOomAdj(const AppPtr &app,ApplicationState state,int bool ProcessOptimizer::UpdateAppSchedPolicy(const AppPtr &app) { if (!app) { - APP_LOGE("%{public}s(%{public}d) invalid app.", __func__, __LINE__); + APP_LOGE("invalid app."); return false; } @@ -588,32 +578,26 @@ bool ProcessOptimizer::UpdateAppSchedPolicy(const AppPtr &app) void ProcessOptimizer::StartAppSuspendTimer(const AppPtr &app) { if (!app) { - APP_LOGE("%{public}s(%{public}d) invalid app.", __func__, __LINE__); + APP_LOGE("invalid app."); return; } - APP_LOGI("%{public}s(%{public}d) starting suspend timer for app '%{public}s'...", - __func__, - __LINE__, - app->GetName().c_str()); + APP_LOGI("starting suspend timer for app '%{public}s'...", app->GetName().c_str()); if (!eventHandler_) { - APP_LOGE("%{public}s(%{public}d) invalid event handler.", __func__, __LINE__); + APP_LOGE("invalid event handler."); return; } auto timerName = GetAppSuspendTimerName(app); if (timerName.empty()) { - APP_LOGE("%{public}s(%{public}d) invalid suspend timer name.", __func__, __LINE__); + APP_LOGE("invalid suspend timer name."); return; } auto it = suspendTimers_.find(timerName); if (it != suspendTimers_.end()) { - APP_LOGW("%{public}s(%{public}d) app '%{public}s' suspend timer already started.", - __func__, - __LINE__, - app->GetName().c_str()); + APP_LOGW("app '%{public}s' suspend timer already started.", app->GetName().c_str()); return; } @@ -623,15 +607,13 @@ void ProcessOptimizer::StartAppSuspendTimer(const AppPtr &app) [=]() { auto finder = suspendTimers_.find(timerName); if (finder != suspendTimers_.end()) { - APP_LOGD("%{public}s(%{public}d) removing app '%{public}s' suspend timer name...", + APP_LOGD("removing app '%{public}s' '%{public}s' suspend timer name...", timerName.c_str(), - __LINE__, app->GetName().c_str()); suspendTimers_.erase(finder); } else { - APP_LOGE("%{public}s(%{public}d) invalid suspend timer for app '%{public}s'.", + APP_LOGE("invalid suspend timer for app '%{public}s' '%{public}s'.", timerName.c_str(), - __LINE__, app->GetName().c_str()); } SuspendApp(app); @@ -643,32 +625,26 @@ void ProcessOptimizer::StartAppSuspendTimer(const AppPtr &app) void ProcessOptimizer::StopAppSuspendTimer(const AppPtr &app) { if (!app) { - APP_LOGE("%{public}s(%{public}d) invalid app.", __func__, __LINE__); + APP_LOGE("invalid app."); return; } - APP_LOGI("%{public}s(%{public}d) stopping suspend timer for app '%{public}s'...", - __func__, - __LINE__, - app->GetName().c_str()); + APP_LOGI("stopping suspend timer for app '%{public}s'...", app->GetName().c_str()); if (!eventHandler_) { - APP_LOGE("%{public}s(%{public}d) invalid event handler.", __func__, __LINE__); + APP_LOGE("invalid event handler."); return; } auto timerName = GetAppSuspendTimerName(app); if (timerName.empty()) { - APP_LOGE("%{public}s(%{public}d) invalid suspend timer name.", __func__, __LINE__); + APP_LOGE("invalid suspend timer name."); return; } auto it = suspendTimers_.find(timerName); if (it == suspendTimers_.end()) { - APP_LOGW("%{public}s(%{public}d) app '%{public}s' suspend timer not started.", - __func__, - __LINE__, - app->GetName().c_str()); + APP_LOGW("app '%{public}s' suspend timer not started.", app->GetName().c_str()); return; } @@ -679,20 +655,19 @@ void ProcessOptimizer::StopAppSuspendTimer(const AppPtr &app) void ProcessOptimizer::SuspendApp(const AppPtr &app) { if (!app) { - APP_LOGE("%{public}s(%{public}d) invalid app.", __func__, __LINE__); + APP_LOGE("invalid app."); return; } - APP_LOGI("%{public}s(%{public}d) suspending app '%{public}s'...", __func__, __LINE__, app->GetName().c_str()); + APP_LOGI("suspending app '%{public}s'...", app->GetName().c_str()); if (app->GetState() == ApplicationState::APP_STATE_SUSPENDED) { - APP_LOGE( - "%{public}s(%{public}d) app '%{public}s' already suspended.", __func__, __LINE__, app->GetName().c_str()); + APP_LOGE("app '%{public}s' already suspended.", app->GetName().c_str()); return; } if (!SetAppSchedPolicy(app, CgroupManager::SCHED_POLICY_FREEZED)) { - APP_LOGE("%{public}s(%{public}d) failed to suspend app '%s'.", __func__, __LINE__, app->GetName().c_str()); + APP_LOGE("failed to suspend app '%s'.", app->GetName().c_str()); } } @@ -712,10 +687,10 @@ std::string ProcessOptimizer::GetAppSuspendTimerName(const AppPtr &app) void ProcessOptimizer::SetAppFreezingTime(int time) { - APP_LOGE("%{public}s input second time:[%{public}d]", __func__, time); + APP_LOGE("input second time:[%{public}d]", time); if (time > APP_SUSPEND_TIMEOUT_MAX && time < 0) { - APP_LOGE("%{public}s input time error.", __func__); + APP_LOGE("input time error."); return; } @@ -727,7 +702,7 @@ void ProcessOptimizer::SetAppFreezingTime(int time) void ProcessOptimizer::GetAppFreezingTime(int &time) { time = suspendTimeout_ / TIME_ADVANCE_RATE; - APP_LOGE("%{public}s current freez time:[%{public}d]", __func__, time); + APP_LOGE("current freez time:[%{public}d]", time); return; } } // namespace AppExecFwk diff --git a/services/appmgr/src/process_optimizer_uba.cpp b/services/appmgr/src/process_optimizer_uba.cpp index 9e01e969e3fe8a80af9775e5bd6308c72fb9a50b..b69c6542cc7c2e49f8a1e34915c49e8a9e5cb9b1 100644 --- a/services/appmgr/src/process_optimizer_uba.cpp +++ b/services/appmgr/src/process_optimizer_uba.cpp @@ -96,7 +96,7 @@ ProcessOptimizerUBA::ProcessOptimizerUBA( const UbaServicePtr &ubaService, const LmksClientPtr &lmksClient, int suspendTimeout) : ProcessOptimizer(lmksClient, suspendTimeout), ubaService_(ubaService), abilityActionCount_(0) { - APP_LOGI("%{public}s(%{public}d) constructed.", __func__, __LINE__); + APP_LOGI("ProcessOptimizerUBA ProcessOptimizerUBA start !"); } ProcessOptimizerUBA::~ProcessOptimizerUBA() @@ -104,15 +104,13 @@ ProcessOptimizerUBA::~ProcessOptimizerUBA() if (abilityActionCount_ > 0) { CommitAbilityActions(); } - - APP_LOGI("%{public}s(%{public}d) destructed.", __func__, __LINE__); } void ProcessOptimizerUBA::OnAppAdded(const AppPtr &app) { auto ubaService = GetUbaService(); if (ubaService) { - APP_LOGD("%{public}s(%{public}d) ubaService implement.", __func__, __LINE__); + APP_LOGD("ubaService implement."); } else { ProcessOptimizer::OnAppAdded(app); } @@ -122,7 +120,7 @@ void ProcessOptimizerUBA::OnAppRemoved(const AppPtr &app) { auto ubaService = GetUbaService(); if (ubaService) { - APP_LOGD("%{public}s(%{public}d) ubaService implement.", __func__, __LINE__); + APP_LOGD("ubaService implement."); } else { ProcessOptimizer::OnAppRemoved(app); } @@ -132,7 +130,7 @@ void ProcessOptimizerUBA::OnAppStateChanged(const AppPtr &app, const Application { auto ubaService = GetUbaService(); if (ubaService) { - APP_LOGD("%{public}s(%{public}d) ubaService implement.", __func__, __LINE__); + APP_LOGD("ubaService implement."); } else { ProcessOptimizer::OnAppStateChanged(app, oldState); } @@ -141,7 +139,7 @@ void ProcessOptimizerUBA::OnAppStateChanged(const AppPtr &app, const Application void ProcessOptimizerUBA::OnAbilityStarted(const AbilityPtr &ability) { if (!ability) { - APP_LOGE("%{public}s(%{public}d) invalid ability.", __func__, __LINE__); + APP_LOGE("invalid ability."); return; } @@ -152,14 +150,14 @@ void ProcessOptimizerUBA::OnAbilityStarted(const AbilityPtr &ability) // 'preAbility' can be a nullptr. preAbility = GetAbilityByToken(preToken); } else { - APP_LOGW("%{public}s(%{public}d) 'GetAbilityByToken' is not registered.", __func__, __LINE__); + APP_LOGW(" 'GetAbilityByToken' is not registered."); } RecordAbilityAction(ability, preAbility); auto ubaService = GetUbaService(); if (ubaService) { - APP_LOGD("%{public}s(%{public}d) ubaService implement.", __func__, __LINE__); + APP_LOGD("ubaService implement."); } else { ProcessOptimizer::OnAbilityStarted(ability); } @@ -168,12 +166,12 @@ void ProcessOptimizerUBA::OnAbilityStarted(const AbilityPtr &ability) void ProcessOptimizerUBA::OnAbilityConnected(const AbilityPtr &ability, const AbilityPtr &targetAbility) { if (!ability) { - APP_LOGE("%{public}s(%{public}d) invalid ability.", __func__, __LINE__); + APP_LOGE("invalid ability."); return; } if (!targetAbility) { - APP_LOGE("%{public}s(%{public}d) invalid targetAbility.", __func__, __LINE__); + APP_LOGE("invalid targetAbility."); return; } @@ -181,7 +179,7 @@ void ProcessOptimizerUBA::OnAbilityConnected(const AbilityPtr &ability, const Ab auto ubaService = GetUbaService(); if (ubaService) { - APP_LOGD("%{public}s(%{public}d) ubaService implement.", __func__, __LINE__); + APP_LOGD("ubaService implement."); } else { ProcessOptimizer::OnAbilityConnected(ability, targetAbility); } @@ -190,12 +188,12 @@ void ProcessOptimizerUBA::OnAbilityConnected(const AbilityPtr &ability, const Ab void ProcessOptimizerUBA::OnAbilityDisconnected(const AbilityPtr &ability, const AbilityPtr &targetAbility) { if (!ability) { - APP_LOGE("%{public}s(%{public}d) invalid ability.", __func__, __LINE__); + APP_LOGE("invalid ability."); return; } if (!targetAbility) { - APP_LOGE("%{public}s(%{public}d) invalid targetAbility.", __func__, __LINE__); + APP_LOGE("invalid targetAbility."); return; } @@ -203,7 +201,7 @@ void ProcessOptimizerUBA::OnAbilityDisconnected(const AbilityPtr &ability, const auto ubaService = GetUbaService(); if (ubaService) { - APP_LOGD("%{public}s(%{public}d) ubaService implement.", __func__, __LINE__); + APP_LOGD("ubaService implement."); } else { ProcessOptimizer::OnAbilityDisconnected(ability, targetAbility); } @@ -212,14 +210,14 @@ void ProcessOptimizerUBA::OnAbilityDisconnected(const AbilityPtr &ability, const void ProcessOptimizerUBA::OnAbilityStateChanged(const AbilityPtr &ability, const AbilityState oldState) { if (!ability) { - APP_LOGE("%{public}s(%{public}d) invalid ability.", __func__, __LINE__); + APP_LOGE("invalid ability."); return; } RecordAbilityAction(ability, oldState); auto ubaService = GetUbaService(); if (ubaService) { - APP_LOGD("%{public}s(%{public}d) ubaService implement.", __func__, __LINE__); + APP_LOGD("ubaService implement."); } else { ProcessOptimizer::OnAbilityStateChanged(ability, oldState); } @@ -228,14 +226,14 @@ void ProcessOptimizerUBA::OnAbilityStateChanged(const AbilityPtr &ability, const void ProcessOptimizerUBA::OnAbilityVisibleChanged(const AbilityPtr &ability) { if (!ability) { - APP_LOGE("%{public}s(%{public}d) invalid ability.", __func__, __LINE__); + APP_LOGE("invalid ability."); return; } RecordAbilityAction(ability); auto ubaService = GetUbaService(); if (ubaService) { - APP_LOGD("%{public}s(%{public}d) ubaService implement.", __func__, __LINE__); + APP_LOGD("ubaService implement."); } else { ProcessOptimizer::OnAbilityVisibleChanged(ability); } @@ -244,14 +242,14 @@ void ProcessOptimizerUBA::OnAbilityVisibleChanged(const AbilityPtr &ability) void ProcessOptimizerUBA::OnAbilityPerceptibleChanged(const AbilityPtr &ability) { if (!ability) { - APP_LOGE("%{public}s(%{public}d) invalid ability.", __func__, __LINE__); + APP_LOGE("invalid ability."); return; } RecordAbilityAction(ability); auto ubaService = GetUbaService(); if (ubaService) { - APP_LOGD("%{public}s(%{public}d) ubaService implement.", __func__, __LINE__); + APP_LOGD("ubaService implement."); } else { ProcessOptimizer::OnAbilityPerceptibleChanged(ability); } @@ -260,7 +258,7 @@ void ProcessOptimizerUBA::OnAbilityPerceptibleChanged(const AbilityPtr &ability) void ProcessOptimizerUBA::OnAbilityRemoved(const AbilityPtr &ability) { if (!ability) { - APP_LOGE("%{public}s(%{public}d) invalid ability.", __func__, __LINE__); + APP_LOGE("invalid ability."); return; } @@ -268,7 +266,7 @@ void ProcessOptimizerUBA::OnAbilityRemoved(const AbilityPtr &ability) auto ubaService = GetUbaService(); if (ubaService) { - APP_LOGD("%{public}s(%{public}d) ubaService implement.", __func__, __LINE__); + APP_LOGD("ubaService implement."); } else { ProcessOptimizer::OnAbilityRemoved(ability); } @@ -278,7 +276,7 @@ void ProcessOptimizerUBA::OnLowMemoryAlert(const CgroupManager::LowMemoryLevel l { auto ubaService = GetUbaService(); if (ubaService) { - APP_LOGD("%{public}s(%{public}d) ubaService implement.", __func__, __LINE__); + APP_LOGD("ubaService implement."); } else { ProcessOptimizer::OnLowMemoryAlert(level); } @@ -290,11 +288,11 @@ void ProcessOptimizerUBA::CommitAbilityActions() abilityActionCount_ = 0; auto ubaService = GetUbaService(); if (!ubaService) { - APP_LOGE("%{public}s(%{pubic}d) uba is not available.", __func__, __LINE__); + APP_LOGE("uba is not available."); return; } - APP_LOGI("%{public}s(%{pubic}d) committing %{public}zu actions...", __func__, __LINE__, n); + APP_LOGI("committing %{public}zu actions...", n); for (size_t i = 0; i < n; ++i) { auto &abilityAction = abilityActionCache_[i]; @@ -391,7 +389,7 @@ void ProcessOptimizerUBA::SetAppFreezingTime(int time) { auto ubaService = GetUbaService(); if (ubaService) { - APP_LOGD("%{public}s(%{public}d) ubaService implement.", __func__, __LINE__); + APP_LOGD("ubaService implement."); } else { ProcessOptimizer::SetAppFreezingTime(time); } @@ -401,7 +399,7 @@ void ProcessOptimizerUBA::GetAppFreezingTime(int &time) { auto ubaService = GetUbaService(); if (ubaService) { - APP_LOGD("%{public}s(%{public}d) ubaService implement.", __func__, __LINE__); + APP_LOGD("ubaService implement."); } else { ProcessOptimizer::GetAppFreezingTime(time); } diff --git a/services/appmgr/src/system_environment_information.cpp b/services/appmgr/src/system_environment_information.cpp index a44d03e73cbdddd18a4035055359ec47d2d74f59..dd50b8b03d1807449d30c54a66f07d4ab60fe095 100644 --- a/services/appmgr/src/system_environment_information.cpp +++ b/services/appmgr/src/system_environment_information.cpp @@ -37,10 +37,10 @@ void KernelSystemMemoryInfo::Init(std::map &memInfo) auto findData = [&] (const std::string& key) -> std::string { auto iter = memInfo.find(key); if (iter != memInfo.end()) { - APP_LOGD("%{public}s, key[%{public}s] data[%{public}s]", __func__, key.c_str(), iter->second.c_str()); + APP_LOGD("key[%{public}s] data[%{public}s]", key.c_str(), iter->second.c_str()); return iter->second; } else { - APP_LOGE("%{public}s, key[%{public}s]", __func__, key.c_str()); + APP_LOGE("key[%{public}s]", key.c_str()); return std::string(""); } }; @@ -92,7 +92,7 @@ static void RequestSystemMemoryInfo(std::map &memInfo) FILE *fp = popen("cat /proc/meminfo", "r"); if (fp == nullptr) { - APP_LOGE("%{public}s, open meminfo failed", __func__); + APP_LOGE("open meminfo failed"); return; } @@ -104,14 +104,14 @@ static void RequestSystemMemoryInfo(std::map &memInfo) bool flag = false; flag = std::regex_search(strbuf, sm, rLabel); if (!flag) { - APP_LOGE("%{public}s, open meminfo failed", __func__); + APP_LOGE("open meminfo failed"); continue; } std::string strLabel = sm[0]; strbuf = sm.suffix().str(); flag = std::regex_search(strbuf, sm, rData); if (!flag) { - APP_LOGE("%{public}s, open meminfo failed", __func__); + APP_LOGE("open meminfo failed"); continue; } std::string strData = sm[0]; diff --git a/services/appmgr/test/BUILD.gn b/services/appmgr/test/BUILD.gn index d65202818ebc18eebd071e6e074d4d4c9df4322f..a4bea5928c773a0a4a75bb767a14c07684d24254 100644 --- a/services/appmgr/test/BUILD.gn +++ b/services/appmgr/test/BUILD.gn @@ -46,7 +46,6 @@ ohos_source_set("appmgr_test_source") { "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core/src/appmgr/app_mgr_stub.cpp", "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core/src/appmgr/app_process_data.cpp", "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core/src/appmgr/app_record_id.cpp", - "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core/src/appmgr/app_resident_process_info.cpp", "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core/src/appmgr/app_scheduler_host.cpp", "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core/src/appmgr/app_scheduler_proxy.cpp", "${appexecfwk_path}/interfaces/innerkits/appexecfwk_core/src/appmgr/app_state_callback_host.cpp", diff --git a/services/appmgr/test/mock/include/mock_app_mgr_service.h b/services/appmgr/test/mock/include/mock_app_mgr_service.h index 7bdbccfdbbb1e5b36dffd7c90810ce7c4570386b..0d4774e6447bc84b1bdefdef6e69665e9ccf1a7a 100644 --- a/services/appmgr/test/mock/include/mock_app_mgr_service.h +++ b/services/appmgr/test/mock/include/mock_app_mgr_service.h @@ -86,7 +86,6 @@ public: return; } AppProcessData processData; - processData.appName = ""; processData.pid = 1; processData.appState = ApplicationState::APP_STATE_BEGIN; callback_->OnAppStateChanged(processData); diff --git a/services/appmgr/test/mock/include/mock_app_scheduler.h b/services/appmgr/test/mock/include/mock_app_scheduler.h index 01c5aab26ecc92c36ee5eea94fcde7dbf41ddf25..7e4ae840d84d2be7cc509de8914ca6b2b54d1a62 100644 --- a/services/appmgr/test/mock/include/mock_app_scheduler.h +++ b/services/appmgr/test/mock/include/mock_app_scheduler.h @@ -39,7 +39,7 @@ public: MOCK_METHOD1(ScheduleShrinkMemory, void(const int)); MOCK_METHOD0(ScheduleLowMemory, void()); MOCK_METHOD0(ScheduleProcessSecurityExit, void()); - MOCK_METHOD1(ScheduleAbilityStageInfo, void(const AppResidentProcessInfo &)); + MOCK_METHOD1(ScheduleAbilityStageInfo, void(const HapModuleInfo &)); }; } // namespace AppExecFwk } // namespace OHOS diff --git a/services/appmgr/test/mock/include/mock_application.h b/services/appmgr/test/mock/include/mock_application.h index 1690dca7f8e9f638a36e1bc03d29577c09043a90..18b55b25e3ea172bc50e20fad83bfeac949b8076 100644 --- a/services/appmgr/test/mock/include/mock_application.h +++ b/services/appmgr/test/mock/include/mock_application.h @@ -34,7 +34,7 @@ public: MOCK_METHOD1(ScheduleProfileChanged, void(const Profile &)); MOCK_METHOD1(ScheduleConfigurationUpdated, void(const Configuration &)); MOCK_METHOD0(ScheduleProcessSecurityExit, void()); - MOCK_METHOD1(ScheduleAbilityStageInfo, void(const AppResidentProcessInfo &)); + MOCK_METHOD1(ScheduleAbilityStageInfo, void(const HapModuleInfo &)); void Post() { diff --git a/services/appmgr/test/mock/include/mock_bundle_manager.h b/services/appmgr/test/mock/include/mock_bundle_manager.h index 6e837c982c0e4b945a29fb49731b8d55b22dd0d6..7998a9e377cca272e082c1dd073b0fe088c22b9e 100755 --- a/services/appmgr/test/mock/include/mock_bundle_manager.h +++ b/services/appmgr/test/mock/include/mock_bundle_manager.h @@ -29,7 +29,7 @@ namespace OHOS { namespace AppExecFwk { namespace { const std::string COM_OHOS_HELLO = "com.ohos.test.helloworld"; -const int32_t APPLICATION_NUMHELLO = 100; +const int32_t APPLICATION_NUMHELLO = 104; const std::string COM_OHOS_SPECIAL = "com.ohos.test.special"; } // namespace class BundleMgrProxy : public IRemoteProxy { @@ -116,6 +116,12 @@ public: BundleInfo bundleInfo; bundleInfo.applicationInfo = info; + HapModuleInfo hapModuleInfo; + hapModuleInfo.name = "Module"; + HapModuleInfo hapModuleInfo1; + hapModuleInfo1.name = "Module1"; + bundleInfo.hapModuleInfos.push_back(hapModuleInfo); + bundleInfo.hapModuleInfos.push_back(hapModuleInfo1); bundleInfos.push_back(bundleInfo); GTEST_LOG_(INFO) << "bundleInfos size : "< &gids) diff --git a/services/appmgr/test/unittest/ams_ability_running_record_test/ams_ability_running_record_test.cpp b/services/appmgr/test/unittest/ams_ability_running_record_test/ams_ability_running_record_test.cpp index 028cda0ea969c2aa01706e557fe415adcb677f65..632838ca199e3e02d8fbb734a60f11afe05ff666 100644 --- a/services/appmgr/test/unittest/ams_ability_running_record_test/ams_ability_running_record_test.cpp +++ b/services/appmgr/test/unittest/ams_ability_running_record_test/ams_ability_running_record_test.cpp @@ -116,7 +116,16 @@ HWTEST_F(AmsAbilityRunningRecordTest, CreateAbilityRunningRecord_001, TestSize.L abilityInfo->name = GetTestAbilityName(); auto appRunningRecord = GetTestAppRunningRecord(); sptr token = new MockAbilityToken(); - auto abilityRunningRecord = appRunningRecord->AddAbility(token, abilityInfo); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + appRunningRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(token); EXPECT_TRUE(abilityRunningRecord != nullptr); EXPECT_EQ(abilityRunningRecord, appRunningRecord->GetAbilityRunningRecordByToken(token)); @@ -136,7 +145,16 @@ HWTEST_F(AmsAbilityRunningRecordTest, CreateAbilityRunningRecord_002, TestSize.L APP_LOGD("CreateAbilityRunningRecord_002 start."); auto appRunningRecord = GetTestAppRunningRecord(); sptr token = new MockAbilityToken(); - auto abilityRunningRecord = appRunningRecord->AddAbility(token, nullptr); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + appRunningRecord->AddModule(appInfo, nullptr, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(token); EXPECT_TRUE(abilityRunningRecord == nullptr); APP_LOGD("CreateAbilityRunningRecord_002 end."); } @@ -157,12 +175,24 @@ HWTEST_F(AmsAbilityRunningRecordTest, CreateAbilityRunningRecord_003, TestSize.L auto appRunningRecord = GetTestAppRunningRecord(); sptr token = new MockAbilityToken(); - auto abilityRunningRecordFirst = appRunningRecord->AddAbility(token, abilityInfo); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + appRunningRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecordFirst = moduleRecord->GetAbilityRunningRecordByToken(token); EXPECT_TRUE(abilityRunningRecordFirst != nullptr); EXPECT_EQ(abilityRunningRecordFirst, appRunningRecord->GetAbilityRunningRecordByToken(token)); - auto abilityRunningRecordSecond = appRunningRecord->AddAbility(token, abilityInfo); - EXPECT_TRUE(abilityRunningRecordSecond == nullptr); + appRunningRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecordSecond = moduleRecord->GetAbilityRunningRecordByToken(token); + EXPECT_TRUE(abilityRunningRecordSecond == abilityRunningRecordFirst); APP_LOGD("CreateAbilityRunningRecord_003 end."); } @@ -181,8 +211,17 @@ HWTEST_F(AmsAbilityRunningRecordTest, UpdateAbilityRunningRecord_001, TestSize.L auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); sptr token = new MockAbilityToken(); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + appRunningRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(token); - auto abilityRunningRecord = appRunningRecord->AddAbility(token, abilityInfo); EXPECT_TRUE(abilityRunningRecord != nullptr); abilityRunningRecord->SetState(AbilityState::ABILITY_STATE_READY); appRunningRecord->SetState(ApplicationState::APP_STATE_READY); @@ -215,7 +254,16 @@ HWTEST_F(AmsAbilityRunningRecordTest, UpdateAbilityRunningRecord_002, TestSize.L abilityInfo->name = GetTestAbilityName(); sptr token = new MockAbilityToken(); - auto abilityRunningRecord = appRunningRecord->AddAbility(token, abilityInfo); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + appRunningRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(token); EXPECT_TRUE(abilityRunningRecord != nullptr); AbilityState state = abilityRunningRecord->GetState(); @@ -240,7 +288,16 @@ HWTEST_F(AmsAbilityRunningRecordTest, UpdateAbilityRunningRecord_003, TestSize.L auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); sptr token = new MockAbilityToken(); - auto abilityRunningRecord = appRunningRecord->AddAbility(token, abilityInfo); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + appRunningRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(token); EXPECT_TRUE(abilityRunningRecord != nullptr); AbilityState state = abilityRunningRecord->GetState(); @@ -271,7 +328,16 @@ HWTEST_F(AmsAbilityRunningRecordTest, UpdateAbilityRunningRecord_004, TestSize.L anotherAbilityInfo->name = GetAnotherTestAbilityName(); sptr token2 = new MockAbilityToken(); - auto abilityRunningRecord = appRunningRecord->AddAbility(token, abilityInfo); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + appRunningRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(token); EXPECT_TRUE(abilityRunningRecord != nullptr); AbilityState state = abilityRunningRecord->GetState(); @@ -301,8 +367,21 @@ HWTEST_F(AmsAbilityRunningRecordTest, UpdateAbilityRunningRecord_005, TestSize.L sptr token = new MockAbilityToken(); sptr anotherToken = new MockAbilityToken(); - auto abilityRunningRecord = appRunningRecord->AddAbility(token, abilityInfo); - auto anotherAbilityRunningRecord = appRunningRecord->AddAbility(anotherToken, anotherAbilityInfo); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + appRunningRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(token); + + appRunningRecord->AddModule(appInfo, anotherAbilityInfo, anotherToken, hapModuleInfo); + moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto anotherAbilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(anotherToken); EXPECT_TRUE(abilityRunningRecord != nullptr); EXPECT_TRUE(anotherAbilityRunningRecord != nullptr); @@ -333,8 +412,21 @@ HWTEST_F(AmsAbilityRunningRecordTest, UpdateAbilityRunningRecord_006, TestSize.L anotherAbilityInfo->name = GetAnotherTestAbilityName(); sptr token = new MockAbilityToken(); sptr anotherToken = new MockAbilityToken(); - auto abilityRunningRecord = appRunningRecord->AddAbility(token, abilityInfo); - auto anotherAbilityRunningRecord = appRunningRecord->AddAbility(anotherToken, anotherAbilityInfo); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + appRunningRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(token); + + appRunningRecord->AddModule(appInfo, anotherAbilityInfo, anotherToken, hapModuleInfo); + moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto anotherAbilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(anotherToken); EXPECT_TRUE(abilityRunningRecord != nullptr); EXPECT_TRUE(anotherAbilityRunningRecord != nullptr); anotherAbilityRunningRecord->SetState(AbilityState::ABILITY_STATE_FOREGROUND); @@ -370,8 +462,21 @@ HWTEST_F(AmsAbilityRunningRecordTest, UpdateAbilityRunningRecord_007, TestSize.L anotherAbilityInfo->name = GetAnotherTestAbilityName(); sptr token = new MockAbilityToken(); sptr anotherToken = new MockAbilityToken(); - auto abilityRunningRecord = appRunningRecord->AddAbility(token, abilityInfo); - auto anotherAbilityRunningRecord = appRunningRecord->AddAbility(anotherToken, anotherAbilityInfo); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + appRunningRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(token); + + appRunningRecord->AddModule(appInfo, anotherAbilityInfo, anotherToken, hapModuleInfo); + moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto anotherAbilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(anotherToken); EXPECT_TRUE(abilityRunningRecord != nullptr); EXPECT_TRUE(anotherAbilityRunningRecord != nullptr); anotherAbilityRunningRecord->SetState(AbilityState::ABILITY_STATE_BACKGROUND); @@ -403,7 +508,16 @@ HWTEST_F(AmsAbilityRunningRecordTest, DeleteAbilityRunningRecord_001, TestSize.L auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); sptr token = new MockAbilityToken(); - auto abilityRunningRecord = appRunningRecord->AddAbility(token, abilityInfo); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + appRunningRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(token); EXPECT_TRUE(abilityRunningRecord != nullptr); EXPECT_TRUE(appRunningRecord->GetAbilityRunningRecordByToken(token) != nullptr); @@ -428,9 +542,18 @@ HWTEST_F(AmsAbilityRunningRecordTest, DeleteAbilityRunningRecord_002, TestSize.L auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); sptr token = new MockAbilityToken(); - auto abilityRunnningRecord = appRunningRecord->AddAbility(token, abilityInfo); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; - EXPECT_TRUE(abilityRunnningRecord != nullptr); + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + appRunningRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(token); + + EXPECT_TRUE(abilityRunningRecord != nullptr); EXPECT_TRUE(appRunningRecord->GetAbilityRunningRecordByToken(token) != nullptr); appRunningRecord->ClearAbility(nullptr); @@ -456,8 +579,21 @@ HWTEST_F(AmsAbilityRunningRecordTest, DeleteAbilityRunningRecord_003, TestSize.L anotherAbilityInfo->name = GetAnotherTestAbilityName(); sptr token = new MockAbilityToken(); sptr anotherToken = new MockAbilityToken(); - auto abilityRunningRecord = appRunningRecord->AddAbility(token, abilityInfo); - auto anotherAbilityRunningRecord = appRunningRecord->AddAbility(anotherToken, anotherAbilityInfo); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + appRunningRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(token); + + appRunningRecord->AddModule(appInfo, anotherAbilityInfo, anotherToken, hapModuleInfo); + moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto anotherAbilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(anotherToken); EXPECT_TRUE(abilityRunningRecord != nullptr); EXPECT_TRUE(anotherAbilityRunningRecord != nullptr); @@ -515,7 +651,16 @@ HWTEST_F(AmsAbilityRunningRecordTest, SetGetAbilityRecord_001, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); auto appRunningRecord = GetTestAppRunningRecord(); sptr token = new MockAbilityToken(); - auto abilityRunningRecord = appRunningRecord->AddAbility(token, abilityInfo); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + appRunningRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRunningRecord = moduleRecord->GetAbilityRunningRecordByToken(token); EXPECT_TRUE(abilityRunningRecord != nullptr); abilityRunningRecord->SetVisibility(1); diff --git a/services/appmgr/test/unittest/ams_app_death_recipient_test/BUILD.gn b/services/appmgr/test/unittest/ams_app_death_recipient_test/BUILD.gn index f8c3fc80014ff8d0f2e4e13a9d50f64cf566eb8c..a53b50cf07a62de712dda1ff4adafb10d7ccd94c 100644 --- a/services/appmgr/test/unittest/ams_app_death_recipient_test/BUILD.gn +++ b/services/appmgr/test/unittest/ams_app_death_recipient_test/BUILD.gn @@ -32,6 +32,7 @@ ohos_unittest("AppDeathRecipientTest") { "${services_path}/appmgr/src/app_spawn_socket.cpp", "${services_path}/appmgr/src/cgroup_manager.cpp", "${services_path}/appmgr/src/lmks_client.cpp", + "${services_path}/appmgr/src/module_running_record.cpp", "${services_path}/appmgr/src/process_optimizer.cpp", "${services_path}/appmgr/src/process_optimizer_uba.cpp", "${services_path}/appmgr/src/remote_client_manager.cpp", diff --git a/services/appmgr/test/unittest/ams_app_death_recipient_test/ams_app_death_recipient_test.cpp b/services/appmgr/test/unittest/ams_app_death_recipient_test/ams_app_death_recipient_test.cpp index 002860c65a351fbd2299614996a90bd0309e6f78..e363a5a09825564395af51fd45751302f4c8a04d 100644 --- a/services/appmgr/test/unittest/ams_app_death_recipient_test/ams_app_death_recipient_test.cpp +++ b/services/appmgr/test/unittest/ams_app_death_recipient_test/ams_app_death_recipient_test.cpp @@ -105,6 +105,7 @@ const std::shared_ptr AppDeathRecipientTest::GetAbilityInfoByIndex( std::shared_ptr abilityInfo = std::make_shared(); abilityInfo->name = "AppDeathRecipientTest_ability" + std::to_string(index); abilityInfo->applicationName = "com.ohos.test.helloworld" + std::to_string(index); + abilityInfo->applicationInfo.bundleName = "com.ohos.test.helloworld" + std::to_string(index);; return abilityInfo; } @@ -119,7 +120,12 @@ const std::shared_ptr AppDeathRecipientTest::GetApplicationByIn const std::shared_ptr AppDeathRecipientTest::GetAppRunningRecordByIndex(const int32_t index) const { auto appInfo = GetApplicationByIndex(index); - auto appRecord = appMgrServiceInner_->GetAppRunningRecordByAppName(appInfo->name); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto appRecord = appMgrServiceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, appInfo->name, appInfo->uid, bundleInfo); + EXPECT_NE(nullptr, appRecord); return appRecord; } diff --git a/services/appmgr/test/unittest/ams_app_life_cycle_test/BUILD.gn b/services/appmgr/test/unittest/ams_app_life_cycle_test/BUILD.gn index aa4882cebe1984a888129c9845c6c8a1233da514..53184abe06c68552efcd768d051065cd499714fa 100644 --- a/services/appmgr/test/unittest/ams_app_life_cycle_test/BUILD.gn +++ b/services/appmgr/test/unittest/ams_app_life_cycle_test/BUILD.gn @@ -37,6 +37,7 @@ ohos_unittest("AmsAppLifeCycleTest") { "${services_path}/appmgr/src/app_spawn_socket.cpp", "${services_path}/appmgr/src/cgroup_manager.cpp", "${services_path}/appmgr/src/lmks_client.cpp", + "${services_path}/appmgr/src/module_running_record.cpp", "${services_path}/appmgr/src/process_optimizer.cpp", "${services_path}/appmgr/src/process_optimizer_uba.cpp", "${services_path}/appmgr/src/remote_client_manager.cpp", diff --git a/services/appmgr/test/unittest/ams_app_life_cycle_test/ams_app_life_cycle_test.cpp b/services/appmgr/test/unittest/ams_app_life_cycle_test/ams_app_life_cycle_test.cpp index 79247d637cfbb5b505c9a330baf1620d99088627..59f53707d7fbf16a3e66e97d0097ef94330f1646 100644 --- a/services/appmgr/test/unittest/ams_app_life_cycle_test/ams_app_life_cycle_test.cpp +++ b/services/appmgr/test/unittest/ams_app_life_cycle_test/ams_app_life_cycle_test.cpp @@ -81,6 +81,7 @@ protected: const std::shared_ptr &appRecord, const std::string &index) const; std::shared_ptr AddNewAbility( const std::shared_ptr &appRecord, const std::string &index, const int uid) const; + protected: std::shared_ptr serviceInner_; sptr mock_token_ = nullptr; @@ -120,7 +121,10 @@ std::shared_ptr AmsAppLifeCycleTest::StartProcessAndLoadAbilit serviceInner_->SetAppSpawnClient(mockClientPtr); serviceInner_->LoadAbility(token, preToken, abilityInfo, appInfo); - std::shared_ptr record = serviceInner_->GetAppRunningRecordByAppName(appInfo->name); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + auto record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, abilityInfo->process, appInfo->uid, bundleInfo); EXPECT_EQ(record->GetPriorityObject()->GetPid(), newPid); return record; } @@ -136,6 +140,7 @@ std::shared_ptr AmsAppLifeCycleTest::GetAbilityInfoByIndex(const st abilityInfo->name = "test_ability" + index; abilityInfo->applicationName = "com.ohos.test.helloworld"; abilityInfo->process = "com.ohos.test.helloworld"; + abilityInfo->applicationInfo.bundleName = "com.ohos.test.helloworld"; return abilityInfo; } @@ -171,13 +176,18 @@ TestApplicationPreRecord AmsAppLifeCycleTest::PrepareLoadTestAbilityAndApp(const TestApplicationPreRecord AmsAppLifeCycleTest::CreateTestApplicationRecord( const AbilityState abilityState, const ApplicationState appState) const { - RecordQueryResult result; auto abilityInfo = GetAbilityInfoByIndex("0"); auto appInfo = GetApplication(); sptr token = GetMockToken(); - auto appRecord = serviceInner_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, - "com.ohos.test.helloworld", 0, result); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + std::shared_ptr appRecord = serviceInner_->CreateAppRunningRecord( + token, nullptr, appInfo, abilityInfo, "com.ohos.test.helloworld", bundleInfo, hapModuleInfo); + appRecord->SetEventHandler(handler_); EXPECT_NE(appRecord, nullptr); auto abilityRecord = appRecord->GetAbilityRunningRecordByToken(GetMockToken()); @@ -193,15 +203,20 @@ TestApplicationPreRecord AmsAppLifeCycleTest::CreateTestApplicationRecord( std::shared_ptr AmsAppLifeCycleTest::CreateTestApplicationAndSetState( const ApplicationState appState) const { - RecordQueryResult result; auto abilityInfo = GetAbilityInfoByIndex("0"); auto appInfo = GetApplication(); sptr token = GetMockToken(); - auto appRecord = - serviceInner_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, "AmsAppLifeCycleTest", 0, result); + + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + std::shared_ptr appRecord = serviceInner_->CreateAppRunningRecord( + token, nullptr, appInfo, abilityInfo, "AmsAppLifeCycleTest", bundleInfo, hapModuleInfo); + EXPECT_NE(appRecord, nullptr); appRecord->SetEventHandler(handler_); - EXPECT_EQ(appRecord->GetRecordId(), result.appRecordId); appRecord->SetState(appState); return appRecord; } @@ -289,7 +304,7 @@ std::shared_ptr AmsAppLifeCycleTest::AddNewAbility( /* * Feature: AMS - * Function: AppLifeCycle::GetOrCreateAppRunningRecord + * Function: AppLifeCycle::CreateAppRunningRecord * SubFunction: bundleMgr CheckPermission * FunctionPoints: UnsuspendApplication * CaseDescription: Check if there is background operation permission @@ -315,12 +330,11 @@ HWTEST_F(AmsAppLifeCycleTest, RemoveAppFromRecentList_001, TestSize.Level1) abilityInfo2->name = "test_ability_1"; abilityInfo2->applicationName = "com.ohos.test.special"; abilityInfo2->process = "com.ohos.test.special"; - abilityInfo->applicationInfo.uid = 101; + abilityInfo2->applicationInfo.bundleName = "com.ohos.test.special"; auto appInfo2 = std::make_shared(); appInfo2->name = "com.ohos.test.special"; appInfo2->bundleName = "com.ohos.test.special"; - appInfo->uid = 101; sptr token2 = GetMockToken(); auto appRecord2 = StartProcessAndLoadAbility(token2, nullptr, abilityInfo2, appInfo2, 101); @@ -340,7 +354,7 @@ HWTEST_F(AmsAppLifeCycleTest, RemoveAppFromRecentList_001, TestSize.Level1) EXPECT_CALL(*mockAppScheduler, ScheduleProcessSecurityExit()).Times(1); serviceInner_->RemoveAppFromRecentList(appRecord2->GetName(), appRecord2->GetName()); sleep(3); - + auto list = serviceInner_->GetRecentAppList(); size = list.size(); EXPECT_EQ(size, 0); @@ -450,7 +464,7 @@ HWTEST_F(AmsAppLifeCycleTest, Schedule_003, TestSize.Level1) HWTEST_F(AmsAppLifeCycleTest, Schedule_004, TestSize.Level1) { TestApplicationPreRecord testAppRecord = PrepareLoadTestAbilityAndApp(ApplicationState::APP_STATE_READY); - + testAppRecord.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleLaunchAbility(_, _)).Times(1); auto newAbilityRecord = AddNewAbility(testAppRecord.appRecord_, "1"); EXPECT_EQ(AbilityState::ABILITY_STATE_READY, newAbilityRecord->GetState()); @@ -467,7 +481,7 @@ HWTEST_F(AmsAppLifeCycleTest, Schedule_004, TestSize.Level1) HWTEST_F(AmsAppLifeCycleTest, Schedule_005, TestSize.Level1) { TestApplicationPreRecord testAppRecord = PrepareLoadTestAbilityAndApp(ApplicationState::APP_STATE_FOREGROUND); - + testAppRecord.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleLaunchAbility(_, _)).Times(1); auto newAbilityRecord = AddNewAbility(testAppRecord.appRecord_, "1"); EXPECT_EQ(AbilityState::ABILITY_STATE_READY, newAbilityRecord->GetState()); @@ -484,8 +498,8 @@ HWTEST_F(AmsAppLifeCycleTest, Schedule_005, TestSize.Level1) HWTEST_F(AmsAppLifeCycleTest, Schedule_006, TestSize.Level1) { TestApplicationPreRecord testAppRecord = PrepareLoadTestAbilityAndApp(ApplicationState::APP_STATE_BACKGROUND); + testAppRecord.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleLaunchAbility(_, _)).Times(1); - auto newAbilityRecord = AddNewAbility(testAppRecord.appRecord_, "1"); EXPECT_EQ(AbilityState::ABILITY_STATE_READY, newAbilityRecord->GetState()); EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, testAppRecord.appRecord_->GetState()); @@ -501,7 +515,7 @@ HWTEST_F(AmsAppLifeCycleTest, Schedule_006, TestSize.Level1) HWTEST_F(AmsAppLifeCycleTest, Schedule_007, TestSize.Level1) { TestApplicationPreRecord testAppRecord = PrepareLoadTestAbilityAndApp(ApplicationState::APP_STATE_SUSPENDED); - + testAppRecord.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleLaunchAbility(_, _)).Times(1); auto newAbilityRecord = AddNewAbility(testAppRecord.appRecord_, "1"); EXPECT_EQ(AbilityState::ABILITY_STATE_READY, newAbilityRecord->GetState()); @@ -831,7 +845,15 @@ HWTEST_F(AmsAppLifeCycleTest, Schedule_029, TestSize.Level1) CreateTestApplicationRecord(AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND); auto newAbilityInfo = GetAbilityInfoByIndex("1"); sptr newToken = new MockAbilityToken(); - auto newAbilityRecord = testAppPreRecord.appRecord_->AddAbility(newToken, newAbilityInfo); + + auto appInfo = GetApplication(); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + testAppPreRecord.appRecord_->AddModule(appInfo, newAbilityInfo, newToken, hapModuleInfo); + auto moduleRecord = + testAppPreRecord.appRecord_->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto newAbilityRecord = moduleRecord->GetAbilityRunningRecordByToken(newToken); newAbilityRecord->SetState(AbilityState::ABILITY_STATE_FOREGROUND); EXPECT_NE(newAbilityRecord, nullptr); @@ -1005,8 +1027,9 @@ HWTEST_F(AmsAppLifeCycleTest, Schedule_042, TestSize.Level1) { auto testAppRecord = CreateTestApplicationRecord(AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND); - EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleLaunchAbility(_, _)).Times(1); - auto newAbilityRecord = AddNewAbility(testAppRecord.appRecord_, "1", 0); + testAppRecord.appRecord_->LaunchPendingAbilities(); + EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleLaunchAbility(_, _)).Times(1); + auto newAbilityRecord = AddNewAbility(testAppRecord.appRecord_, "1", -1); newAbilityRecord->SetState(AbilityState::ABILITY_STATE_BACKGROUND); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleCleanAbility(_)).Times(1); @@ -1028,7 +1051,7 @@ HWTEST_F(AmsAppLifeCycleTest, Schedule_043, TestSize.Level1) { auto testAppRecord = CreateTestApplicationRecord(AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND); - + testAppRecord.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleCleanAbility(_)).Times(1); serviceInner_->TerminateAbility(GetMockToken()); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleTerminateApplication()).Times(1); @@ -1037,7 +1060,11 @@ HWTEST_F(AmsAppLifeCycleTest, Schedule_043, TestSize.Level1) EXPECT_EQ(nullptr, abilityRecord); serviceInner_->ApplicationTerminated(testAppRecord.appRecord_->GetRecordId()); - auto appRecord = serviceInner_->GetAppRunningRecordByAppName(testAppRecord.appRecord_->GetName()); + auto appInfo = GetApplication(); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, appInfo->name, appInfo->uid, bundleInfo); EXPECT_EQ(nullptr, appRecord); } @@ -1052,9 +1079,9 @@ HWTEST_F(AmsAppLifeCycleTest, Schedule_044, TestSize.Level1) { auto testAppRecord = CreateTestApplicationRecord(AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND); - + testAppRecord.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleLaunchAbility(_, _)).Times(1); - auto newAbilityRecord = AddNewAbility(testAppRecord.appRecord_, "1", 0); + auto newAbilityRecord = AddNewAbility(testAppRecord.appRecord_, "1", -1); newAbilityRecord->SetState(AbilityState::ABILITY_STATE_BACKGROUND); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleCleanAbility(_)).Times(1); @@ -1076,7 +1103,7 @@ HWTEST_F(AmsAppLifeCycleTest, Schedule_045, TestSize.Level1) { auto testAppRecord = CreateTestApplicationRecord(AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_SUSPENDED); - + testAppRecord.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleCleanAbility(_)).Times(1); serviceInner_->TerminateAbility(GetMockToken()); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleTerminateApplication()).Times(1); @@ -1085,7 +1112,12 @@ HWTEST_F(AmsAppLifeCycleTest, Schedule_045, TestSize.Level1) EXPECT_EQ(nullptr, abilityRecord); serviceInner_->ApplicationTerminated(testAppRecord.appRecord_->GetRecordId()); - auto appRecord = serviceInner_->GetAppRunningRecordByAppName(testAppRecord.appRecord_->GetName()); + + auto appInfo = GetApplication(); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, appInfo->name, appInfo->uid, bundleInfo); EXPECT_EQ(nullptr, appRecord); } @@ -1100,9 +1132,9 @@ HWTEST_F(AmsAppLifeCycleTest, Schedule_046, TestSize.Level1) { auto testAppRecord = CreateTestApplicationRecord(AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_SUSPENDED); - + testAppRecord.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleLaunchAbility(_, _)).Times(1); - auto newAbilityRecord = AddNewAbility(testAppRecord.appRecord_, "1", 0); + auto newAbilityRecord = AddNewAbility(testAppRecord.appRecord_, "1", -1); newAbilityRecord->SetState(AbilityState::ABILITY_STATE_BACKGROUND); testAppRecord.appRecord_->SetState(ApplicationState::APP_STATE_SUSPENDED); @@ -1464,7 +1496,10 @@ HWTEST_F(AmsAppLifeCycleTest, KillApplication_002, TestSize.Level1) serviceInner_->SetAppSpawnClient(mockClientPtr); serviceInner_->LoadAbility(token, nullptr, abilityInfo, appInfo); - std::shared_ptr appRecord = serviceInner_->GetAppRunningRecordByAppName(appInfo->name); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, appInfo->name, appInfo->uid, bundleInfo); EXPECT_EQ(appRecord->GetPriorityObject()->GetPid(), NEW_PID); pid_t pid = fork(); @@ -1682,7 +1717,7 @@ HWTEST_F(AmsAppLifeCycleTest, AppStateChanged001, TestSize.Level1) HWTEST_F(AmsAppLifeCycleTest, Unsuspend_001, TestSize.Level1) { TestApplicationPreRecord testAppRecord = PrepareLoadTestAbilityAndApp(ApplicationState::APP_STATE_FOREGROUND); - + testAppRecord.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleLaunchAbility(_, _)).Times(1); auto newAbilityRecord = AddNewAbility(testAppRecord.appRecord_, "1"); EXPECT_EQ(AbilityState::ABILITY_STATE_READY, newAbilityRecord->GetState()); @@ -1705,7 +1740,7 @@ HWTEST_F(AmsAppLifeCycleTest, Unsuspend_001, TestSize.Level1) HWTEST_F(AmsAppLifeCycleTest, Unsuspend_002, TestSize.Level1) { TestApplicationPreRecord testAppRecord = PrepareLoadTestAbilityAndApp(ApplicationState::APP_STATE_FOREGROUND); - + testAppRecord.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleLaunchAbility(_, _)).Times(1); auto newAbilityRecord = AddNewAbility(testAppRecord.appRecord_, "1"); EXPECT_EQ(AbilityState::ABILITY_STATE_READY, newAbilityRecord->GetState()); @@ -1728,7 +1763,7 @@ HWTEST_F(AmsAppLifeCycleTest, Unsuspend_002, TestSize.Level1) HWTEST_F(AmsAppLifeCycleTest, Suspend_001, TestSize.Level1) { TestApplicationPreRecord testAppRecord = PrepareLoadTestAbilityAndApp(ApplicationState::APP_STATE_FOREGROUND); - + testAppRecord.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleLaunchAbility(_, _)).Times(1); auto newAbilityRecord = AddNewAbility(testAppRecord.appRecord_, "1"); EXPECT_EQ(AbilityState::ABILITY_STATE_READY, newAbilityRecord->GetState()); @@ -1749,7 +1784,7 @@ HWTEST_F(AmsAppLifeCycleTest, Suspend_001, TestSize.Level1) HWTEST_F(AmsAppLifeCycleTest, Suspend_002, TestSize.Level1) { TestApplicationPreRecord testAppRecord = PrepareLoadTestAbilityAndApp(ApplicationState::APP_STATE_FOREGROUND); - + testAppRecord.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(testAppRecord.mockAppScheduler_), ScheduleLaunchAbility(_, _)).Times(1); auto newAbilityRecord = AddNewAbility(testAppRecord.appRecord_, "1"); EXPECT_EQ(AbilityState::ABILITY_STATE_READY, newAbilityRecord->GetState()); @@ -1903,113 +1938,60 @@ HWTEST_F(AmsAppLifeCycleTest, IsBackgroundRunningRestricted_001, TestSize.Level1 /* * Feature: AMS - * Function: AppLifeCycle::GetOrCreateAppRunningRecord + * Function: AppLifeCycle::CreateAppRunningRecord * SubFunction: bundleMgr CheckPermission * FunctionPoints: UnsuspendApplication * CaseDescription: Check if there is background operation permission */ -HWTEST_F(AmsAppLifeCycleTest, GetOrCreateAppRunningRecord_001, TestSize.Level1) +HWTEST_F(AmsAppLifeCycleTest, CreateAppRunningRecord_001, TestSize.Level1) { - RecordQueryResult result; auto abilityInfo = GetAbilityInfoByIndex("0"); auto appInfo = GetApplication(); sptr token = GetMockToken(); - auto appRecord = serviceInner_->GetOrCreateAppRunningRecord(nullptr, appInfo, abilityInfo, "test_app", 100, result); - EXPECT_FALSE(appRecord); - appRecord = serviceInner_->GetOrCreateAppRunningRecord(token, nullptr, abilityInfo, "test_app", 100, result); - EXPECT_FALSE(appRecord); - appRecord = serviceInner_->GetOrCreateAppRunningRecord(token, appInfo, nullptr, "test_app", 100, result); - EXPECT_FALSE(appRecord); - appRecord = serviceInner_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, "test_app", -1, result); - EXPECT_FALSE(appRecord); - appRecord = serviceInner_->GetOrCreateAppRunningRecord( - token, appInfo, abilityInfo, "test_app", std::numeric_limits::max(), result); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + std::shared_ptr appRecord = serviceInner_->CreateAppRunningRecord( + nullptr, nullptr, appInfo, abilityInfo, "test_app", bundleInfo, hapModuleInfo); + EXPECT_TRUE(appRecord); + appRecord = serviceInner_->CreateAppRunningRecord( + token, nullptr, nullptr, abilityInfo, "test_app", bundleInfo, hapModuleInfo); EXPECT_FALSE(appRecord); - appRecord = serviceInner_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, "", 100, result); + appRecord = + serviceInner_->CreateAppRunningRecord(token, nullptr, appInfo, nullptr, "test_app", bundleInfo, hapModuleInfo); + EXPECT_TRUE(appRecord); + appRecord = + serviceInner_->CreateAppRunningRecord(token, nullptr, appInfo, abilityInfo, "", bundleInfo, hapModuleInfo); EXPECT_FALSE(appRecord); } /* * Feature: AMS - * Function: AppLifeCycle::GetOrCreateAppRunningRecord + * Function: AppLifeCycle::CreateAppRunningRecord * SubFunction: bundleMgr CheckPermission * FunctionPoints: UnsuspendApplication * CaseDescription: Check if there is background operation permission */ -HWTEST_F(AmsAppLifeCycleTest, GetOrCreateAppRunningRecord_002, TestSize.Level1) +HWTEST_F(AmsAppLifeCycleTest, CheckAppRunningRecordIsExist_001, TestSize.Level1) { - RecordQueryResult result; auto abilityInfo = GetAbilityInfoByIndex("0"); auto appInfo = GetApplication(); sptr token = GetMockToken(); - abilityInfo->applicationInfo.uid = 123; - appInfo->uid = 123; - // add one app - auto appRecord = - serviceInner_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, appInfo->name, 123, result); - EXPECT_TRUE(appRecord); - appRecord->SetUid(123); - - // add again - RecordQueryResult result1; - auto appRecord2 = - serviceInner_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, appInfo->name, 123, result1); - EXPECT_TRUE(appRecord2); - - EXPECT_TRUE(result1.appExists); - EXPECT_TRUE(result1.abilityExists); - EXPECT_EQ(appRecord->GetRecordId(), appRecord2->GetRecordId()); - - // same token, new ability, - RecordQueryResult result2; - auto abilityInfo2 = GetAbilityInfoByIndex("1"); - abilityInfo2->applicationInfo.uid = 123; - auto appRecord3 = - serviceInner_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo2, appInfo->name, 123, result2); - EXPECT_TRUE(appRecord3); - EXPECT_TRUE(result2.appExists); - EXPECT_TRUE(result2.abilityExists); - EXPECT_FALSE(appRecord3->GetAbilityRunningRecord(abilityInfo2->name)); - - // new token, new ability - RecordQueryResult result3; - sptr token2 = new MockAbilityToken(); - auto abilityInfo3 = GetAbilityInfoByIndex("2"); - abilityInfo3->applicationInfo.uid = 123; - auto appRecord4 = - serviceInner_->GetOrCreateAppRunningRecord(token2, appInfo, abilityInfo3, appInfo->name, 123, result3); - auto abilityRecord = appRecord4->GetAbilityRunningRecord(abilityInfo3->name); - EXPECT_TRUE(appRecord4); - EXPECT_TRUE(result3.appExists); - EXPECT_FALSE(result3.abilityExists); - EXPECT_TRUE(abilityRecord); -} + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; -/* - * Feature: AMS - * Function: AppLifeCycle::GetOrCreateAppRunningRecord - * SubFunction: bundleMgr CheckPermission - * FunctionPoints: UnsuspendApplication - * CaseDescription: Check if there is background operation permission - */ -HWTEST_F(AmsAppLifeCycleTest, GetAppRunningRecordByProcessName_001, TestSize.Level1) -{ - RecordQueryResult result; - auto abilityInfo = GetAbilityInfoByIndex("0"); - auto appInfo = GetApplication(); - abilityInfo->applicationInfo.uid = 100; - appInfo->uid = 100; - sptr token = GetMockToken(); - - auto appRecord = - serviceInner_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, appInfo->name, 100, result); + std::shared_ptr appRecord = serviceInner_->CreateAppRunningRecord( + token, nullptr, appInfo, abilityInfo, appInfo->name, bundleInfo, hapModuleInfo); EXPECT_TRUE(appRecord); - appRecord->SetUid(100); - auto appRecordProc = - serviceInner_->GetAppRunningRecordByProcessName(appInfo->name, appInfo->name, abilityInfo->applicationInfo.uid); + auto appRecordProc = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, appInfo->name, abilityInfo->applicationInfo.uid, bundleInfo); EXPECT_TRUE(appRecordProc); EXPECT_EQ(appRecord->GetRecordId(), appRecordProc->GetRecordId()); @@ -2023,7 +2005,7 @@ HWTEST_F(AmsAppLifeCycleTest, GetAppRunningRecordByProcessName_001, TestSize.Lev /* * Feature: AMS - * Function: AppLifeCycle::GetOrCreateAppRunningRecord + * Function: AppLifeCycle::CreateAppRunningRecord * SubFunction: bundleMgr CheckPermission * FunctionPoints: UnsuspendApplication * CaseDescription: Check if there is background operation permission @@ -2062,8 +2044,10 @@ HWTEST_F(AmsAppLifeCycleTest, LoadResidentProcess_001, TestSize.Level1) std::string proc = "KeepAliveApplication"; int uid = 2100; int pid = 120; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; - auto appRecord = serviceInner_->GetAppRunningRecordByProcessName(appName, proc, uid); + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, bundleInfo); EXPECT_FALSE(appRecord); MockAppSpawnClient *mockClientPtrT = new (std::nothrow) MockAppSpawnClient(); @@ -2073,7 +2057,7 @@ HWTEST_F(AmsAppLifeCycleTest, LoadResidentProcess_001, TestSize.Level1) serviceInner_->SetAppSpawnClient(std::unique_ptr(mockClientPtrT)); serviceInner_->LoadResidentProcess(); - appRecord = serviceInner_->GetAppRunningRecordByProcessName(appName, proc, uid); + appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, bundleInfo); EXPECT_TRUE(appRecord); } @@ -2089,12 +2073,14 @@ HWTEST_F(AmsAppLifeCycleTest, LoadResidentProcess_002, TestSize.Level1) std::string appName = "KeepAliveApp"; std::string proc = "KeepAliveApplication"; int uid = 2100; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; - auto appRecord = serviceInner_->GetAppRunningRecordByProcessName(appName, proc, uid); + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, bundleInfo); EXPECT_FALSE(appRecord); serviceInner_->LoadResidentProcess(); - appRecord = serviceInner_->GetAppRunningRecordByProcessName(appName, proc, uid); + appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, bundleInfo); EXPECT_FALSE(appRecord); } @@ -2113,10 +2099,14 @@ HWTEST_F(AmsAppLifeCycleTest, StartResidentProcess_001, TestSize.Level1) std::string proc = "KeepAliveApplication"; int uid = 2100; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "KeepAliveApplication"; + std::vector infos; BundleInfo info; info.name = proc; info.uid = uid; + info.hapModuleInfos.push_back(hapModuleInfo); ApplicationInfo appInfo; appInfo.name = "KeepAliveApp"; @@ -2124,8 +2114,10 @@ HWTEST_F(AmsAppLifeCycleTest, StartResidentProcess_001, TestSize.Level1) appInfo.uid = 2100; info.applicationInfo = appInfo; infos.push_back(info); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; - auto appRecord = serviceInner_->GetAppRunningRecordByProcessName(appName, proc, uid); + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, bundleInfo); EXPECT_FALSE(appRecord); MockAppSpawnClient *mockClientPtrT = new (std::nothrow) MockAppSpawnClient(); @@ -2134,12 +2126,112 @@ HWTEST_F(AmsAppLifeCycleTest, StartResidentProcess_001, TestSize.Level1) serviceInner_->SetAppSpawnClient(std::unique_ptr(mockClientPtrT)); - serviceInner_->StartResidentProcess(infos); + serviceInner_->StartResidentProcess(infos, -1); - appRecord = serviceInner_->GetAppRunningRecordByProcessName(appName, proc, uid); + appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, bundleInfo); EXPECT_TRUE(appRecord); pid_t newPid = appRecord->GetPriorityObject()->GetPid(); EXPECT_TRUE(newPid == pid); } + +/* + * Feature: AMS + * Function: AppLifeCycle::StartResidentProcess + * SubFunction: NA + * FunctionPoints: NA + * CaseDescription: NA + */ +HWTEST_F(AmsAppLifeCycleTest, StartResidentProcess_002, TestSize.Level1) +{ + pid_t pid = 123; + sptr token = GetMockToken(); + std::string appName = "KeepAliveApp"; + std::string proc = "KeepAliveApplication"; + int uid = 2100; + + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "KeepAliveApplication"; + std::vector infos; + BundleInfo info; + info.name = proc; + info.uid = uid; + info.hapModuleInfos.push_back(hapModuleInfo); + + ApplicationInfo appInfo; + appInfo.name = "KeepAliveApp"; + appInfo.bundleName = "KeepAliveApplication"; + appInfo.uid = 2100; + info.applicationInfo = appInfo; + infos.push_back(info); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, bundleInfo); + EXPECT_FALSE(appRecord); + + MockAppSpawnClient *mockClientPtrT = new (std::nothrow) MockAppSpawnClient(); + EXPECT_TRUE(mockClientPtrT); + EXPECT_CALL(*mockClientPtrT, StartProcess(_, _)).Times(1).WillOnce(DoAll(SetArgReferee<1>(pid), Return(ERR_OK))); + + serviceInner_->SetAppSpawnClient(std::unique_ptr(mockClientPtrT)); + + serviceInner_->StartResidentProcess(infos, -1); + + appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, bundleInfo); + EXPECT_TRUE(appRecord); + int recordId = appRecord->GetRecordId(); + + // start agin + serviceInner_->StartResidentProcess(infos, -1); + + auto other = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, bundleInfo); + EXPECT_TRUE(other); + int id = other->GetRecordId(); + EXPECT_TRUE(recordId == id); +} + +/* + * Feature: AMS + * Function: AppLifeCycle::RestartResidentProcess + * SubFunction: NA + * FunctionPoints: NA + * CaseDescription: NA + */ +HWTEST_F(AmsAppLifeCycleTest, RestartResidentProcess_001, TestSize.Level1) +{ + sptr token = GetMockToken(); + std::string appName = "KeepAliveApp"; + std::string proc = "KeepAliveApplication"; + int uid = 2100; + + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "KeepAliveApplication"; + std::vector infos; + BundleInfo info; + info.name = proc; + info.uid = uid; + info.hapModuleInfos.push_back(hapModuleInfo); + + ApplicationInfo appInfo; + appInfo.name = "KeepAliveApp"; + appInfo.bundleName = "KeepAliveApplication"; + appInfo.uid = 2100; + info.applicationInfo = appInfo; + infos.push_back(info); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, bundleInfo); + EXPECT_FALSE(appRecord); + + int recordId = 156; + auto app = std::make_shared(appInfo); + auto record = std::make_shared(app, recordId, proc); + serviceInner_->RestartResidentProcess(record); + + appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, bundleInfo); + EXPECT_FALSE(appRecord); +} + } // namespace AppExecFwk } // namespace OHOS \ No newline at end of file diff --git a/services/appmgr/test/unittest/ams_app_running_record_test/ams_app_running_record_test.cpp b/services/appmgr/test/unittest/ams_app_running_record_test/ams_app_running_record_test.cpp index e1550b1c0f0686b59e87794df31669eea1d87dc8..c19f6d37f6846b97ed7c04d74e1aa2695e6d40b5 100644 --- a/services/appmgr/test/unittest/ams_app_running_record_test/ams_app_running_record_test.cpp +++ b/services/appmgr/test/unittest/ams_app_running_record_test/ams_app_running_record_test.cpp @@ -76,6 +76,7 @@ protected: { return mock_token_; } + protected: std::shared_ptr testAbilityRecord_; sptr client_; @@ -131,15 +132,17 @@ std::shared_ptr AmsAppRunningRecordTest::StartLoadAbility(cons const std::shared_ptr &abilityInfo, const std::shared_ptr &appInfo, const pid_t newPid) const { - RecordQueryResult result; std::shared_ptr mockClientPtr = std::make_shared(); service_->SetAppSpawnClient(mockClientPtr); EXPECT_CALL(*mockClientPtr, StartProcess(_, _)).Times(1).WillOnce(DoAll(SetArgReferee<1>(newPid), Return(ERR_OK))); service_->LoadAbility(token, nullptr, abilityInfo, appInfo); - std::shared_ptr record = - service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, GetTestProcessName(), 0, result); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestProcessName(), appInfo->uid, bundleInfo); EXPECT_TRUE(record); auto clent = GetMockedAppSchedulerClient(); @@ -155,7 +158,7 @@ std::shared_ptr AmsAppRunningRecordTest::StartLoadAbility(cons * SubFunction: NA * FunctionPoints: Create using correct args with app/ability not exists. * EnvConditions: NA - * CaseDescription: Call GetOrCreateAppRunningRecord to get result. + * CaseDescription: Call CreateAppRunningRecord to get result. */ HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_001, TestSize.Level1) { @@ -163,17 +166,17 @@ HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_001, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); - RecordQueryResult result; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + bundleInfo.jointUserId = "joint456"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; EXPECT_TRUE(service_ != nullptr); - auto record = service_->GetOrCreateAppRunningRecord( - GetMockToken(), appInfo, abilityInfo, GetTestProcessName(), GetTestUid(), result); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); EXPECT_TRUE(record != nullptr); - EXPECT_EQ(result.error, ERR_OK); EXPECT_EQ(record->GetName(), GetTestAppName()); - EXPECT_FALSE(result.appExists); - EXPECT_FALSE(result.abilityExists); - EXPECT_TRUE(result.appRecordId > 0); EXPECT_EQ(record->GetProcessName(), GetTestProcessName()); @@ -187,7 +190,7 @@ HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_001, TestSize.Level1) * SubFunction: NA * FunctionPoints Create using correct args with app/ability exists. * EnvConditions: NA - * CaseDescription: Call GetOrCreateAppRunningRecord twice to create/get a AppRunningRecord. + * CaseDescription: Call CreateAppRunningRecord twice to create/get a AppRunningRecord. */ HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_002, TestSize.Level1) { @@ -197,25 +200,23 @@ HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_002, TestSize.Level1) appInfo->name = GetTestAppName(); abilityInfo->applicationInfo.uid = 1010; appInfo->uid = 1010; - RecordQueryResult result; - RecordQueryResult result1; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + bundleInfo.jointUserId = "joint456"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; EXPECT_TRUE(service_ != nullptr); // Create sptr token = GetMockToken(); - auto record = - service_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, GetTestProcessName(), GetTestUid(), result); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); record->SetUid(1010); - EXPECT_EQ(result.error, ERR_OK); // Get - auto record1 = - service_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, GetTestProcessName(), GetTestUid(), result1); + auto record1 = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); EXPECT_TRUE(record1 != nullptr); - EXPECT_EQ(result1.error, ERR_OK); EXPECT_EQ(record1->GetName(), GetTestAppName()); EXPECT_EQ(record1->GetProcessName(), GetTestProcessName()); - // Already exists - EXPECT_TRUE(result1.appExists); - EXPECT_TRUE(result1.abilityExists); } /* @@ -224,7 +225,7 @@ HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_002, TestSize.Level1) * SubFunction: NA * FunctionPoints: Create using correct args with app exists but ability not. * EnvConditions: NA - * CaseDescription: Call GetOrCreateAppRunningRecord twice which second call uses a different ability info. + * CaseDescription: Call CreateAppRunningRecord twice which second call uses a different ability info. */ HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_003, TestSize.Level1) { @@ -235,98 +236,53 @@ HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_003, TestSize.Level1) appInfo->bundleName = GetTestAppName(); abilityInfo->applicationInfo.uid = 1010; appInfo->uid = 1010; - RecordQueryResult result; - RecordQueryResult result1; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + bundleInfo.jointUserId = "joint456"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; EXPECT_TRUE(service_ != nullptr); - auto record = service_->GetOrCreateAppRunningRecord( - GetMockToken(), appInfo, abilityInfo, GetTestProcessName(), GetTestUid(), result); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); record->SetUid(1010); - EXPECT_EQ(result.error, ERR_OK); auto anotherAbilityInfo = std::make_shared(); anotherAbilityInfo->name = "Another_ability"; anotherAbilityInfo->applicationInfo.uid = 1010; sptr anotherToken = new (std::nothrow) MockAbilityToken(); - auto record1 = service_->GetOrCreateAppRunningRecord( - anotherToken, appInfo, anotherAbilityInfo, GetTestProcessName(), GetTestUid(), result1); - EXPECT_EQ(result1.error, ERR_OK); + auto record1 = service_->CreateAppRunningRecord( + GetMockToken(), anotherToken, appInfo, anotherAbilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); EXPECT_EQ(record1->GetName(), GetTestAppName()); EXPECT_EQ(record1->GetProcessName(), GetTestProcessName()); - EXPECT_TRUE(result1.appExists); - EXPECT_FALSE(result1.abilityExists); - EXPECT_TRUE(result1.appRecordId > 0); auto abilityRecord = record1->GetAbilityRunningRecordByToken(GetMockToken()); EXPECT_TRUE(abilityRecord != nullptr); } -/* - * Feature: AMS - * Function: AppRunningRecord - * SubFunction: NA - * FunctionPoints: Create using invalid uid (-1). - * EnvConditions: NA - * CaseDescription: Call GetOrCreateAppRunningRecord using uid -1. - */ -HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_004, TestSize.Level1) -{ - auto abilityInfo = std::make_shared(); - abilityInfo->name = GetTestAbilityName(); - auto appInfo = std::make_shared(); - appInfo->name = GetTestAppName(); - RecordQueryResult result; - EXPECT_TRUE(service_ != nullptr); - // Create - auto record = - service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, GetTestProcessName(), -1, result); - EXPECT_TRUE(record == nullptr); - EXPECT_EQ(result.error, ERR_APPEXECFWK_INVALID_UID); -} - -/* - * Feature: AMS - * Function: AppRunningRecord - * SubFunction: NA - * FunctionPoints: Create using invalid uid (int32_max). - * EnvConditions: NA - * CaseDescription: Call GetOrCreateAppRunningRecord using uid int32_max. - */ -HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_005, TestSize.Level1) -{ - auto abilityInfo = std::make_shared(); - abilityInfo->name = GetTestAbilityName(); - auto appInfo = std::make_shared(); - appInfo->name = GetTestAppName(); - RecordQueryResult result; - EXPECT_TRUE(service_ != nullptr); - // Create - auto record = service_->GetOrCreateAppRunningRecord( - GetMockToken(), appInfo, abilityInfo, GetTestProcessName(), std::numeric_limits::max(), result); - EXPECT_TRUE(record == nullptr); - EXPECT_EQ(result.error, ERR_APPEXECFWK_INVALID_UID); -} - /* * Feature: AMS * Function: AppRunningRecord * SubFunction: NA * FunctionPoints: Create using empty appInfo. * EnvConditions: NA - * CaseDescription: Call GetOrCreateAppRunningRecord using empty appInfo. + * CaseDescription: Call CreateAppRunningRecord using empty appInfo. */ -HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_006, TestSize.Level1) +HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_004, TestSize.Level1) { auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); - RecordQueryResult result; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + bundleInfo.jointUserId = "joint456"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; EXPECT_TRUE(service_ != nullptr); // Create - auto record = service_->GetOrCreateAppRunningRecord( - GetMockToken(), nullptr, abilityInfo, GetTestProcessName(), GetTestUid(), result); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, nullptr, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); EXPECT_TRUE(record == nullptr); - EXPECT_EQ(result.error, ERR_INVALID_VALUE); } /* @@ -335,65 +291,22 @@ HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_006, TestSize.Level1) * SubFunction: NA * FunctionPoints: Create using empty abilityInfo. * EnvConditions: NA - * CaseDescription: Call GetOrCreateAppRunningRecord using empty abilityInfo. + * CaseDescription: Call CreateAppRunningRecord using empty abilityInfo. */ -HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_007, TestSize.Level1) -{ - auto appInfo = std::make_shared(); - appInfo->name = GetTestAppName(); - RecordQueryResult result; - EXPECT_TRUE(service_ != nullptr); - // Create - auto record = service_->GetOrCreateAppRunningRecord( - GetMockToken(), appInfo, nullptr, GetTestProcessName(), GetTestUid(), result); - EXPECT_TRUE(record == nullptr); - EXPECT_EQ(result.error, ERR_INVALID_VALUE); -} - -/* - * Feature: AMS - * Function: AppRunningRecord - * SubFunction: NA - * FunctionPoints: Create using valid border uid (0). - * EnvConditions: NA - * CaseDescription: Call GetOrCreateAppRunningRecord using uid 0. - */ -HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_008, TestSize.Level1) -{ - auto abilityInfo = std::make_shared(); - abilityInfo->name = GetTestAbilityName(); - auto appInfo = std::make_shared(); - appInfo->name = GetTestAppName(); - RecordQueryResult result; - EXPECT_TRUE(service_ != nullptr); - // Create - auto record = - service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, GetTestProcessName(), 0, result); - EXPECT_TRUE(record != nullptr); - EXPECT_EQ(result.error, ERR_OK); -} - -/* - * Feature: AMS - * Function: AppRunningRecord - * SubFunction: NA - * FunctionPoints: Create using valid border uid (int32_max - 1). - * EnvConditions: NA - * CaseDescription: Call GetOrCreateAppRunningRecord using uid (int32_max - 1). - */ -HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_009, TestSize.Level1) +HWTEST_F(AmsAppRunningRecordTest, CreateAppRunningRecord_005, TestSize.Level1) { - auto abilityInfo = std::make_shared(); - abilityInfo->name = GetTestAbilityName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); - RecordQueryResult result; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + bundleInfo.jointUserId = "joint456"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; EXPECT_TRUE(service_ != nullptr); // Create - auto record = service_->GetOrCreateAppRunningRecord( - GetMockToken(), appInfo, abilityInfo, GetTestProcessName(), std::numeric_limits::max() - 1, result); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, nullptr, GetTestProcessName(), bundleInfo, hapModuleInfo); EXPECT_TRUE(record != nullptr); - EXPECT_EQ(result.error, ERR_OK); } /* @@ -421,10 +334,16 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchApplication_001, TestSize.Level1) */ HWTEST_F(AmsAppRunningRecordTest, LaunchAbility_001, TestSize.Level1) { + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; auto record = GetTestAppRunningRecord(); EXPECT_TRUE(record); - auto abilityRecord = record->AddAbility(GetMockToken(), nullptr); - + record->AddModule(appInfo, nullptr, GetMockToken(), hapModuleInfo); + auto moduleRecord = record->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRecord = moduleRecord->GetAbilityRunningRecordByToken(GetMockToken()); EXPECT_EQ(nullptr, abilityRecord); EXPECT_CALL(*mockAppSchedulerClient_, ScheduleLaunchAbility(_, _)).Times(0); record->LaunchAbility(abilityRecord); @@ -440,10 +359,17 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchAbility_001, TestSize.Level1) */ HWTEST_F(AmsAppRunningRecordTest, LaunchAbility_002, TestSize.Level1) { + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; auto record = GetTestAppRunningRecord(); - auto abilityRecord = record->AddAbility(GetMockToken(), abilityInfo); + record->AddModule(appInfo, abilityInfo, GetMockToken(), hapModuleInfo); + auto moduleRecord = record->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRecord = moduleRecord->GetAbilityRunningRecordByToken(GetMockToken()); EXPECT_TRUE(abilityRecord); EXPECT_CALL(*mockAppSchedulerClient_, ScheduleLaunchAbility(_, _)).Times(1); @@ -568,7 +494,8 @@ HWTEST_F(AmsAppRunningRecordTest, UpdateAppRunningRecord_002, TestSize.Level1) * SubFunction: NA * FunctionPoints: Delete application record info when application terminated. * EnvConditions: NA - * CaseDescription: Create an AppRunningRecord and call AppMgrService::ApplicationTerminated passing exists |RecordId|. + * CaseDescription: Create an AppRunningRecord and call AppMgrService::ApplicationTerminated passing exists + |RecordId|. */ HWTEST_F(AmsAppRunningRecordTest, DeleteAppRunningRecord_001, TestSize.Level1) { @@ -576,10 +503,14 @@ HWTEST_F(AmsAppRunningRecordTest, DeleteAppRunningRecord_001, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); - RecordQueryResult result; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + bundleInfo.jointUserId = "joint456"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; EXPECT_TRUE(service_ != nullptr); - auto record = - service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, GetTestProcessName(), 0, result); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); EXPECT_TRUE(record != nullptr); record->SetState(ApplicationState::APP_STATE_BACKGROUND); record->SetApplicationClient(GetMockedAppSchedulerClient()); @@ -603,6 +534,7 @@ HWTEST_F(AmsAppRunningRecordTest, AttachApplication_001, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); appInfo->bundleName = GetTestAppName(); @@ -634,6 +566,7 @@ HWTEST_F(AmsAppRunningRecordTest, AttachApplication_002, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); appInfo->bundleName = GetTestAppName(); @@ -664,6 +597,7 @@ HWTEST_F(AmsAppRunningRecordTest, AttachApplication_003, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); appInfo->bundleName = GetTestAppName(); @@ -694,6 +628,7 @@ HWTEST_F(AmsAppRunningRecordTest, AttachApplication_004, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -722,6 +657,7 @@ HWTEST_F(AmsAppRunningRecordTest, AttachApplication_005, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -759,6 +695,7 @@ HWTEST_F(AmsAppRunningRecordTest, AttachApplication_006, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto abilityInfo2 = std::make_shared(); abilityInfo2->name = GetTestAbilityName() + "_1"; @@ -810,15 +747,18 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchAbilityForApp_001, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); - appInfo->name = GetTestAppName(); - RecordQueryResult result; - Profile profile; - EXPECT_TRUE(service_ != nullptr); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + bundleInfo.jointUserId = "joint456"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; - std::shared_ptr record = - service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, GetTestProcessName(), 0, result); + EXPECT_TRUE(service_ != nullptr); + std::shared_ptr record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); auto abilityRecord = record->GetAbilityRunningRecord(GetTestAbilityName()); EXPECT_TRUE(abilityRecord != nullptr); @@ -852,20 +792,31 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchAbilityForApp_002, TestSize.Level1) abilityInfo3->applicationName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); - RecordQueryResult result; - Profile profile; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + bundleInfo.jointUserId = "joint456"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; const int EXPECT_ABILITY_LAUNCH_TIME = 3; EXPECT_TRUE(service_ != nullptr); - std::shared_ptr record = - service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, GetTestProcessName(), 0, result); + std::shared_ptr record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); auto abilityRecord = record->GetAbilityRunningRecord(GetTestAbilityName()); EXPECT_TRUE(abilityRecord != nullptr); + sptr token2 = new (std::nothrow) MockAbilityToken(); - auto abilityRecord2 = record->AddAbility(token2, abilityInfo2); + record->AddModule(appInfo, abilityInfo2, token2, hapModuleInfo); + auto moduleRecord = record->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + auto abilityRecord2 = moduleRecord->GetAbilityRunningRecordByToken(token2); EXPECT_TRUE(abilityRecord2 != nullptr); + sptr token3 = new (std::nothrow) MockAbilityToken(); - auto abilityRecord3 = record->AddAbility(token3, abilityInfo3); + record->AddModule(appInfo, abilityInfo3, token3, hapModuleInfo); + auto moduleRecord3 = record->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord3); + auto abilityRecord3 = moduleRecord3->GetAbilityRunningRecordByToken(token3); EXPECT_TRUE(abilityRecord3 != nullptr); EXPECT_CALL(*mockAppSchedulerClient_, ScheduleLaunchApplication(_)).Times(1); @@ -892,12 +843,15 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchAbilityForApp_003, TestSize.Level1) abilityInfo->applicationName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); - RecordQueryResult result; - Profile profile; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + bundleInfo.jointUserId = "joint456"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; EXPECT_TRUE(service_ != nullptr); - std::shared_ptr record = - service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, GetTestProcessName(), 0, result); + std::shared_ptr record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); record->SetState(ApplicationState::APP_STATE_READY); record->SetApplicationClient(GetMockedAppSchedulerClient()); auto abilityRecord = record->GetAbilityRunningRecord(GetTestAbilityName()); @@ -935,12 +889,15 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchAbilityForApp_004, TestSize.Level1) appInfo->name = GetTestAppName(); appInfo->bundleName = GetTestAppName(); - RecordQueryResult result; - Profile profile; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + bundleInfo.jointUserId = "joint456"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; EXPECT_TRUE(service_ != nullptr); - std::shared_ptr record = - service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, GetTestAppName(), 0, result); + std::shared_ptr record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); auto abilityRecord = record->GetAbilityRunningRecord(GetTestAbilityName()); EXPECT_TRUE(abilityRecord != nullptr); @@ -951,7 +908,7 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchAbilityForApp_004, TestSize.Level1) EXPECT_EQ(record->GetState(), ApplicationState::APP_STATE_READY); EXPECT_CALL(*mockAppSchedulerClient_, ScheduleLaunchApplication(_)).Times(0); - EXPECT_CALL(*mockAppSchedulerClient_, ScheduleLaunchAbility(_, _)).Times(0); + EXPECT_CALL(*mockAppSchedulerClient_, ScheduleLaunchAbility(_, _)).Times(1); sptr token2 = new (std::nothrow) MockAbilityToken(); service_->LoadAbility(token2, nullptr, abilityInfo2, appInfo); APP_LOGI("AmsAppRunningRecordTest LaunchAbilityForApp_004 end"); @@ -979,20 +936,31 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchAbilityForApp_005, TestSize.Level1) abilityInfo3->applicationName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); - RecordQueryResult result; - Profile profile; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + bundleInfo.jointUserId = "joint456"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; const int EXPECT_ABILITY_LAUNCH_TIME = 2; EXPECT_TRUE(service_ != nullptr); - std::shared_ptr record = - service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, GetTestProcessName(), 0, result); + std::shared_ptr record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); auto abilityRecord = record->GetAbilityRunningRecord(GetTestAbilityName()); EXPECT_TRUE(abilityRecord != nullptr); + sptr token2 = new (std::nothrow) MockAbilityToken(); - auto abilityRecord2 = record->AddAbility(token2, abilityInfo2); + record->AddModule(appInfo, abilityInfo2, token2, hapModuleInfo); + auto moduleRecord2 = record->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord2); + auto abilityRecord2 = moduleRecord2->GetAbilityRunningRecordByToken(token2); abilityRecord2->SetState(AbilityState::ABILITY_STATE_READY); + sptr token3 = new (std::nothrow) MockAbilityToken(); - auto abilityRecord3 = record->AddAbility(token3, abilityInfo3); + record->AddModule(appInfo, abilityInfo3, token3, hapModuleInfo); + auto moduleRecord3 = record->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord3); + auto abilityRecord3 = moduleRecord3->GetAbilityRunningRecordByToken(token3); EXPECT_CALL(*mockAppSchedulerClient_, ScheduleLaunchApplication(_)).Times(1); EXPECT_CALL(*mockAppSchedulerClient_, ScheduleLaunchAbility(_, _)).Times(EXPECT_ABILITY_LAUNCH_TIME); @@ -1002,63 +970,6 @@ HWTEST_F(AmsAppRunningRecordTest, LaunchAbilityForApp_005, TestSize.Level1) APP_LOGI("AmsAppRunningRecordTest LaunchAbilityForApp_005 end"); } -/* - * Feature: AMS - * Function: AppRunningRecord - * SubFunction: AddAbility - * FunctionPoints: check params - * EnvConditions: Mobile that can run ohos test framework - * CaseDescription: Verify the function AddAbility can check the invalid token param. - */ -HWTEST_F(AmsAppRunningRecordTest, AddAbility_001, TestSize.Level1) -{ - auto appRecord = GetTestAppRunningRecord(); - EXPECT_TRUE(appRecord); - - auto abilityInfo = std::make_shared(); - abilityInfo->name = GetTestAbilityName(); - abilityInfo->type = AbilityType::PAGE; - - EXPECT_EQ(nullptr, appRecord->AddAbility(nullptr, abilityInfo)); -} - -/* - * Feature: AMS - * Function: AppRunningRecord - * SubFunction: AddAbility - * FunctionPoints: check params - * EnvConditions: Mobile that can run ohos test framework - * CaseDescription: Verify the function AddAbility can check the invalid abilityInfo param. - */ -HWTEST_F(AmsAppRunningRecordTest, AddAbility_002, TestSize.Level1) -{ - auto appRecord = GetTestAppRunningRecord(); - EXPECT_TRUE(appRecord); - - EXPECT_EQ(nullptr, appRecord->AddAbility(GetMockToken(), nullptr)); -} - -/* - * Feature: AMS - * Function: AppRunningRecord - * SubFunction: AddAbility - * FunctionPoints: check params - * EnvConditions: Mobile that can run ohos test framework - * CaseDescription: Verify the function AddAbility can check the AbilityRecord which already existed. - */ -HWTEST_F(AmsAppRunningRecordTest, AddAbility_003, TestSize.Level1) -{ - auto appRecord = GetTestAppRunningRecord(); - EXPECT_TRUE(appRecord); - - auto abilityInfo = std::make_shared(); - abilityInfo->name = GetTestAbilityName(); - abilityInfo->type = AbilityType::PAGE; - - EXPECT_NE(nullptr, appRecord->AddAbility(GetMockToken(), abilityInfo)); - EXPECT_EQ(nullptr, appRecord->AddAbility(GetMockToken(), abilityInfo)); -} - /* * Feature: AMS * Function: AppRunningRecord @@ -1092,8 +1003,21 @@ HWTEST_F(AmsAppRunningRecordTest, TerminateAbility_002, TestSize.Level1) auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); - auto record = GetTestAppRunningRecord(); - EXPECT_NE(nullptr, record->AddAbility(GetMockToken(), abilityInfo)); + + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + appInfo->bundleName = GetTestAppName(); + + std::shared_ptr record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); + auto abilityRecord = record->GetAbilityRunningRecord(GetTestAbilityName()); + EXPECT_TRUE(abilityRecord != nullptr); + EXPECT_CALL(*mockAppSchedulerClient_, ScheduleCleanAbility(_)).Times(0); record->TerminateAbility(GetMockToken(), false); @@ -1133,8 +1057,20 @@ HWTEST_F(AmsAppRunningRecordTest, GetAbilityRunningRecord_001, TestSize.Level1) auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); - auto record = GetTestAppRunningRecord(); - EXPECT_NE(nullptr, record->AddAbility(GetMockToken(), abilityInfo)); + + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + appInfo->bundleName = GetTestAppName(); + + std::shared_ptr record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); + auto abilityRecord = record->GetAbilityRunningRecord(GetTestAbilityName()); + EXPECT_TRUE(abilityRecord != nullptr); + std::string abilityName = "not_exist_ability_name"; EXPECT_EQ(nullptr, record->GetAbilityRunningRecord(abilityName)); @@ -1158,6 +1094,7 @@ HWTEST_F(AmsAppRunningRecordTest, GetAbilityRunningRecordByToken_001, TestSize.L APP_LOGI("AmsAppRunningRecordTest GetAbilityRunningRecordByToken_001 end"); } + /* * Feature: AMS * Function: AppRunningRecord::SetUid, AppRunningRecord::GetUid() @@ -1174,10 +1111,14 @@ HWTEST_F(AmsAppRunningRecordTest, SetUid_GetUid_001, TestSize.Level1) auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); - RecordQueryResult result; + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + bundleInfo.jointUserId = "joint456"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; EXPECT_TRUE(service_ != nullptr); - auto record = - service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, GetTestProcessName(), 101, result); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); EXPECT_TRUE(record != nullptr); record->SetUid(102); @@ -1188,18 +1129,6 @@ HWTEST_F(AmsAppRunningRecordTest, SetUid_GetUid_001, TestSize.Level1) EXPECT_EQ(otherRecord->GetUid(), 102); } -/* - * Feature: AMS - * Function: OptimizerAbilityStateChanged - * SubFunction: OnAbilityStateChanged - * FunctionPoints: check params - * EnvConditions: Mobile that can run ohos test framework - * CaseDescription: Record and optimize the current app status - */ - -HWTEST_F(AmsAppRunningRecordTest, OptimizerAbilityStateChanged_001, TestSize.Level1) -{} - /* * Feature: AMS * Function: OnAbilityStateChanged @@ -1211,19 +1140,29 @@ HWTEST_F(AmsAppRunningRecordTest, OptimizerAbilityStateChanged_001, TestSize.Lev HWTEST_F(AmsAppRunningRecordTest, OnAbilityStateChanged_001, TestSize.Level1) { - auto appRecord = GetTestAppRunningRecord(); - EXPECT_TRUE(appRecord); - auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); - auto abilityRecord = appRecord->AddAbility(GetMockToken(), abilityInfo); - EXPECT_NE(nullptr, abilityRecord); + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + appInfo->bundleName = GetTestAppName(); + + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + std::shared_ptr record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); + auto moduleRecord = record->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord != nullptr); + auto abilityRecord = record->GetAbilityRunningRecord(GetTestAbilityName()); + EXPECT_TRUE(abilityRecord != nullptr); sptr callback = new (std::nothrow) MockAppStateCallback(); EXPECT_CALL(*callback, OnAbilityRequestDone(_, _)).Times(0); - appRecord->OnAbilityStateChanged(nullptr, AbilityState::ABILITY_STATE_FOREGROUND); + moduleRecord->OnAbilityStateChanged(nullptr, AbilityState::ABILITY_STATE_FOREGROUND); EXPECT_NE(AbilityState::ABILITY_STATE_FOREGROUND, abilityRecord->GetState()); @@ -1233,13 +1172,249 @@ HWTEST_F(AmsAppRunningRecordTest, OnAbilityStateChanged_001, TestSize.Level1) EXPECT_CALL(*callback, OnAbilityRequestDone(_, _)).Times(2); serviceInner->RegisterAppStateCallback(callback); - appRecord->SetAppMgrServiceInner(serviceInner); + record->SetAppMgrServiceInner(serviceInner); - appRecord->OnAbilityStateChanged(abilityRecord, AbilityState::ABILITY_STATE_FOREGROUND); + moduleRecord->OnAbilityStateChanged(abilityRecord, AbilityState::ABILITY_STATE_FOREGROUND); EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, abilityRecord->GetState()); - appRecord->OnAbilityStateChanged(abilityRecord, AbilityState::ABILITY_STATE_BACKGROUND); + moduleRecord->OnAbilityStateChanged(abilityRecord, AbilityState::ABILITY_STATE_BACKGROUND); EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, abilityRecord->GetState()); } + +/* + * Feature: AMS + * Function: AddModule + * SubFunction: AddModule + * FunctionPoints: check params + * EnvConditions: Mobile that can run ohos test framework + * CaseDescription: add module + */ + +HWTEST_F(AmsAppRunningRecordTest, AddModule_001, TestSize.Level1) +{ + auto abilityInfo = std::make_shared(); + abilityInfo->name = GetTestAbilityName(); + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + EXPECT_TRUE(service_ != nullptr); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); + + EXPECT_TRUE(record != nullptr); + + auto moduleRecordList = record->GetAllModuleRecord(); + EXPECT_TRUE(moduleRecordList.size() == 1); + + auto abilityInfo2 = std::make_shared(); + abilityInfo2->name = GetTestAbilityName() + "_1"; + abilityInfo2->applicationName = GetTestAppName(); + HapModuleInfo hapModuleInfo1; + hapModuleInfo1.moduleName = "module123"; + sptr token2 = new (std::nothrow) MockAbilityToken(); + record->AddModule(appInfo, abilityInfo2, token2, hapModuleInfo1); + + moduleRecordList = record->GetAllModuleRecord(); + EXPECT_TRUE(moduleRecordList.size() == 2); +} + +/* + * Feature: AMS + * Function: AddModule + * SubFunction: AddModule + * FunctionPoints: check params + * EnvConditions: Mobile that can run ohos test framework + * CaseDescription: add module + */ + +HWTEST_F(AmsAppRunningRecordTest, AddModule_002, TestSize.Level1) +{ + auto abilityInfo = std::make_shared(); + abilityInfo->name = GetTestAbilityName(); + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + EXPECT_TRUE(service_ != nullptr); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); + + EXPECT_TRUE(record != nullptr); + + auto moduleRecordList = record->GetAllModuleRecord(); + EXPECT_TRUE(moduleRecordList.size() == 1); + + auto abilityInfo2 = std::make_shared(); + abilityInfo2->name = GetTestAbilityName() + "_1"; + abilityInfo2->applicationName = GetTestAppName(); + sptr token2 = new (std::nothrow) MockAbilityToken(); + record->AddModule(appInfo, abilityInfo2, token2, hapModuleInfo); + + moduleRecordList = record->GetAllModuleRecord(); + EXPECT_TRUE(moduleRecordList.size() == 1); +} + +/* + * Feature: AMS + * Function: GetModuleRecordByModuleName + * SubFunction: GetModuleRecordByModuleName + * FunctionPoints: check params + * EnvConditions: Mobile that can run ohos test framework + * CaseDescription: Get ModuleRecord By ModuleName + */ + +HWTEST_F(AmsAppRunningRecordTest, GetModuleRecordByModuleName_001, TestSize.Level1) +{ + auto abilityInfo = std::make_shared(); + abilityInfo->name = GetTestAbilityName(); + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + appInfo->bundleName = GetTestAppName(); + + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + EXPECT_TRUE(service_ != nullptr); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); + + EXPECT_TRUE(record != nullptr); + + auto abilityInfo2 = std::make_shared(); + abilityInfo2->name = GetTestAbilityName() + "_1"; + abilityInfo2->applicationName = GetTestAppName(); + HapModuleInfo hapModuleInfo1; + hapModuleInfo1.moduleName = "module123"; + sptr token2 = new (std::nothrow) MockAbilityToken(); + record->AddModule(appInfo, abilityInfo2, token2, hapModuleInfo1); + + auto moduleRecord = record->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); +} + +/* + * Feature: AMS + * Function: GetAbilities + * SubFunction: GetAbilities + * FunctionPoints: check params + * EnvConditions: Mobile that can run ohos test framework + * CaseDescription: Get All Abilities + */ + +HWTEST_F(AmsAppRunningRecordTest, GetAbilities_001, TestSize.Level1) +{ + auto abilityInfo = std::make_shared(); + abilityInfo->name = GetTestAbilityName(); + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + EXPECT_TRUE(service_ != nullptr); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); + + EXPECT_TRUE(record != nullptr); + + auto abilityInfo2 = std::make_shared(); + abilityInfo2->name = GetTestAbilityName() + "_1"; + abilityInfo2->applicationName = GetTestAppName(); + sptr token2 = new (std::nothrow) MockAbilityToken(); + record->AddModule(appInfo, abilityInfo2, token2, hapModuleInfo); + + auto abilities = record->GetAbilities(); + EXPECT_TRUE(abilities.size() == 2); +} + +/* + * Feature: AMS + * Function: GetAbilities + * SubFunction: GetAbilities + * FunctionPoints: check params + * EnvConditions: Mobile that can run ohos test framework + * CaseDescription: Get All Abilities + */ + +HWTEST_F(AmsAppRunningRecordTest, GetAbilities_002, TestSize.Level1) +{ + auto abilityInfo = std::make_shared(); + abilityInfo->name = GetTestAbilityName(); + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + EXPECT_TRUE(service_ != nullptr); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); + + EXPECT_TRUE(record != nullptr); + + auto abilityInfo2 = std::make_shared(); + abilityInfo2->name = GetTestAbilityName() + "_1"; + abilityInfo2->applicationName = GetTestAppName(); + HapModuleInfo hapModuleInfo1; + hapModuleInfo1.moduleName = "module123"; + sptr token2 = new (std::nothrow) MockAbilityToken(); + record->AddModule(appInfo, abilityInfo2, token2, hapModuleInfo1); + + auto abilities = record->GetAbilities(); + EXPECT_TRUE(abilities.size() == 2); +} + +/* + * Feature: AMS + * Function: RemoveModuleRecord + * SubFunction: RemoveModuleRecord + * FunctionPoints: check params + * EnvConditions: Mobile that can run ohos test framework + * CaseDescription: Remove ModuleRecord + */ + +HWTEST_F(AmsAppRunningRecordTest, RemoveModuleRecord_001, TestSize.Level1) +{ + auto abilityInfo = std::make_shared(); + abilityInfo->name = GetTestAbilityName(); + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(); + appInfo->bundleName = GetTestAppName(); + + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + EXPECT_TRUE(service_ != nullptr); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, GetTestProcessName(), bundleInfo, hapModuleInfo); + + EXPECT_TRUE(record != nullptr); + + auto abilityInfo2 = std::make_shared(); + abilityInfo2->name = GetTestAbilityName() + "_1"; + abilityInfo2->applicationName = GetTestAppName(); + HapModuleInfo hapModuleInfo1; + hapModuleInfo1.moduleName = "module123"; + sptr token2 = new (std::nothrow) MockAbilityToken(); + record->AddModule(appInfo, abilityInfo2, token2, hapModuleInfo1); + + auto moduleRecord = record->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + EXPECT_TRUE(moduleRecord); + + record->RemoveModuleRecord(moduleRecord); + auto moduleRecordList = record->GetAllModuleRecord(); + EXPECT_TRUE(moduleRecordList.size() == 1); +} } // namespace AppExecFwk } // namespace OHOS diff --git a/services/appmgr/test/unittest/ams_app_state_callback_test/ams_app_state_callback_test.cpp b/services/appmgr/test/unittest/ams_app_state_callback_test/ams_app_state_callback_test.cpp index 8ca0a8472be65de81b360fcdd5b3a59e3779738c..4b30bb988ad4e20cf437137f5bc743bbe442f994 100644 --- a/services/appmgr/test/unittest/ams_app_state_callback_test/ams_app_state_callback_test.cpp +++ b/services/appmgr/test/unittest/ams_app_state_callback_test/ams_app_state_callback_test.cpp @@ -54,8 +54,12 @@ HWTEST_F(AmsAppStateCallBackTest, OnRemoteRequest_001, TestSize.Level1) MessageParcel data; MessageParcel reply; MessageOption option{MessageOption::TF_ASYNC}; + + AppData appDataInfo; AppProcessData processData; - processData.appName = "test_name"; + appDataInfo.appName = "test_name"; + appDataInfo.uid = 2; + processData.appDatas.emplace_back(appDataInfo); processData.pid = 1; processData.appState = ApplicationState::APP_STATE_FOREGROUND; data.WriteParcelable(&processData); @@ -98,8 +102,11 @@ HWTEST_F(AmsAppStateCallBackTest, OnRemoteRequest_002, TestSize.Level1) HWTEST_F(AmsAppStateCallBackTest, AppProcessData_001, TestSize.Level1) { Parcel data; + AppData appDataInfo; AppProcessData processData; - processData.appName = "test_name"; + appDataInfo.appName = "test_name"; + appDataInfo.uid = 2; + processData.appDatas.emplace_back(appDataInfo); processData.pid = 1; processData.appState = ApplicationState::APP_STATE_FOREGROUND; @@ -109,7 +116,11 @@ HWTEST_F(AmsAppStateCallBackTest, AppProcessData_001, TestSize.Level1) sptr newProcessData = AppProcessData::Unmarshalling(data); EXPECT_NE(nullptr, newProcessData); - EXPECT_EQ(processData.appName, newProcessData->appName); + for (auto i = 0; i < processData.appDatas.size(); i++) { + EXPECT_EQ(processData.appDatas[i].appName, newProcessData->appDatas[i].appName); + EXPECT_EQ(processData.appDatas[i].uid, newProcessData->appDatas[i].uid); + } + EXPECT_EQ(processData.pid, newProcessData->pid); EXPECT_EQ(processData.appState, newProcessData->appState); } diff --git a/services/appmgr/test/unittest/ams_app_workflow_test/BUILD.gn b/services/appmgr/test/unittest/ams_app_workflow_test/BUILD.gn index 965a5ad800cb84e39e4f2776e3fd727d05fe72ea..60ca099883d36df59ff7824a92f8a674f1db58c4 100644 --- a/services/appmgr/test/unittest/ams_app_workflow_test/BUILD.gn +++ b/services/appmgr/test/unittest/ams_app_workflow_test/BUILD.gn @@ -38,6 +38,7 @@ ohos_unittest("AmsWorkFlowTest") { "${services_path}/appmgr/src/app_spawn_socket.cpp", "${services_path}/appmgr/src/cgroup_manager.cpp", "${services_path}/appmgr/src/lmks_client.cpp", + "${services_path}/appmgr/src/module_running_record.cpp", "${services_path}/appmgr/src/process_optimizer.cpp", "${services_path}/appmgr/src/process_optimizer_uba.cpp", "${services_path}/appmgr/src/remote_client_manager.cpp", diff --git a/services/appmgr/test/unittest/ams_app_workflow_test/ams_workflow_test.cpp b/services/appmgr/test/unittest/ams_app_workflow_test/ams_workflow_test.cpp index 59c412fbdd2ad910b9b374c03f8cfc05b9c460fb..5037314a1fce2b028adabafd0cf61f47be605d3c 100644 --- a/services/appmgr/test/unittest/ams_app_workflow_test/ams_workflow_test.cpp +++ b/services/appmgr/test/unittest/ams_app_workflow_test/ams_workflow_test.cpp @@ -13,7 +13,13 @@ * limitations under the License. */ +#define private public #include "app_mgr_service_inner.h" +#undef private +#include +#include +#include "iremote_object.h" +#include "refbase.h" #include "app_launch_data.h" #include "app_log_wrapper.h" #include @@ -57,8 +63,8 @@ public: void TearDown(); protected: - AbilityInfo CreateAbilityInfo(const std::string &ability, const std::string &app) const; - ApplicationInfo CreateApplication(const std::string &app) const; + std::shared_ptr CreateAbilityInfo(const std::string &ability, const std::string &app) const; + std::shared_ptr CreateApplication(const std::string &app) const; sptr AddApplicationClient(const std::shared_ptr &appRecord) const; TestApplicationPreRecord CreateTestApplicationRecord(const std::string &ability, const sptr &token, const std::string &app, const AbilityState abilityState, const ApplicationState appState) const; @@ -87,19 +93,33 @@ void AmsWorkFlowTest::TearDown() g_mockPid = 0; } -AbilityInfo AmsWorkFlowTest::CreateAbilityInfo(const std::string &ability, const std::string &app) const +std::shared_ptr AmsWorkFlowTest::CreateAbilityInfo( + const std::string &ability, const std::string &app) const { - AbilityInfo abilityInfo; - abilityInfo.visible = true; - abilityInfo.name = "test_ability" + ability; - abilityInfo.applicationName = "test_app" + app; + // AbilityInfo abilityInfo; + // abilityInfo.visible = true; + // abilityInfo.name = "test_ability" + ability; + // abilityInfo.applicationName = "test_app" + app; + // abilityInfo.applicationInfo.bundleName = "test_app" + app; + + auto abilityInfo = std::make_shared(); + abilityInfo->visible = true; + abilityInfo->name = "test_ability" + ability; + abilityInfo->applicationName = "test_app" + app; + abilityInfo->applicationInfo.bundleName = "test_app" + app; + return abilityInfo; } -ApplicationInfo AmsWorkFlowTest::CreateApplication(const std::string &app) const +std::shared_ptr AmsWorkFlowTest::CreateApplication(const std::string &app) const { - ApplicationInfo appInfo; - appInfo.name = "test_app" + app; + // ApplicationInfo appInfo; + // appInfo.name = "test_app" + app; + + auto appInfo = std::make_shared(); + appInfo->name = "test_app" + app; + appInfo->bundleName = "test_app" + app; + return appInfo; } @@ -119,21 +139,44 @@ TestApplicationPreRecord AmsWorkFlowTest::CreateTestApplicationRecord(const std: const sptr &token, const std::string &app, const AbilityState abilityState, const ApplicationState appState) const { - RecordQueryResult result; - AbilityInfo abilityInfo = CreateAbilityInfo(ability, app); - ApplicationInfo appInfo = CreateApplication(app); - abilityInfo.applicationInfo.uid = 0; - appInfo.uid = 0; - - auto appRecord = serviceInner_->GetOrCreateAppRunningRecord(token, - std::make_shared(appInfo), - std::make_shared(abilityInfo), - appInfo.name, - 0, - result); - if (!result.appExists) { - appRecord->GetPriorityObject()->SetPid(g_mockPid++); + auto abilityInfo = CreateAbilityInfo(ability, app); + auto appInfo = CreateApplication(app); + abilityInfo->applicationInfo.uid = 0; + appInfo->uid = 0; + + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, appInfo->name, appInfo->uid, bundleInfo); + + if (!appRecord) { + appRecord = serviceInner_->CreateAppRunningRecord( + token, nullptr, appInfo, abilityInfo, appInfo->name, bundleInfo, hapModuleInfo); + serviceInner_->StartProcess(abilityInfo->applicationName, + appInfo->name, + appRecord, + abilityInfo->applicationInfo.uid, + abilityInfo->applicationInfo.bundleName); + } else { + appRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo); } + + // std::shared_ptr mockClientPtr = std::make_shared(); + // serviceInner_->SetAppSpawnClient(mockClientPtr); + // EXPECT_CALL(*mockClientPtr, StartProcess(_, _)).Times(1).WillOnce(DoAll(SetArgReferee<1>(newPid), + // Return(ERR_OK))); + + // serviceInner_->LoadAbility(token, nullptr, abilityInfo, appInfo); + + // BundleInfo bundleInfo; + // bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + // auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + // appInfo->name, appInfo->name, appInfo->uid, bundleInfo); + EXPECT_NE(appRecord, nullptr); appRecord->SetEventHandler(handler_); auto abilityRecord = appRecord->GetAbilityRunningRecordByToken(token); @@ -286,7 +329,8 @@ HWTEST_F(AmsWorkFlowTest, BackKey_004, TestSize.Level1) * Function: AppLifeCycle * SubFunction: WorkFlow * FunctionPoints: BackKey - * CaseDescription: when only one ability on foreground, previous is another app, simulate press back key and exit app + * CaseDescription: when only one ability on foreground, previous is another app, simulate press back key and exit + app */ HWTEST_F(AmsWorkFlowTest, BackKey_005, TestSize.Level1) { @@ -294,9 +338,11 @@ HWTEST_F(AmsWorkFlowTest, BackKey_005, TestSize.Level1) sptr tokenA = new MockAbilityToken(); TestApplicationPreRecord appA = CreateTestApplicationRecord( "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND); + appA.appRecord_->LaunchPendingAbilities(); sptr tokenB = new MockAbilityToken(); TestApplicationPreRecord appB = CreateTestApplicationRecord( "B", tokenB, "B", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND); + appB.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(appB.mockAppScheduler_), ScheduleForegroundApplication()).Times(1); EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1); EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_)).Times(1); @@ -330,12 +376,14 @@ HWTEST_F(AmsWorkFlowTest, BackKey_006, TestSize.Level1) sptr tokenA = new MockAbilityToken(); TestApplicationPreRecord appA = CreateTestApplicationRecord( "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND); + appA.appRecord_->LaunchPendingAbilities(); sptr tokenB = new MockAbilityToken(); CreateTestApplicationRecord( "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND); sptr tokenC = new MockAbilityToken(); TestApplicationPreRecord appC = CreateTestApplicationRecord( "C", tokenC, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND); + appC.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(appC.mockAppScheduler_), ScheduleForegroundApplication()).Times(1); EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1); EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_)).Times(2); @@ -374,12 +422,14 @@ HWTEST_F(AmsWorkFlowTest, BackKey_007, TestSize.Level1) sptr tokenA = new MockAbilityToken(); TestApplicationPreRecord appA = CreateTestApplicationRecord( "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND); + appA.appRecord_->LaunchPendingAbilities(); sptr tokenB = new MockAbilityToken(); CreateTestApplicationRecord( "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND); sptr tokenC = new MockAbilityToken(); TestApplicationPreRecord appC = CreateTestApplicationRecord( "C", tokenC, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND); + appC.appRecord_->LaunchPendingAbilities(); sptr tokenD = new MockAbilityToken(); CreateTestApplicationRecord( "D", tokenD, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND); @@ -500,6 +550,7 @@ HWTEST_F(AmsWorkFlowTest, ScreenOff_004, TestSize.Level1) sptr tokenA = new MockAbilityToken(); TestApplicationPreRecord appA = CreateTestApplicationRecord( "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND); + appA.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1); EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_)).Times(1); EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleTerminateApplication()).Times(1); @@ -528,6 +579,7 @@ HWTEST_F(AmsWorkFlowTest, ScreenOff_005, TestSize.Level1) sptr tokenA = new MockAbilityToken(); TestApplicationPreRecord appA = CreateTestApplicationRecord( "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND); + appA.appRecord_->LaunchPendingAbilities(); sptr tokenB = new MockAbilityToken(); CreateTestApplicationRecord( "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND); @@ -564,6 +616,7 @@ HWTEST_F(AmsWorkFlowTest, ScreenOff_006, TestSize.Level1) sptr tokenA = new MockAbilityToken(); TestApplicationPreRecord appA = CreateTestApplicationRecord( "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND); + appA.appRecord_->LaunchPendingAbilities(); sptr tokenB = new MockAbilityToken(); CreateTestApplicationRecord( "B", tokenB, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_FOREGROUND); @@ -750,10 +803,11 @@ HWTEST_F(AmsWorkFlowTest, ChangeAbility_003, TestSize.Level1) sptr tokenA = new MockAbilityToken(); TestApplicationPreRecord appA = CreateTestApplicationRecord( "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND); + appA.appRecord_->LaunchPendingAbilities(); sptr tokenB = new MockAbilityToken(); TestApplicationPreRecord appB = CreateTestApplicationRecord( "B", tokenB, "B", AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); - + appB.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(appB.mockAppScheduler_), ScheduleForegroundApplication()).Times(1); EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1); @@ -776,9 +830,6 @@ HWTEST_F(AmsWorkFlowTest, ChangeAbility_003, TestSize.Level1) auto abilitiesB = appB.appRecord_->GetAbilities(); EXPECT_NE(nullptr, abilitiesA[tokenA]); EXPECT_NE(nullptr, abilitiesB[tokenB]); - pid_t pidA = appA.appRecord_->GetPriorityObject()->GetPid(); - pid_t pidB = appB.appRecord_->GetPriorityObject()->GetPid(); - EXPECT_NE(pidA, pidB); } /* @@ -794,13 +845,14 @@ HWTEST_F(AmsWorkFlowTest, ChangeAbility_004, TestSize.Level1) sptr tokenA = new MockAbilityToken(); TestApplicationPreRecord appA = CreateTestApplicationRecord( "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND); + appA.appRecord_->LaunchPendingAbilities(); sptr tokenB = new MockAbilityToken(); CreateTestApplicationRecord( "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND); sptr tokenC = new MockAbilityToken(); TestApplicationPreRecord appC = CreateTestApplicationRecord( "C", tokenC, "C", AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); - + appC.appRecord_->LaunchPendingAbilities(); EXPECT_CALL(*(appC.mockAppScheduler_), ScheduleForegroundApplication()).Times(1); EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1); @@ -829,10 +881,6 @@ HWTEST_F(AmsWorkFlowTest, ChangeAbility_004, TestSize.Level1) EXPECT_NE(nullptr, abilitiesA[tokenA]); EXPECT_NE(nullptr, abilitiesA[tokenB]); EXPECT_NE(nullptr, abilitiesC[tokenC]); - - pid_t pidA = appA.appRecord_->GetPriorityObject()->GetPid(); - pid_t pidC = appC.appRecord_->GetPriorityObject()->GetPid(); - EXPECT_NE(pidA, pidC); } /* diff --git a/services/appmgr/test/unittest/ams_recent_app_list_test/BUILD.gn b/services/appmgr/test/unittest/ams_recent_app_list_test/BUILD.gn index c873bec2c78a7c9784b74b7919ec09ef540755ea..f6c0704aa405cf2d69bed2823f71725375f68828 100644 --- a/services/appmgr/test/unittest/ams_recent_app_list_test/BUILD.gn +++ b/services/appmgr/test/unittest/ams_recent_app_list_test/BUILD.gn @@ -35,6 +35,7 @@ ohos_unittest("AmsRecentAppListTest") { "${services_path}/appmgr/src/app_spawn_socket.cpp", "${services_path}/appmgr/src/cgroup_manager.cpp", "${services_path}/appmgr/src/lmks_client.cpp", + "${services_path}/appmgr/src/module_running_record.cpp", "${services_path}/appmgr/src/process_optimizer.cpp", "${services_path}/appmgr/src/process_optimizer_uba.cpp", "${services_path}/appmgr/src/remote_client_manager.cpp", diff --git a/services/appmgr/test/unittest/ams_recent_app_list_test/ams_recent_app_list_test.cpp b/services/appmgr/test/unittest/ams_recent_app_list_test/ams_recent_app_list_test.cpp index 4d22b5616e40528706697773528d818e3cdd7603..fda095275ba9996b2923ee44bfaf40d380ca9e48 100644 --- a/services/appmgr/test/unittest/ams_recent_app_list_test/ams_recent_app_list_test.cpp +++ b/services/appmgr/test/unittest/ams_recent_app_list_test/ams_recent_app_list_test.cpp @@ -78,6 +78,7 @@ const std::shared_ptr AmsRecentAppListTest::GetAbilityInfoByIndex(c std::shared_ptr abilityInfo = std::make_shared(); abilityInfo->name = "test_ability" + std::to_string(index); abilityInfo->applicationName = "com.ohos.test.helloworld" + std::to_string(index); + abilityInfo->applicationInfo.bundleName = "com.ohos.test.helloworld" + std::to_string(index); return abilityInfo; } @@ -92,7 +93,12 @@ const std::shared_ptr AmsRecentAppListTest::GetApplicationByInd const std::shared_ptr AmsRecentAppListTest::GetAppRunningRecordByIndex(const int32_t index) const { auto appInfo = GetApplicationByIndex(index); - auto appRecord = serviceInner_->GetAppRunningRecordByAppName(appInfo->name); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, appInfo->name, appInfo->uid, bundleInfo); + EXPECT_NE(nullptr, appRecord); return appRecord; } diff --git a/services/appmgr/test/unittest/ams_service_load_ability_process_test/BUILD.gn b/services/appmgr/test/unittest/ams_service_load_ability_process_test/BUILD.gn index e6f75ff901d1e97271eff70ab45e6eef937713bd..ceb457463d64420e42d802502ab992b93e15d6a1 100644 --- a/services/appmgr/test/unittest/ams_service_load_ability_process_test/BUILD.gn +++ b/services/appmgr/test/unittest/ams_service_load_ability_process_test/BUILD.gn @@ -33,6 +33,7 @@ ohos_unittest("AmsServiceLoadAbilityProcessTest") { "${services_path}/appmgr/src/app_spawn_socket.cpp", "${services_path}/appmgr/src/cgroup_manager.cpp", "${services_path}/appmgr/src/lmks_client.cpp", + "${services_path}/appmgr/src/module_running_record.cpp", "${services_path}/appmgr/src/process_optimizer.cpp", "${services_path}/appmgr/src/process_optimizer_uba.cpp", "${services_path}/appmgr/src/remote_client_manager.cpp", diff --git a/services/appmgr/test/unittest/ams_service_load_ability_process_test/ams_service_load_ability_process_test.cpp b/services/appmgr/test/unittest/ams_service_load_ability_process_test/ams_service_load_ability_process_test.cpp index be3048ca3f803834bd4d13509d62ec221875929b..86391935a78e300cf1c2aac36a40c7353f4abef4 100644 --- a/services/appmgr/test/unittest/ams_service_load_ability_process_test/ams_service_load_ability_process_test.cpp +++ b/services/appmgr/test/unittest/ams_service_load_ability_process_test/ams_service_load_ability_process_test.cpp @@ -99,14 +99,16 @@ std::shared_ptr AmsServiceLoadAbilityProcessTest::StartLoadAbi const sptr &preToken, const std::shared_ptr &abilityInfo, const std::shared_ptr &appInfo, const pid_t newPid) const { - RecordQueryResult result; std::shared_ptr mockClientPtr = std::make_shared(); EXPECT_CALL(*mockClientPtr, StartProcess(_, _)).Times(1).WillOnce(DoAll(SetArgReferee<1>(newPid), Return(ERR_OK))); service_->SetAppSpawnClient(mockClientPtr); service_->LoadAbility(token, preToken, abilityInfo, appInfo); - std::shared_ptr record = - service_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, abilityInfo->process, 0, result); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, abilityInfo->process, appInfo->uid, bundleInfo);; EXPECT_EQ(record->GetPriorityObject()->GetPid(), newPid); return record; } @@ -126,6 +128,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_001, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); appInfo->bundleName = GetTestAppName(); @@ -135,7 +138,12 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_001, TestSize.Level1) StartLoadAbility(token, nullptr, abilityInfo, appInfo, PID); const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record, nullptr); CHECK_POINTER_IS_NULLPTR(record); EXPECT_EQ(record->GetState(), ApplicationState::APP_STATE_CREATE); @@ -168,6 +176,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_002, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -179,14 +188,18 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_002, TestSize.Level1) const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record, nullptr); - CHECK_POINTER_IS_NULLPTR(record); + CHECK_POINTER_IS_NULLPTR(record); EXPECT_EQ(record->GetState(), ApplicationState::APP_STATE_CREATE); const auto &abilityMap = record->GetAbilities(); EXPECT_EQ(abilityMap.size(), (uint32_t)1); - - auto abilityRecord = record->GetAbilityRunningRecordByToken(token); + + auto abilityRecord = record->GetAbilityRunningRecordByToken(token); EXPECT_NE(abilityRecord, nullptr); CHECK_POINTER_IS_NULLPTR(abilityRecord); EXPECT_EQ(abilityRecord->GetState(), AbilityState::ABILITY_STATE_CREATE); @@ -196,22 +209,33 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_002, TestSize.Level1) abilityInfo2->name = GetTestAbilityName() + "_1"; abilityInfo2->applicationName = "com.ohos.test.special"; abilityInfo2->process = "com.ohos.test.special"; + abilityInfo2->applicationInfo.bundleName = "com.ohos.test.special"; auto appInfo2 = std::make_shared(); appInfo2->name = "com.ohos.test.special"; appInfo2->bundleName = "com.ohos.test.special"; const pid_t PID2 = 2234; - StartLoadAbility(token2, nullptr, abilityInfo2, appInfo2, PID2); + APP_LOGI("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"); + StartLoadAbility(token2, token, abilityInfo2, appInfo2, PID2); + APP_LOGI("00000000000000000000000000000000000000"); const uint32_t EXPECT_MAP_SIZE = 2; EXPECT_EQ(recordMap.size(), EXPECT_MAP_SIZE); - auto record2 = service_->GetAppRunningRecordByAppName("com.ohos.test.special"); + + APP_LOGI("11111111111111111111111111111111111111111"); + auto record2 = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo2->name, "com.ohos.test.special", appInfo2->uid, bundleInfo); + APP_LOGI("22222222222222222222222222222222222222"); EXPECT_NE(record2, nullptr); CHECK_POINTER_IS_NULLPTR(record2); + APP_LOGI("3333333333333333333333333333333333333"); EXPECT_EQ(record2->GetState(), ApplicationState::APP_STATE_CREATE); + APP_LOGI("444444444444444444444444444444444444444444444"); auto abilityRecord2 = record2->GetAbilityRunningRecordByToken(token2); + APP_LOGI("5555555555555555555555555555555555555"); EXPECT_NE(abilityRecord2, nullptr); CHECK_POINTER_IS_NULLPTR(abilityRecord2); + APP_LOGI("666666666666666666666666666666666"); EXPECT_EQ(abilityRecord2->GetState(), AbilityState::ABILITY_STATE_CREATE); APP_LOGI("AmsServiceLoadAbilityProcessTest LoadAbility_002 end"); } @@ -230,6 +254,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_003, TestSize.Level1) auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); appInfo->bundleName = GetTestAppName(); @@ -261,6 +286,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_004, TestSize.Level1) auto abilityInfo = std::make_shared(); abilityInfo->name = ""; abilityInfo->applicationName = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); appInfo->bundleName = GetTestAppName(); @@ -291,6 +317,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_005, TestSize.Level1) auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = ""; + abilityInfo->applicationInfo.bundleName = ""; auto appInfo = std::make_shared(); appInfo->name = ""; appInfo->bundleName = ""; @@ -320,6 +347,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_006, TestSize.Level1) auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName() + "_1"; + abilityInfo->applicationInfo.bundleName = GetTestAppName() + "_1"; auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); appInfo->bundleName = GetTestAppName(); @@ -351,6 +379,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_007, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -360,7 +389,11 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_007, TestSize.Level1) StartLoadAbility(token, nullptr, abilityInfo, appInfo, PID); const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record, nullptr); CHECK_POINTER_IS_NULLPTR(record); EXPECT_EQ(record->GetState(), ApplicationState::APP_STATE_CREATE); @@ -376,7 +409,9 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_007, TestSize.Level1) service_->SetAppSpawnClient(mockClientPtr); service_->LoadAbility(token, nullptr, abilityInfo, appInfo); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record2 = service_->GetAppRunningRecordByAppName(GetTestAppName()); + + auto record2 = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_EQ(record2, record); const auto &abilityMap2 = record2->GetAbilities(); EXPECT_EQ(abilityMap2.size(), (uint32_t)1); @@ -399,6 +434,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_008, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -408,7 +444,11 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_008, TestSize.Level1) StartLoadAbility(token, nullptr, abilityInfo, appInfo, PID); const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record, nullptr); CHECK_POINTER_IS_NULLPTR(record); EXPECT_EQ(record->GetState(), ApplicationState::APP_STATE_CREATE); @@ -423,6 +463,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_008, TestSize.Level1) auto abilityInfo2 = std::make_shared(); abilityInfo2->name = GetTestAbilityName() + "_1"; abilityInfo2->applicationName = GetTestAppName(); + abilityInfo2->applicationInfo.bundleName = GetTestAppName(); const uint32_t EXPECT_MAP_SIZE = 2; std::shared_ptr mockClientPtr = std::make_shared(); EXPECT_CALL(*mockClientPtr, StartProcess(_, _)).Times(0); @@ -430,7 +471,8 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LoadAbility_008, TestSize.Level1) service_->SetAppSpawnClient(mockClientPtr); service_->LoadAbility(token2, preToken, abilityInfo2, appInfo); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record2 = service_->GetAppRunningRecordByAppName(GetTestAppName()); + auto record2 = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_EQ(record2, record); const auto &abilityMap2 = record2->GetAbilities(); EXPECT_EQ(abilityMap2.size(), EXPECT_MAP_SIZE); @@ -458,6 +500,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, RequestProcess_001, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -472,7 +515,11 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, RequestProcess_001, TestSize.Level1) const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record, nullptr); CHECK_POINTER_IS_NULLPTR(record); EXPECT_EQ(record->GetPriorityObject()->GetPid(), PID); @@ -496,6 +543,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, RequestProcess_002, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -528,6 +576,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, SavePid_001, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -540,7 +589,11 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, SavePid_001, TestSize.Level1) service_->SetAppSpawnClient(mockClientPtr); service_->LoadAbility(token, nullptr, abilityInfo, appInfo); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_EQ(record->GetPriorityObject()->GetPid(), PID); APP_LOGI("AmsServiceLoadAbilityProcessTest SavePid_001 end"); } @@ -560,6 +613,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, SavePid_002, TestSize.Level1) auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); appInfo->bundleName = GetTestAppName(); @@ -570,7 +624,11 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, SavePid_002, TestSize.Level1) service_->SetAppSpawnClient(mockClientPtr); service_->LoadAbility(token, nullptr, abilityInfo, appInfo); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_EQ(record, nullptr); APP_LOGI("AmsServiceLoadAbilityProcessTest SavePid_002 end"); } @@ -590,6 +648,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LaunchMode_001, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); abilityInfo->launchMode = LaunchMode::SINGLETON; auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -600,7 +659,11 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LaunchMode_001, TestSize.Level1) StartLoadAbility(token, nullptr, abilityInfo, appInfo, PID); const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record, nullptr); CHECK_POINTER_IS_NULLPTR(record); EXPECT_EQ(record->GetState(), ApplicationState::APP_STATE_CREATE); @@ -630,6 +693,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LaunchMode_002, TestSize.Level1) abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); abilityInfo->launchMode = LaunchMode::SINGLETON; + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -639,7 +703,11 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LaunchMode_002, TestSize.Level1) StartLoadAbility(token, nullptr, abilityInfo, appInfo, PID); const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record, nullptr); CHECK_POINTER_IS_NULLPTR(record); EXPECT_EQ(record->GetState(), ApplicationState::APP_STATE_CREATE); @@ -656,7 +724,8 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, LaunchMode_002, TestSize.Level1) service_->SetAppSpawnClient(mockClientPtr); service_->LoadAbility(token2, preToken, abilityInfo, appInfo); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record2 = service_->GetAppRunningRecordByAppName(GetTestAppName()); + auto record2 = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_EQ(record2, record); const auto &abilityMap2 = record2->GetAbilities(); EXPECT_EQ(abilityMap2.size(), (uint32_t)1); @@ -679,6 +748,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_001, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -688,7 +758,11 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_001, TestSize.Level1) StartLoadAbility(token, nullptr, abilityInfo, appInfo, PID); const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record, nullptr); CHECK_POINTER_IS_NULLPTR(record); EXPECT_EQ(record->GetState(), ApplicationState::APP_STATE_CREATE); @@ -703,6 +777,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_001, TestSize.Level1) abilityInfo2->name = GetTestAbilityName() + "_1"; abilityInfo2->applicationName = GetTestAppName(); abilityInfo2->process = GetTestAppName(); + abilityInfo2->applicationInfo.bundleName = GetTestAppName(); record->SetState(ApplicationState::APP_STATE_FOREGROUND); sptr mockAppScheduler = new MockAppScheduler(); @@ -710,8 +785,11 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_001, TestSize.Level1) record->SetApplicationClient(client); EXPECT_CALL(*mockAppScheduler, ScheduleLaunchAbility(_, _)).Times(1); - service_->StartAbility(token2, token, abilityInfo2, record); - auto record1 = service_->GetAppRunningRecordByAppName(GetTestAppName()); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + service_->StartAbility(token2, token, abilityInfo2, record, hapModuleInfo); + auto record1 = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); const auto &abilityMap1 = record1->GetAbilities(); EXPECT_EQ(abilityMap1.size(), (uint32_t)2); auto abilityrecord1 = record1->GetAbilityRunningRecordByToken(token2); @@ -737,6 +815,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_002, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -746,7 +825,11 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_002, TestSize.Level1) StartLoadAbility(token, nullptr, abilityInfo, appInfo, PID); const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record, nullptr); CHECK_POINTER_IS_NULLPTR(record); EXPECT_EQ(record->GetState(), ApplicationState::APP_STATE_CREATE); @@ -761,14 +844,18 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_002, TestSize.Level1) abilityInfo2->name = GetTestAbilityName() + "_1"; abilityInfo2->applicationName = GetTestAppName(); abilityInfo2->process = GetTestAppName(); + abilityInfo2->applicationInfo.bundleName = GetTestAppName(); record->SetState(ApplicationState::APP_STATE_FOREGROUND); sptr mockAppScheduler = new MockAppScheduler(); sptr client = iface_cast(mockAppScheduler.GetRefPtr()); record->SetApplicationClient(client); EXPECT_CALL(*mockAppScheduler, ScheduleLaunchAbility(_, _)).Times(0); - service_->StartAbility(token2, token, abilityInfo2, nullptr); - auto record1 = service_->GetAppRunningRecordByAppName(GetTestAppName()); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + service_->StartAbility(token2, token, abilityInfo2, nullptr, hapModuleInfo); + auto record1 = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); const auto &abilityMap1 = record1->GetAbilities(); EXPECT_EQ(abilityMap1.size(), (uint32_t)1); APP_LOGI("AmsServiceLoadAbilityProcessTest StartAbility_002 end"); @@ -791,6 +878,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_003, TestSize.Level1) abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); abilityInfo->launchMode = LaunchMode::SINGLETON; + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -801,7 +889,11 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_003, TestSize.Level1) StartLoadAbility(token, nullptr, abilityInfo, appInfo, PID); const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record, nullptr); CHECK_POINTER_IS_NULLPTR(record); EXPECT_EQ(record->GetState(), ApplicationState::APP_STATE_CREATE); @@ -818,14 +910,18 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_003, TestSize.Level1) abilityInfo2->launchMode = LaunchMode::SINGLETON; abilityInfo2->process = GetTestAppName(); abilityInfo2->applicationName = GetTestAppName(); + abilityInfo2->applicationInfo.bundleName = GetTestAppName(); record->SetState(ApplicationState::APP_STATE_FOREGROUND); sptr mockAppScheduler = new MockAppScheduler(); sptr client = iface_cast(mockAppScheduler.GetRefPtr()); record->SetApplicationClient(client); EXPECT_CALL(*mockAppScheduler, ScheduleLaunchAbility(_, _)).Times(0); - service_->StartAbility(token2, token, abilityInfo2, nullptr); - auto record1 = service_->GetAppRunningRecordByAppName(GetTestAppName()); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + service_->StartAbility(token2, token, abilityInfo2, nullptr, hapModuleInfo); + auto record1 = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); const auto &abilityMap1 = record1->GetAbilities(); EXPECT_EQ(abilityMap1.size(), (uint32_t)1); APP_LOGI("AmsServiceLoadAbilityProcessTest StartAbility_003 end"); @@ -847,6 +943,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_004, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); appInfo->bundleName = GetTestAppName(); @@ -855,7 +952,11 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_004, TestSize.Level1) StartLoadAbility(token, nullptr, abilityInfo, appInfo, PID); const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record, nullptr); CHECK_POINTER_IS_NULLPTR(record); EXPECT_EQ(record->GetState(), ApplicationState::APP_STATE_CREATE); @@ -869,14 +970,18 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_004, TestSize.Level1) abilityInfo2->name = GetTestAbilityName() + "_1"; abilityInfo2->applicationName = GetTestAppName(); abilityInfo2->process = GetTestAppName(); + abilityInfo2->applicationInfo.bundleName = GetTestAppName(); record->SetState(ApplicationState::APP_STATE_FOREGROUND); sptr mockAppScheduler = new MockAppScheduler(); sptr client = iface_cast(mockAppScheduler.GetRefPtr()); record->SetApplicationClient(client); EXPECT_CALL(*mockAppScheduler, ScheduleLaunchAbility(_, _)).Times(0); - service_->StartAbility(nullptr, token, abilityInfo2, nullptr); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + service_->StartAbility(nullptr, token, abilityInfo2, nullptr, hapModuleInfo); - auto record1 = service_->GetAppRunningRecordByAppName(GetTestAppName()); + auto record1 = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); const auto &abilityMap1 = record1->GetAbilities(); EXPECT_EQ(abilityMap1.size(), (uint32_t)1); APP_LOGI("AmsServiceLoadAbilityProcessTest StartAbility_004 end"); @@ -898,6 +1003,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_005, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -908,7 +1014,11 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_005, TestSize.Level1) StartLoadAbility(token, nullptr, abilityInfo, appInfo, PID); const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record, nullptr); CHECK_POINTER_IS_NULLPTR(record); EXPECT_EQ(record->GetState(), ApplicationState::APP_STATE_CREATE); @@ -923,13 +1033,17 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_005, TestSize.Level1) abilityInfo2->name = GetTestAbilityName() + "_1"; abilityInfo2->applicationName = GetTestAppName(); abilityInfo2->process = GetTestAppName(); + abilityInfo2->applicationInfo.bundleName = GetTestAppName(); record->SetState(ApplicationState::APP_STATE_FOREGROUND); sptr mockAppScheduler = new MockAppScheduler(); sptr client = iface_cast(mockAppScheduler.GetRefPtr()); record->SetApplicationClient(client); EXPECT_CALL(*mockAppScheduler, ScheduleLaunchAbility(_, _)).Times(1); - service_->StartAbility(token2, nullptr, abilityInfo2, record); - auto record1 = service_->GetAppRunningRecordByAppName(GetTestAppName()); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + service_->StartAbility(token2, nullptr, abilityInfo2, record, hapModuleInfo); + auto record1 = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); const auto &abilityMap1 = record1->GetAbilities(); EXPECT_EQ(abilityMap1.size(), (uint32_t)2); auto abilityrecord1 = record1->GetAbilityRunningRecordByToken(token2); @@ -955,6 +1069,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_006, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); appInfo->bundleName = GetTestAppName(); @@ -963,7 +1078,11 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_006, TestSize.Level1) StartLoadAbility(token, nullptr, abilityInfo, appInfo, PID); const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record = service_->GetAppRunningRecordByAppName(GetTestAppName()); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + + auto record = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record, nullptr); CHECK_POINTER_IS_NULLPTR(record); EXPECT_EQ(record->GetState(), ApplicationState::APP_STATE_CREATE); @@ -977,12 +1096,16 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartAbility_006, TestSize.Level1) abilityInfo2->name = GetTestAbilityName() + "_1"; abilityInfo2->applicationName = GetTestAppName(); abilityInfo2->process = GetTestAppName(); + abilityInfo2->applicationInfo.bundleName = GetTestAppName(); sptr mockAppScheduler = new MockAppScheduler(); sptr client = iface_cast(mockAppScheduler.GetRefPtr()); record->SetApplicationClient(client); EXPECT_CALL(*mockAppScheduler, ScheduleLaunchAbility(_, _)).Times(0); - service_->StartAbility(nullptr, token, abilityInfo2, nullptr); - auto record1 = service_->GetAppRunningRecordByAppName(GetTestAppName()); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + service_->StartAbility(nullptr, token, abilityInfo2, nullptr, hapModuleInfo); + auto record1 = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); const auto &abilityMap1 = record1->GetAbilities(); EXPECT_EQ(abilityMap1.size(), (uint32_t)1); APP_LOGI("AmsServiceLoadAbilityProcessTest StartAbility_006 end"); @@ -1003,6 +1126,7 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartProcess001, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); @@ -1010,16 +1134,27 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartProcess001, TestSize.Level1) const pid_t PID = 1234; EXPECT_TRUE(service_ != nullptr); sptr token = GetMockToken(); - RecordQueryResult result; std::shared_ptr mockClientPtr = std::make_shared(); EXPECT_CALL(*mockClientPtr, StartProcess(_, _)).Times(1).WillOnce(DoAll(SetArgReferee<1>(PID), Return(ERR_OK))); service_->SetAppSpawnClient(mockClientPtr); - std::shared_ptr record = - service_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, GetTestAppName(), 0, result); - service_->StartProcess(abilityInfo->applicationName, GetTestAppName(), record, abilityInfo->applicationInfo.uid); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + std::shared_ptr record = service_->CreateAppRunningRecord( + token, nullptr, appInfo, abilityInfo, GetTestAppName(), bundleInfo, hapModuleInfo); + + service_->StartProcess(abilityInfo->applicationName, + GetTestAppName(), + record, + abilityInfo->applicationInfo.uid, + abilityInfo->applicationInfo.bundleName); const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record1 = service_->GetAppRunningRecordByAppName(GetTestAppName()); + + auto record1 = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_EQ(record1->GetPriorityObject()->GetPid(), PID); EXPECT_NE(record1, nullptr); CHECK_POINTER_IS_NULLPTR(record1); @@ -1047,18 +1182,30 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartProcess002, TestSize.Level1) auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); EXPECT_TRUE(service_ != nullptr); sptr token = GetMockToken(); - RecordQueryResult result; - std::shared_ptr record = - service_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, GetTestAppName(), 0, result); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + std::shared_ptr record = service_->CreateAppRunningRecord( + token, nullptr, appInfo, abilityInfo, GetTestAppName(), bundleInfo, hapModuleInfo); + service_->SetAppSpawnClient(nullptr); - service_->StartProcess(abilityInfo->applicationName, GetTestAppName(), record, abilityInfo->applicationInfo.uid); + service_->StartProcess(abilityInfo->applicationName, + GetTestAppName(), + record, + abilityInfo->applicationInfo.uid, + abilityInfo->applicationInfo.bundleName); const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record1 = service_->GetAppRunningRecordByAppName(GetTestAppName()); + + auto record1 = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record1, nullptr); CHECK_POINTER_IS_NULLPTR(record1); APP_LOGI("AmsServiceLoadAbilityProcessTest StartProcess002 end"); @@ -1078,19 +1225,31 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartProcess003, TestSize.Level1) auto abilityInfo = std::make_shared(); abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); EXPECT_TRUE(service_ != nullptr); sptr token = GetMockToken(); - RecordQueryResult result; std::shared_ptr mockClientPtr = std::make_shared(); service_->SetAppSpawnClient(mockClientPtr); - std::shared_ptr record = - service_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, GetTestAppName(), 0, result); - service_->StartProcess(abilityInfo->applicationName, GetTestAppName(), nullptr, abilityInfo->applicationInfo.uid); + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + std::shared_ptr record = service_->CreateAppRunningRecord( + token, nullptr, appInfo, abilityInfo, GetTestAppName(), bundleInfo, hapModuleInfo); + + service_->StartProcess(abilityInfo->applicationName, + GetTestAppName(), + nullptr, + abilityInfo->applicationInfo.uid, + abilityInfo->applicationInfo.bundleName); const auto &recordMap = service_->GetRecordMap(); EXPECT_EQ(recordMap.size(), (uint32_t)1); - auto record1 = service_->GetAppRunningRecordByAppName(GetTestAppName()); + + auto record1 = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(), appInfo->uid, bundleInfo); EXPECT_NE(record1, nullptr); CHECK_POINTER_IS_NULLPTR(record1); APP_LOGI("AmsServiceLoadAbilityProcessTest StartProcess003 end"); @@ -1111,23 +1270,34 @@ HWTEST_F(AmsServiceLoadAbilityProcessTest, StartProcess004, TestSize.Level1) abilityInfo->name = GetTestAbilityName(); abilityInfo->applicationName = GetTestAppName(); abilityInfo->process = GetTestAppName(); + abilityInfo->applicationInfo.bundleName = GetTestAppName(); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(); appInfo->bundleName = GetTestAppName(); const pid_t PID = 1234; EXPECT_TRUE(service_ != nullptr); sptr token = GetMockToken(); - RecordQueryResult result; std::shared_ptr mockClientPtr = std::make_shared(); service_->SetAppSpawnClient(mockClientPtr); EXPECT_CALL(*mockClientPtr, StartProcess(_, _)) .Times(1) .WillOnce(DoAll(SetArgReferee<1>(PID), Return(ERR_TIMED_OUT))); - std::shared_ptr record = - service_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, GetTestAppName(), 0, result); + + BundleInfo bundleInfo; + bundleInfo.appId = "com.ohos.test.helloworld_code123"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "module789"; + + std::shared_ptr record = service_->CreateAppRunningRecord( + token, nullptr, appInfo, abilityInfo, GetTestAppName(), bundleInfo, hapModuleInfo); + EXPECT_NE(record, nullptr); CHECK_POINTER_IS_NULLPTR(record); - service_->StartProcess(abilityInfo->applicationName, GetTestAppName(), record, abilityInfo->applicationInfo.uid); + service_->StartProcess(abilityInfo->applicationName, + GetTestAppName(), + record, + abilityInfo->applicationInfo.uid, + abilityInfo->applicationInfo.bundleName); auto record1 = service_->GetAppRunningRecordByAppRecordId(record->GetRecordId()); EXPECT_EQ(record1, nullptr); APP_LOGI("AmsServiceLoadAbilityProcessTest StartProcess004 end"); diff --git a/services/appmgr/test/unittest/app_mgr_service_event_handler_test/BUILD.gn b/services/appmgr/test/unittest/app_mgr_service_event_handler_test/BUILD.gn index 00f23e5f98ffce8b6b099175b18e96723d6970e6..a8dc9c7e0ac65ab1d3c87b55b4a7aab72e7894ce 100644 --- a/services/appmgr/test/unittest/app_mgr_service_event_handler_test/BUILD.gn +++ b/services/appmgr/test/unittest/app_mgr_service_event_handler_test/BUILD.gn @@ -33,6 +33,7 @@ ohos_unittest("AMSEventHandlerTest") { "${services_path}/appmgr/src/app_spawn_socket.cpp", "${services_path}/appmgr/src/cgroup_manager.cpp", "${services_path}/appmgr/src/lmks_client.cpp", + "${services_path}/appmgr/src/module_running_record.cpp", "${services_path}/appmgr/src/process_optimizer.cpp", "${services_path}/appmgr/src/process_optimizer_uba.cpp", "${services_path}/appmgr/src/remote_client_manager.cpp", diff --git a/services/test/moduletest/common/ams/BUILD.gn b/services/test/moduletest/common/ams/BUILD.gn index 6a5e12bf99bf29b4bc13b30ad8f566948f0a1d16..447e694ec184e13cc767c4ec0be10b24d5dd3cf5 100755 --- a/services/test/moduletest/common/ams/BUILD.gn +++ b/services/test/moduletest/common/ams/BUILD.gn @@ -33,6 +33,7 @@ ohos_source_set("appmgr_mst_source") { "${services_path}/appmgr/src/app_spawn_socket.cpp", "${services_path}/appmgr/src/cgroup_manager.cpp", "${services_path}/appmgr/src/lmks_client.cpp", + "${services_path}/appmgr/src/module_running_record.cpp", "${services_path}/appmgr/src/process_optimizer.cpp", "${services_path}/appmgr/src/process_optimizer_uba.cpp", "${services_path}/appmgr/src/remote_client_manager.cpp", diff --git a/services/test/moduletest/common/ams/ability_running_record_test/ams_ability_running_record_module_test.cpp b/services/test/moduletest/common/ams/ability_running_record_test/ams_ability_running_record_module_test.cpp index 706c7fd2d00fd297073224c53c5083f76695dafd..9afaa04c8ede9562db2725ba355ae022cbde287c 100644 --- a/services/test/moduletest/common/ams/ability_running_record_test/ams_ability_running_record_module_test.cpp +++ b/services/test/moduletest/common/ams/ability_running_record_test/ams_ability_running_record_module_test.cpp @@ -122,7 +122,7 @@ public: return abilityLaunchTime; } - void ScheduleAbilityStageInfo(const AppResidentProcessInfo &) override + void ScheduleAbilityStageInfo(const HapModuleInfo &) override {} void Reset() override @@ -205,12 +205,20 @@ HWTEST_F(AmsAbilityRunningRecordModuleTest, AddAbilityRunningRecord_001, TestSiz auto appRunningRecord = QueryAppRunningRecord(); auto caseAbilityInfo = std::make_shared(); caseAbilityInfo->name = ABILITY_RECORD_NAME; + auto appInfo = std::make_shared(); + appInfo->bundleName = "com.ohos.test.helloworld"; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "Module"; sptr token = new MockAbilityToken(); - auto caseAbilityRunningRecord = appRunningRecord->AddAbility(token, caseAbilityInfo); + appRunningRecord->AddModule(appInfo, caseAbilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, hapModuleInfo.moduleName); + auto caseAbilityRunningRecord = moduleRecord->AddAbility(token, caseAbilityInfo); - EXPECT_TRUE(caseAbilityRunningRecord != nullptr); + EXPECT_TRUE(caseAbilityRunningRecord == nullptr); + caseAbilityRunningRecord = moduleRecord->GetAbilityRunningRecord(ABILITY_RECORD_NAME); EXPECT_EQ(caseAbilityRunningRecord, appRunningRecord->GetAbilityRunningRecordByToken(token)); - auto abilityRunningRecordWithSameName = appRunningRecord->AddAbility(token, caseAbilityInfo); + auto abilityRunningRecordWithSameName = moduleRecord->AddAbility(token, caseAbilityInfo); + EXPECT_TRUE(abilityRunningRecordWithSameName == nullptr); appRunningRecord->ClearAbility(caseAbilityRunningRecord); EXPECT_TRUE(appRunningRecord->GetAbilityRunningRecordByToken(token) == nullptr); APP_LOGI("AddAbilityRunningRecord_001 end"); @@ -229,13 +237,21 @@ HWTEST_F(AmsAbilityRunningRecordModuleTest, AddAbilityRunningRecord_002, TestSiz APP_LOGI("AddAbilityRunningRecord_002 start"); int i; auto appRunningRecord = QueryAppRunningRecord(); + auto appInfo = std::make_shared(); + appInfo->bundleName = "com.ohos.test.helloworld"; for (i = 0; i < ABILITY_RUNNING_RECORD_NUM; i++) { auto caseAbilityInfo = std::make_shared(); caseAbilityInfo->name = ABILITY_RECORD_NAME + "_" + std::to_string(i); sptr token = new MockAbilityToken(); - auto caseAbilityRunningRecord = appRunningRecord->AddAbility(token, caseAbilityInfo); - EXPECT_TRUE(caseAbilityRunningRecord != nullptr); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "Module"; + appRunningRecord->AddModule(appInfo, caseAbilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, + hapModuleInfo.moduleName); + auto caseAbilityRunningRecord = moduleRecord->AddAbility(token, caseAbilityInfo); + EXPECT_TRUE(caseAbilityRunningRecord == nullptr); + caseAbilityRunningRecord = moduleRecord->GetAbilityRunningRecord(ABILITY_RECORD_NAME + "_" + std::to_string(i)); EXPECT_EQ(caseAbilityRunningRecord, appRunningRecord->GetAbilityRunningRecordByToken(token)); EXPECT_EQ(caseAbilityRunningRecord->GetState(), AbilityState::ABILITY_STATE_BEGIN); } @@ -255,13 +271,21 @@ HWTEST_F(AmsAbilityRunningRecordModuleTest, UpdateAbilityRunningRecord_001, Test APP_LOGI("UpdateAbilityRunningRecord_001 start"); int i; auto appRunningRecord = QueryAppRunningRecord(); + auto appInfo = std::make_shared(); + appInfo->bundleName = "com.ohos.test.helloworld"; for (i = 0; i < ABILITY_RUNNING_RECORD_NUM; i++) { auto caseAbilityInfo = std::make_shared(); caseAbilityInfo->name = ABILITY_RECORD_NAME + "_" + std::to_string(i); sptr token = new MockAbilityToken(); - auto caseAbilityRunningRecord = appRunningRecord->AddAbility(token, caseAbilityInfo); - EXPECT_TRUE(caseAbilityRunningRecord != nullptr); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "Module"; + appRunningRecord->AddModule(appInfo, caseAbilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, + hapModuleInfo.moduleName); + auto caseAbilityRunningRecord = moduleRecord->AddAbility(token, caseAbilityInfo); + EXPECT_TRUE(caseAbilityRunningRecord == nullptr); + caseAbilityRunningRecord = moduleRecord->GetAbilityRunningRecord(ABILITY_RECORD_NAME + "_" + std::to_string(i)); EXPECT_EQ(caseAbilityRunningRecord, appRunningRecord->GetAbilityRunningRecordByToken(token)); caseAbilityRunningRecord->SetState(AbilityState::ABILITY_STATE_BACKGROUND); appRunningRecord->SetState(ApplicationState::APP_STATE_FOREGROUND); @@ -286,13 +310,21 @@ HWTEST_F(AmsAbilityRunningRecordModuleTest, UpdateAbilityRunningRecord_002, Test APP_LOGI("UpdateAbilityRunningRecord_002 start"); int i; auto appRunningRecord = QueryAppRunningRecord(); + auto appInfo = std::make_shared(); + appInfo->bundleName = "com.ohos.test.helloworld"; for (i = 0; i < ABILITY_RUNNING_RECORD_NUM; i++) { auto caseAbilityInfo = std::make_shared(); caseAbilityInfo->name = ABILITY_RECORD_NAME + "_" + std::to_string(i); sptr token = new MockAbilityToken(); - auto caseAbilityRunningRecord = appRunningRecord->AddAbility(token, caseAbilityInfo); - EXPECT_TRUE(caseAbilityRunningRecord != nullptr); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "Module"; + appRunningRecord->AddModule(appInfo, caseAbilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, + hapModuleInfo.moduleName); + auto caseAbilityRunningRecord = moduleRecord->AddAbility(token, caseAbilityInfo); + EXPECT_TRUE(caseAbilityRunningRecord == nullptr); + caseAbilityRunningRecord = moduleRecord->GetAbilityRunningRecord(ABILITY_RECORD_NAME + "_" + std::to_string(i)); EXPECT_EQ(caseAbilityRunningRecord, appRunningRecord->GetAbilityRunningRecordByToken(token)); appRunningRecord->UpdateAbilityState(token, AbilityState::ABILITY_STATE_END); EXPECT_EQ(caseAbilityRunningRecord->GetState(), AbilityState::ABILITY_STATE_BEGIN); @@ -313,13 +345,21 @@ HWTEST_F(AmsAbilityRunningRecordModuleTest, UpdateAbilityRunningRecord_003, Test APP_LOGI("UpdateAbilityRunningRecord_003 start"); int i; auto appRunningRecord = QueryAppRunningRecord(); + auto appInfo = std::make_shared(); + appInfo->bundleName = "com.ohos.test.helloworld"; for (i = 0; i < ABILITY_RUNNING_RECORD_NUM; i++) { auto caseAbilityInfo = std::make_shared(); caseAbilityInfo->name = ABILITY_RECORD_NAME + "_" + std::to_string(i); sptr token = new MockAbilityToken(); - auto caseAbilityRunningRecord = appRunningRecord->AddAbility(token, caseAbilityInfo); - EXPECT_TRUE(caseAbilityRunningRecord != nullptr); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "Module"; + appRunningRecord->AddModule(appInfo, caseAbilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, + hapModuleInfo.moduleName); + auto caseAbilityRunningRecord = moduleRecord->AddAbility(token, caseAbilityInfo); + EXPECT_TRUE(caseAbilityRunningRecord == nullptr); + caseAbilityRunningRecord = moduleRecord->GetAbilityRunningRecord(ABILITY_RECORD_NAME + "_" + std::to_string(i)); EXPECT_EQ(caseAbilityRunningRecord, appRunningRecord->GetAbilityRunningRecordByToken(token)); caseAbilityRunningRecord->SetState(AbilityState::ABILITY_STATE_FOREGROUND); appRunningRecord->SetState(ApplicationState::APP_STATE_BACKGROUND); @@ -344,13 +384,21 @@ HWTEST_F(AmsAbilityRunningRecordModuleTest, ClearAbilityRunningRecord_001, TestS APP_LOGI("ClearAbilityRunningRecord_001 start"); int i; auto appRunningRecord = QueryAppRunningRecord(); + auto appInfo = std::make_shared(); + appInfo->bundleName = "com.ohos.test.helloworld"; for (i = 0; i < ABILITY_RUNNING_RECORD_NUM; i++) { auto caseAbilityInfo = std::make_shared(); caseAbilityInfo->name = ABILITY_RECORD_NAME + "_" + std::to_string(i); sptr token = new MockAbilityToken(); - auto caseAbilityRunningRecord = appRunningRecord->AddAbility(token, caseAbilityInfo); - EXPECT_TRUE(caseAbilityRunningRecord != nullptr); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "Module"; + appRunningRecord->AddModule(appInfo, caseAbilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, + hapModuleInfo.moduleName); + auto caseAbilityRunningRecord = moduleRecord->AddAbility(token, caseAbilityInfo); + EXPECT_TRUE(caseAbilityRunningRecord == nullptr); + caseAbilityRunningRecord = moduleRecord->GetAbilityRunningRecord(ABILITY_RECORD_NAME + "_" + std::to_string(i)); EXPECT_EQ(caseAbilityRunningRecord, appRunningRecord->GetAbilityRunningRecordByToken(token)); } for (i = 0; i < ABILITY_RUNNING_RECORD_NUM; i++) { @@ -377,13 +425,21 @@ HWTEST_F(AmsAbilityRunningRecordModuleTest, ClearAbilityRunningRecord_002, TestS APP_LOGI("ClearAbilityRunningRecord_002 start"); int i; auto appRunningRecord = QueryAppRunningRecord(); + auto appInfo = std::make_shared(); + appInfo->bundleName = "com.ohos.test.helloworld"; for (i = 0; i < ABILITY_RUNNING_RECORD_NUM; i++) { auto caseAbilityInfo = std::make_shared(); caseAbilityInfo->name = ABILITY_RECORD_NAME + "_" + std::to_string(i); sptr token = new MockAbilityToken(); - auto caseAbilityRunningRecord = appRunningRecord->AddAbility(token, caseAbilityInfo); - EXPECT_TRUE(caseAbilityRunningRecord != nullptr); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "Module"; + appRunningRecord->AddModule(appInfo, caseAbilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, + hapModuleInfo.moduleName); + auto caseAbilityRunningRecord = moduleRecord->AddAbility(token, caseAbilityInfo); + EXPECT_TRUE(caseAbilityRunningRecord == nullptr); + caseAbilityRunningRecord = moduleRecord->GetAbilityRunningRecord(ABILITY_RECORD_NAME + "_" + std::to_string(i)); EXPECT_EQ(caseAbilityRunningRecord, appRunningRecord->GetAbilityRunningRecordByToken(token)); appRunningRecord->ClearAbility(caseAbilityRunningRecord); EXPECT_TRUE(appRunningRecord->GetAbilityRunningRecordByToken(token) == nullptr); @@ -408,13 +464,21 @@ HWTEST_F(AmsAbilityRunningRecordModuleTest, OperateAbilityRunningRecord_001, Tes APP_LOGI("OperateAbilityRunningRecord_001 start"); int i; auto appRunningRecord = QueryAppRunningRecord(); + auto appInfo = std::make_shared(); + appInfo->bundleName = "com.ohos.test.helloworld"; for (i = 0; i < ABILITY_RUNNING_RECORD_NUM; i++) { auto caseAbilityInfo = std::make_shared(); caseAbilityInfo->name = ABILITY_RECORD_NAME + "_" + std::to_string(i); sptr token = new MockAbilityToken(); - auto caseAbilityRunningRecord = appRunningRecord->AddAbility(token, caseAbilityInfo); - EXPECT_TRUE(caseAbilityRunningRecord != nullptr); + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "Module"; + appRunningRecord->AddModule(appInfo, caseAbilityInfo, token, hapModuleInfo); + auto moduleRecord = appRunningRecord->GetModuleRecordByModuleName(appInfo->bundleName, + hapModuleInfo.moduleName); + auto caseAbilityRunningRecord = moduleRecord->AddAbility(token, caseAbilityInfo); + EXPECT_TRUE(caseAbilityRunningRecord == nullptr); + caseAbilityRunningRecord = moduleRecord->GetAbilityRunningRecord(ABILITY_RECORD_NAME + "_" + std::to_string(i)); EXPECT_EQ(caseAbilityRunningRecord, appRunningRecord->GetAbilityRunningRecordByToken(token)); } for (i = 0; i < ABILITY_RUNNING_RECORD_NUM; i++) { diff --git a/services/test/moduletest/common/ams/app_life_cycle_test/ams_app_life_cycle_module_test.cpp b/services/test/moduletest/common/ams/app_life_cycle_test/ams_app_life_cycle_module_test.cpp index 46b9091edea2a020ac145ed2694f898a3abf3006..16d1e07d8eeef89098cc9aa504efa41b27f8b3bd 100755 --- a/services/test/moduletest/common/ams/app_life_cycle_test/ams_app_life_cycle_module_test.cpp +++ b/services/test/moduletest/common/ams/app_life_cycle_test/ams_app_life_cycle_module_test.cpp @@ -158,6 +158,7 @@ std::shared_ptr AmsAppLifeCycleModuleTest::GetAbilityInfo(const std abilityInfo->process = process; } abilityInfo->applicationName = applicationName; + abilityInfo->applicationInfo.bundleName = applicationName; return abilityInfo; } @@ -173,9 +174,12 @@ std::shared_ptr AmsAppLifeCycleModuleTest::StartProcessAndLoad } serviceInner_->LoadAbility(token, nullptr, abilityInfo, appInfo); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); - std::shared_ptr record = serviceInner_->GetAppRunningRecordByProcessName( - appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid); + std::shared_ptr record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo); if (record == nullptr) { EXPECT_TRUE(false); } else { @@ -334,6 +338,7 @@ void AmsAppLifeCycleModuleTest::CreateAppRecentList(const int32_t appNum) appInfo->bundleName = appInfo->name; abilityInfo->name = TEST_ABILITY_NAME + std::to_string(i); abilityInfo->applicationName = TEST_APP_NAME + std::to_string(i); + abilityInfo->applicationInfo.bundleName = appInfo->name; pid_t pid = i; sptr token = new (std::nothrow) MockAbilityToken(); MockAppSpawnClient *mockedSpawnClient = new (std::nothrow) MockAppSpawnClient(); @@ -1088,8 +1093,11 @@ HWTEST_F(AmsAppLifeCycleModuleTest, AbilityBehaviorAnalysis_01, TestSize.Level1) StartAppProcess(pid); serviceInner_->LoadAbility(token, nullptr, abilityInfo, appInfo); - std::shared_ptr record = serviceInner_->GetAppRunningRecordByProcessName( - appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + std::shared_ptr record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo); if (record == nullptr) { EXPECT_TRUE(false); } else { @@ -1141,8 +1149,11 @@ HWTEST_F(AmsAppLifeCycleModuleTest, AbilityBehaviorAnalysis_02, TestSize.Level1) StartAppProcess(pid); serviceInner_->LoadAbility(token, nullptr, abilityInfo, appInfo); - std::shared_ptr record = serviceInner_->GetAppRunningRecordByProcessName( - appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + std::shared_ptr record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo); if (record == nullptr) { EXPECT_TRUE(false); } else { @@ -1194,8 +1205,11 @@ HWTEST_F(AmsAppLifeCycleModuleTest, AbilityBehaviorAnalysis_03, TestSize.Level1) StartAppProcess(pid); serviceInner_->LoadAbility(token, nullptr, abilityInfo, appInfo); - std::shared_ptr record = serviceInner_->GetAppRunningRecordByProcessName( - appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + std::shared_ptr record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo); if (record == nullptr) { EXPECT_TRUE(false); } else { @@ -1247,8 +1261,11 @@ HWTEST_F(AmsAppLifeCycleModuleTest, AbilityBehaviorAnalysis_04, TestSize.Level1) StartAppProcess(pid); serviceInner_->LoadAbility(token, nullptr, abilityInfo, appInfo); - std::shared_ptr record = serviceInner_->GetAppRunningRecordByProcessName( - appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + std::shared_ptr record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo); if (record == nullptr) { EXPECT_TRUE(false); } else { @@ -1300,8 +1317,11 @@ HWTEST_F(AmsAppLifeCycleModuleTest, AbilityBehaviorAnalysis_05, TestSize.Level1) StartAppProcess(pid); serviceInner_->LoadAbility(token, nullptr, abilityInfo, appInfo); - std::shared_ptr record = serviceInner_->GetAppRunningRecordByProcessName( - appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + std::shared_ptr record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo); if (record == nullptr) { EXPECT_TRUE(false); } else { @@ -1355,8 +1375,11 @@ HWTEST_F(AmsAppLifeCycleModuleTest, AbilityBehaviorAnalysis_06, TestSize.Level1) StartAppProcess(pid); serviceInner_->LoadAbility(token, nullptr, abilityInfo, appInfo); - std::shared_ptr record = serviceInner_->GetAppRunningRecordByProcessName( - appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + std::shared_ptr record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo); if (record == nullptr) { EXPECT_TRUE(false); } else { @@ -1398,14 +1421,24 @@ HWTEST_F(AmsAppLifeCycleModuleTest, LoadResidentProcess_01, TestSize.Level1) std::string appName = "KeepAliveApp"; std::string proc = "KeepAliveApplication"; int uid = 2100; - sptr mockAppScheduler = new MockAppScheduler(); + BundleInfo info; + info.name = proc; + info.uid = uid; + + ApplicationInfo appInfo; + appInfo.name = "KeepAliveApp"; + appInfo.bundleName = "KeepAliveApplication"; + appInfo.uid = uid; - auto appRecord = serviceInner_->GetAppRunningRecordByProcessName(appName, proc, uid); + info.applicationInfo = appInfo; + sptr mockAppScheduler = new MockAppScheduler(); + + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info); EXPECT_FALSE(appRecord); StartAppProcess(pid); serviceInner_->LoadResidentProcess(); - appRecord = serviceInner_->GetAppRunningRecordByProcessName(appName, proc, uid); + appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info); EXPECT_TRUE(appRecord); pid_t newPid = appRecord->GetPriorityObject()->GetPid(); EXPECT_TRUE(newPid == pid); @@ -1438,20 +1471,355 @@ HWTEST_F(AmsAppLifeCycleModuleTest, StartResidentProcess_01, TestSize.Level1) appInfo.uid = 2100; info.applicationInfo = appInfo; + HapModuleInfo hapModuleInfo; + hapModuleInfo.name = "Module"; + HapModuleInfo hapModuleInfo1; + hapModuleInfo1.name = "Module1"; + info.hapModuleInfos.push_back(hapModuleInfo); + info.hapModuleInfos.push_back(hapModuleInfo1); infos.push_back(info); sptr mockAppScheduler = new MockAppScheduler(); - auto appRecord = serviceInner_->GetAppRunningRecordByProcessName(appName, proc, uid); + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info); EXPECT_FALSE(appRecord); StartAppProcess(pid); - serviceInner_->StartResidentProcess(infos); - appRecord = serviceInner_->GetAppRunningRecordByProcessName(appName, proc, uid); + serviceInner_->StartResidentProcess(infos, -1); + appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info); EXPECT_TRUE(appRecord); pid_t newPid = appRecord->GetPriorityObject()->GetPid(); EXPECT_TRUE(newPid == pid); } + +/* + * Feature: AbilityMgr + * Function: LoadAbility + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: NA + */ +HWTEST_F(AmsAppLifeCycleModuleTest, LoadAbility_001, TestSize.Level1) +{ + EXPECT_NE(serviceInner_, nullptr); + CHECK_POINTER_IS_NULLPTR(serviceInner_); + pid_t pid_0 = 1024; + pid_t pid_1 = 2048; + sptr token_0 = new (std::nothrow) MockAbilityToken(); + sptr token_1 = new (std::nothrow) MockAbilityToken(); + auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld0"); + auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld0"); + auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p2", "com.ohos.test.helloworld0"); + auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld0"); + sptr mockAppScheduler = new (std::nothrow) MockAppScheduler(); + TestProcessInfo testProcessInfo; + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = false; + auto appRunningRecord_0 = + StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo); + + testProcessInfo.pid = pid_1; + testProcessInfo.isStart = false; + auto appRunningRecord_1 = + StartProcessAndLoadAbility(mockAppScheduler, token_1, abilityInfo_1, appInfo_1, testProcessInfo); + int32_t recordId_0 = appRunningRecord_0->GetRecordId(); + int32_t recordId_1 = appRunningRecord_1->GetRecordId(); + EXPECT_NE(recordId_0, recordId_1); + EXPECT_NE(appRunningRecord_0, appRunningRecord_1); + auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_EQ(2, static_cast(appMap.size())); +} + +/* + * Feature: AbilityMgr + * Function: LoadAbility + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: NA + */ +HWTEST_F(AmsAppLifeCycleModuleTest, LoadAbility_002, TestSize.Level1) +{ + EXPECT_NE(serviceInner_, nullptr); + CHECK_POINTER_IS_NULLPTR(serviceInner_); + pid_t pid_0 = 1024; + sptr token_0 = new (std::nothrow) MockAbilityToken(); + sptr token_1 = new (std::nothrow) MockAbilityToken(); + auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld0"); + auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld0"); + auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p1", "com.ohos.test.helloworld0"); + auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld0"); + sptr mockAppScheduler = new (std::nothrow) MockAppScheduler(); + TestProcessInfo testProcessInfo; + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = false; + auto appRunningRecord_0 = + StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo); + + ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0); + CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); + + ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord_0, token_0); + CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_FOREGROUND, + ApplicationState::APP_STATE_FOREGROUND); + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = true; + auto appRunningRecord_1 = + StartProcessAndLoadAbility(mockAppScheduler, token_1, abilityInfo_1, appInfo_1, testProcessInfo); + int32_t recordId_0 = appRunningRecord_0->GetRecordId(); + int32_t recordId_1 = appRunningRecord_1->GetRecordId(); + EXPECT_EQ(recordId_0, recordId_1); + EXPECT_EQ(appRunningRecord_0, appRunningRecord_1); + auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_EQ(1, static_cast(appMap.size())); +} + +/* + * Feature: AbilityMgr + * Function: LoadAbility + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: NA + */ +HWTEST_F(AmsAppLifeCycleModuleTest, LoadAbility_003, TestSize.Level1) +{ + EXPECT_NE(serviceInner_, nullptr); + CHECK_POINTER_IS_NULLPTR(serviceInner_); + pid_t pid_0 = 1024; + sptr token_0 = new (std::nothrow) MockAbilityToken(); + sptr token_1 = new (std::nothrow) MockAbilityToken(); + auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld101"); + auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld101"); + auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p1", "com.ohos.test.helloworld102"); + auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld102"); + sptr mockAppScheduler = new (std::nothrow) MockAppScheduler(); + TestProcessInfo testProcessInfo; + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = false; + auto appRunningRecord_0 = + StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo); + ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0); + CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); + + ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord_0, token_0); + CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_FOREGROUND, + ApplicationState::APP_STATE_FOREGROUND); + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = true; + auto appRunningRecord_1 = + StartProcessAndLoadAbility(mockAppScheduler, token_1, abilityInfo_1, appInfo_1, testProcessInfo); + int32_t recordId_0 = appRunningRecord_0->GetRecordId(); + int32_t recordId_1 = appRunningRecord_1->GetRecordId(); + EXPECT_EQ(recordId_0, recordId_1); + EXPECT_EQ(appRunningRecord_0, appRunningRecord_1); + auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_EQ(1, static_cast(appMap.size())); +} + +/* + * Feature: AbilityMgr + * Function: LoadAbility + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: NA + */ +HWTEST_F(AmsAppLifeCycleModuleTest, LoadAbility_004, TestSize.Level1) +{ + EXPECT_NE(serviceInner_, nullptr); + CHECK_POINTER_IS_NULLPTR(serviceInner_); + pid_t pid_0 = 1024; + pid_t pid_1 = 2048; + sptr token_0 = new (std::nothrow) MockAbilityToken(); + sptr token_1 = new (std::nothrow) MockAbilityToken(); + auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld103"); + auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld103"); + auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p1", "com.ohos.test.helloworld104"); + auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld104"); + sptr mockAppScheduler = new (std::nothrow) MockAppScheduler(); + TestProcessInfo testProcessInfo; + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = false; + auto appRunningRecord_0 = + StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo); + + testProcessInfo.pid = pid_1; + testProcessInfo.isStart = false; + auto appRunningRecord_1 = + StartProcessAndLoadAbility(mockAppScheduler, token_1, abilityInfo_1, appInfo_1, testProcessInfo); + int32_t recordId_0 = appRunningRecord_0->GetRecordId(); + int32_t recordId_1 = appRunningRecord_1->GetRecordId(); + EXPECT_NE(recordId_0, recordId_1); + EXPECT_NE(appRunningRecord_0, appRunningRecord_1); + auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_EQ(2, static_cast(appMap.size())); +} + +/* + * Feature: AbilityMgr + * Function: KillApplication + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: NA + */ +HWTEST_F(AmsAppLifeCycleModuleTest, KillApplication_001, TestSize.Level1) +{ + EXPECT_NE(serviceInner_, nullptr); + CHECK_POINTER_IS_NULLPTR(serviceInner_); + pid_t pid_0 = 1024; + pid_t pid_1 = 2048; + sptr token_0 = new (std::nothrow) MockAbilityToken(); + sptr token_1 = new (std::nothrow) MockAbilityToken(); + auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld0"); + auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld0"); + auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p2", "com.ohos.test.helloworld0"); + auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld0"); + sptr mockAppScheduler = new (std::nothrow) MockAppScheduler(); + sptr mockAppScheduler1 = new (std::nothrow) MockAppScheduler(); + TestProcessInfo testProcessInfo; + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = false; + auto appRunningRecord_0 = + StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo); + + testProcessInfo.pid = pid_1; + testProcessInfo.isStart = false; + auto appRunningRecord_1 = + StartProcessAndLoadAbility(mockAppScheduler1, token_1, abilityInfo_1, appInfo_1, testProcessInfo); + ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0); + CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); + ChangeAbilityStateAfterAppStart(mockAppScheduler1, pid_1); + CheckState(appRunningRecord_1, token_1, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); + + int32_t recordId_0 = appRunningRecord_0->GetRecordId(); + int32_t recordId_1 = appRunningRecord_1->GetRecordId(); + EXPECT_NE(recordId_0, recordId_1); + EXPECT_NE(appRunningRecord_0, appRunningRecord_1); + auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_EQ(2, static_cast(appMap.size())); + EXPECT_CALL(*mockAppScheduler, ScheduleProcessSecurityExit()).Times(1); + EXPECT_CALL(*mockAppScheduler1, ScheduleProcessSecurityExit()).Times(1); + int32_t ret = serviceInner_->KillApplication("com.ohos.test.helloworld0"); + EXPECT_EQ(ret, 0); + serviceInner_->OnRemoteDied(mockAppScheduler); // A faked death recipient. + auto appMap1 = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_EQ(1, static_cast(appMap1.size())); + serviceInner_->OnRemoteDied(mockAppScheduler1); + auto appMap2 = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_EQ(0, static_cast(appMap2.size())); +} + +/* + * Feature: AbilityMgr + * Function: KillApplication + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: NA + */ +HWTEST_F(AmsAppLifeCycleModuleTest, KillApplication_002, TestSize.Level1) +{ + EXPECT_NE(serviceInner_, nullptr); + CHECK_POINTER_IS_NULLPTR(serviceInner_); + pid_t pid_0 = 1024; + pid_t pid_1 = 2048; + sptr token_0 = new (std::nothrow) MockAbilityToken(); + sptr token_1 = new (std::nothrow) MockAbilityToken(); + auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld103"); + auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld103"); + auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p1", "com.ohos.test.helloworld104"); + auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld104"); + sptr mockAppScheduler = new (std::nothrow) MockAppScheduler(); + sptr mockAppScheduler1 = new (std::nothrow) MockAppScheduler(); + TestProcessInfo testProcessInfo; + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = false; + auto appRunningRecord_0 = + StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo); + + testProcessInfo.pid = pid_1; + testProcessInfo.isStart = false; + auto appRunningRecord_1 = + StartProcessAndLoadAbility(mockAppScheduler1, token_1, abilityInfo_1, appInfo_1, testProcessInfo); + ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0); + CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); + ChangeAbilityStateAfterAppStart(mockAppScheduler1, pid_1); + CheckState(appRunningRecord_1, token_1, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); + int32_t recordId_0 = appRunningRecord_0->GetRecordId(); + int32_t recordId_1 = appRunningRecord_1->GetRecordId(); + EXPECT_NE(recordId_0, recordId_1); + EXPECT_NE(appRunningRecord_0, appRunningRecord_1); + auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_EQ(2, static_cast(appMap.size())); + EXPECT_CALL(*mockAppScheduler, ScheduleProcessSecurityExit()).Times(1); + int32_t ret = serviceInner_->KillApplication("com.ohos.test.helloworld103"); + EXPECT_EQ(ret, 0); + serviceInner_->OnRemoteDied(mockAppScheduler); // A faked death recipient. + auto appMap1 = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_EQ(1, static_cast(appMap1.size())); +} + +/* + * Feature: AbilityMgr + * Function: KillApplication + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: NA + */ +HWTEST_F(AmsAppLifeCycleModuleTest, KillApplication_003, TestSize.Level1) +{ + EXPECT_NE(serviceInner_, nullptr); + CHECK_POINTER_IS_NULLPTR(serviceInner_); + pid_t pid_0 = 1024; + sptr token_0 = new (std::nothrow) MockAbilityToken(); + sptr token_1 = new (std::nothrow) MockAbilityToken(); + auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld101"); + auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld101"); + auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p1", "com.ohos.test.helloworld102"); + auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld102"); + sptr mockAppScheduler = new (std::nothrow) MockAppScheduler(); + TestProcessInfo testProcessInfo; + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = false; + auto appRunningRecord_0 = + StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo); + ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0); + CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); + + ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord_0, token_0); + CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_FOREGROUND, + ApplicationState::APP_STATE_FOREGROUND); + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = true; + auto appRunningRecord_1 = + StartProcessAndLoadAbility(mockAppScheduler, token_1, abilityInfo_1, appInfo_1, testProcessInfo); + int32_t recordId_0 = appRunningRecord_0->GetRecordId(); + int32_t recordId_1 = appRunningRecord_1->GetRecordId(); + EXPECT_EQ(recordId_0, recordId_1); + EXPECT_EQ(appRunningRecord_0, appRunningRecord_1); + auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_EQ(1, static_cast(appMap.size())); + EXPECT_CALL(*mockAppScheduler, ScheduleProcessSecurityExit()).Times(1); + int32_t ret = serviceInner_->KillApplication("com.ohos.test.helloworld101"); + EXPECT_EQ(ret, 0); + serviceInner_->OnRemoteDied(mockAppScheduler); // A faked death recipient. + auto appMap1 = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_EQ(0, static_cast(appMap1.size())); +} } // namespace AppExecFwk } // namespace OHOS \ No newline at end of file diff --git a/services/test/moduletest/common/ams/app_mgr_service_test/ams_app_mgr_service_module_test.cpp b/services/test/moduletest/common/ams/app_mgr_service_test/ams_app_mgr_service_module_test.cpp index d6193a51873625c486c18fa42a45e1b1095acecf..f6438753f8729c25fe224c26ec523a869ae0b89a 100644 --- a/services/test/moduletest/common/ams/app_mgr_service_test/ams_app_mgr_service_module_test.cpp +++ b/services/test/moduletest/common/ams/app_mgr_service_test/ams_app_mgr_service_module_test.cpp @@ -63,7 +63,7 @@ public: {} void ScheduleProcessSecurityExit() override {} - void ScheduleAbilityStageInfo(const AppResidentProcessInfo &) override + void ScheduleAbilityStageInfo(const HapModuleInfo &) override {} }; class AppMgrServiceModuleTest : public testing::Test { diff --git a/services/test/moduletest/common/ams/app_recent_list_test/ams_app_recent_list_module_test.cpp b/services/test/moduletest/common/ams/app_recent_list_test/ams_app_recent_list_module_test.cpp index 8c6e46c445889a003375b010479edf82c8e24b63..6abb9ed978dc6f15483cdac4800bfde2a61eb403 100644 --- a/services/test/moduletest/common/ams/app_recent_list_test/ams_app_recent_list_module_test.cpp +++ b/services/test/moduletest/common/ams/app_recent_list_test/ams_app_recent_list_module_test.cpp @@ -88,8 +88,17 @@ const std::shared_ptr AmsAppRecentListModuleTest::CreateAppRun const int32_t index) const { std::shared_ptr appInfo = std::make_shared(); + std::shared_ptr abilityInfo = std::make_shared(); appInfo->name = TEST_APP_NAME + std::to_string(index); - auto appRunningRecord = serviceInner_->GetAppRunningRecordByAppName(appInfo->name); + abilityInfo->name = TEST_ABILITY_NAME + std::to_string(index); + abilityInfo->applicationName = appInfo->name; + abilityInfo->applicationInfo.bundleName = appInfo->name; + abilityInfo->process = appInfo->name; + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + auto appRunningRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo); EXPECT_NE(nullptr, appRunningRecord); return appRunningRecord; } @@ -104,6 +113,8 @@ void AmsAppRecentListModuleTest::CreateAppRecentList(const int32_t appNum) appInfo->process = appInfo->name; abilityInfo->name = TEST_ABILITY_NAME + std::to_string(i); abilityInfo->applicationName = appInfo->name; + abilityInfo->applicationInfo.bundleName = appInfo->name; + abilityInfo->process = appInfo->name; pid_t pid = i; sptr token = new (std::nothrow) MockAbilityToken(); MockAppSpawnClient *mockedSpawnClient = new MockAppSpawnClient(); @@ -139,6 +150,8 @@ HWTEST_F(AmsAppRecentListModuleTest, Create_Recent_List_001, TestSize.Level1) appInfo->name = TEST_APP_NAME + std::to_string(INDEX_NUM_2); abilityInfo->name = TEST_ABILITY_NAME + std::to_string(INDEX_NUM_2); abilityInfo->applicationName = TEST_APP_NAME + std::to_string(INDEX_NUM_2); + abilityInfo->applicationInfo.bundleName = appInfo->name; + abilityInfo->process = appInfo->name; sptr token = new MockAbilityToken(); MockAppSpawnClient *mockedSpawnClient = new MockAppSpawnClient(); @@ -171,6 +184,8 @@ HWTEST_F(AmsAppRecentListModuleTest, Create_Recent_List_002, TestSize.Level1) appInfo->bundleName = appInfo->name; abilityInfo->name = TEST_ABILITY_NAME + std::to_string(INDEX_NUM_10 + INDEX_NUM_1); abilityInfo->applicationName = TEST_APP_NAME + std::to_string(INDEX_NUM_10 + INDEX_NUM_1); + abilityInfo->applicationInfo.bundleName = appInfo->name; + abilityInfo->process = appInfo->name; pid_t pid = static_cast(INDEX_NUM_10 + INDEX_NUM_1); sptr token = new MockAbilityToken(); MockAppSpawnClient *mockedSpawnClient = new MockAppSpawnClient(); diff --git a/services/test/moduletest/common/ams/app_running_record_test/ams_app_running_record_module_test.cpp b/services/test/moduletest/common/ams/app_running_record_test/ams_app_running_record_module_test.cpp index 2a912c8942a5137d472e227faf66fe734bf256c6..d3a40b2e4ee404d24396c1ba53da21195a83021e 100644 --- a/services/test/moduletest/common/ams/app_running_record_test/ams_app_running_record_module_test.cpp +++ b/services/test/moduletest/common/ams/app_running_record_test/ams_app_running_record_module_test.cpp @@ -12,18 +12,25 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#define private public #include "app_running_record.h" +#undef private #include #include #include "iremote_object.h" #include "app_record_id.h" #include "app_scheduler_proxy.h" #include "app_scheduler_host.h" +#define private public #include "app_mgr_service_inner.h" +#undef private #include "mock_application.h" #include "ability_info.h" #include "application_info.h" +#include "mock_bundle_manager.h" #include "mock_ability_token.h" +#include "mock_app_scheduler.h" +#include "mock_app_spawn_client.h" using namespace testing::ext; using OHOS::iface_cast; @@ -101,23 +108,26 @@ protected: sptr token = abilityRecord->GetToken(); auto abilityName = abilityRecord->GetName(); std::string processName = GetTestAppName(index); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); - auto appRecordFromServ = - service_->GetOrCreateAppRunningRecord(token, appInfo, abilityInfo, processName, 0, result); + auto appRecordFromServ = service_->appRunningManager_->CheckAppRunningRecordIsExist + (appInfo->name, processName, appInfo->uid, bundleInfo); EXPECT_TRUE(appRecordFromServ); auto abilityRecordFromServ = appRecordFromServ->GetAbilityRunningRecord(GetTestAbilityName(index)); int32_t idFromServ = appRecordFromServ->GetRecordId(); sptr tokenFromServ = abilityRecordFromServ->GetToken(); auto nameFromServ = appRecordFromServ->GetName(); auto abilityNameFromServ = abilityRecordFromServ->GetName(); - EXPECT_TRUE(result.appExists) << "result is wrong!"; EXPECT_TRUE(id == idFromServ) << "fail, RecordId is not equal!"; EXPECT_TRUE(tokenFromServ.GetRefPtr() == token.GetRefPtr()) << "fail, token is not equal!"; EXPECT_EQ(name, nameFromServ) << "fail, app record name is not equal!"; EXPECT_EQ(abilityName, abilityNameFromServ) << "fail, app record name is not equal!"; } - std::unique_ptr service_{nullptr}; + std::unique_ptr service_ {nullptr}; + sptr mockBundleMgr_ {nullptr}; sptr GetMockToken() const { @@ -152,6 +162,8 @@ void AmsAppRunningRecordModuleTest::SetUp() { service_.reset(new (std::nothrow) AppMgrServiceInner()); mockToken_ = new (std::nothrow) MockAbilityToken(); + mockBundleMgr_ = new (std::nothrow) BundleMgrService(); + service_->SetBundleManager(mockBundleMgr_); } void AmsAppRunningRecordModuleTest::TearDown() @@ -180,10 +192,13 @@ HWTEST_F(AmsAppRunningRecordModuleTest, ApplicationStart_001, TestSize.Level1) appInfo->uid = 0; std::string processName = GetTestAppName(index); RecordQueryResult result; - auto record = service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, processName, 0, result); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + auto record = service_->CreateAppRunningRecord(GetMockToken(), nullptr, + appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo); record->SetUid(0); EXPECT_TRUE(record != nullptr) << ",create apprunningrecord fail!"; - EXPECT_FALSE(result.appExists) << ",result is wrong!"; // check apprunningrecord int32_t id = record->GetRecordId(); @@ -203,13 +218,11 @@ HWTEST_F(AmsAppRunningRecordModuleTest, ApplicationStart_001, TestSize.Level1) // update application state and check the state record->SetState(ApplicationState::APP_STATE_FOREGROUND); - RecordQueryResult newResult; - auto newRecord = - service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, processName, 0, newResult); + auto newRecord = service_->appRunningManager_->CheckAppRunningRecordIsExist + (appInfo->name, processName, appInfo->uid, bundleInfo); EXPECT_TRUE(newRecord); newRecord->SetUid(0); auto stateFromRec = newRecord->GetState(); - EXPECT_TRUE(newResult.appExists) << "fail, app is not exist!"; EXPECT_EQ(stateFromRec, ApplicationState::APP_STATE_FOREGROUND); // clear apprunningrecord @@ -243,11 +256,13 @@ HWTEST_F(AmsAppRunningRecordModuleTest, MultiApplicationStart_002, TestSize.Leve appInfo->name = GetTestAppName(i); appInfo->uid = 0; RecordQueryResult result; - auto record = - service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, processName, 0, result); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + auto record = service_->CreateAppRunningRecord(GetMockToken(), nullptr, + appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo); record->SetUid(0); EXPECT_TRUE(record != nullptr) << "create apprunningrecord fail!"; - EXPECT_FALSE(result.appExists) << "result is wrong!"; // check abilityrunningrecord & apprunningrecord int32_t id = record->GetRecordId(); @@ -287,10 +302,12 @@ HWTEST_F(AmsAppRunningRecordModuleTest, ScheduleTrimMemory_003, TestSize.Level1) std::string processName = GetTestAppName(index); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(index); - RecordQueryResult result; - auto record = service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, processName, 0, result); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + auto record = service_->CreateAppRunningRecord(GetMockToken(), nullptr, + appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo); EXPECT_TRUE(record != nullptr) << "create apprunningrecord fail!"; - EXPECT_FALSE(result.appExists) << "result is wrong!"; // LaunchApplication sptr mockApplication(new MockApplication()); @@ -335,10 +352,12 @@ HWTEST_F(AmsAppRunningRecordModuleTest, LowMemoryWarning_004, TestSize.Level1) std::string processName = GetTestAppName(index); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(index); - RecordQueryResult result; - auto record = service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, processName, 0, result); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + auto record = service_->CreateAppRunningRecord(GetMockToken(), nullptr, + appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo); EXPECT_TRUE(record != nullptr) << "create apprunningrecord fail!"; - EXPECT_FALSE(result.appExists) << "result is wrong!"; // LaunchApplication sptr mockApplication(new MockApplication()); @@ -385,9 +404,11 @@ HWTEST_F(AmsAppRunningRecordModuleTest, ApplicationStartAndQuit_005, TestSize.Le std::string processName = GetTestAppName(index); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(index); - RecordQueryResult result; - auto record = - service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, processName, 0, result); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + auto record = service_->CreateAppRunningRecord(GetMockToken(), nullptr, + appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo); EXPECT_TRUE(record != nullptr) << "create apprunningrecord fail!"; // LaunchApplication @@ -453,8 +474,11 @@ HWTEST_F(AmsAppRunningRecordModuleTest, ApplicationStatusChange_006, TestSize.Le std::string processName = GetTestAppName(index); auto appInfo = std::make_shared(); appInfo->name = GetTestAppName(index); - RecordQueryResult result; - auto record = service_->GetOrCreateAppRunningRecord(GetMockToken(), appInfo, abilityInfo, processName, 0, result); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + auto record = service_->CreateAppRunningRecord(GetMockToken(), nullptr, + appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo); EXPECT_TRUE(record != nullptr) << "create apprunningrecord fail!"; // LaunchApplication diff --git a/services/test/moduletest/common/ams/app_service_flow_test/ams_app_service_flow_module_test.cpp b/services/test/moduletest/common/ams/app_service_flow_test/ams_app_service_flow_module_test.cpp index f2d71c5baffea9822f605b44ce0b5f811702fa37..f9798be98b99df0eedcd2d907f9bc072355ac626 100644 --- a/services/test/moduletest/common/ams/app_service_flow_test/ams_app_service_flow_module_test.cpp +++ b/services/test/moduletest/common/ams/app_service_flow_test/ams_app_service_flow_module_test.cpp @@ -21,7 +21,11 @@ #include "app_launch_data.h" #include "app_log_wrapper.h" +#define private public #include "app_mgr_service_inner.h" +#undef private +#include "mock_ability_token.h" +#include "mock_bundle_manager.h" #include "mock_ability_token.h" #include "mock_app_scheduler.h" #include "mock_app_spawn_client.h" @@ -76,6 +80,7 @@ protected: protected: std::shared_ptr serviceInner_ = nullptr; std::shared_ptr handler_ = nullptr; + sptr mockBundleMgr_ {nullptr}; }; void AmsAppServiceFlowModuleTest::SetUpTestCase() @@ -91,6 +96,8 @@ void AmsAppServiceFlowModuleTest::SetUp() auto runner = EventRunner::Create("AmsAppServiceFlowModuleTest"); handler_ = std::make_shared(runner, serviceInner_); serviceInner_->SetEventHandler(handler_); + mockBundleMgr_ = new (std::nothrow) BundleMgrService(); + serviceInner_->SetBundleManager(mockBundleMgr_); } void AmsAppServiceFlowModuleTest::TearDown() @@ -105,6 +112,7 @@ sptr AmsAppServiceFlowModuleTest::TestCreateApplicationClient( sptr mockAppScheduler = new (std::nothrow) MockAppScheduler(); sptr client = iface_cast(mockAppScheduler.GetRefPtr()); appRecord->SetApplicationClient(client); + appRecord->LaunchPendingAbilities(); return mockAppScheduler; } @@ -113,30 +121,34 @@ TestApplicationPreRunningRecord AmsAppServiceFlowModuleTest::TestCreateApplicati const std::string &abilityName, const std::string &appName, const AbilityState abilityState, const ApplicationState appState) const { - RecordQueryResult result; - AbilityInfo abilityInfo; - ApplicationInfo appInfo; - - appInfo.name = appName; - appInfo.bundleName = appName; // specify process condition - appInfo.uid = 0; - abilityInfo.name = abilityName; - abilityInfo.applicationInfo.uid = 0; + auto abilityInfo = std::make_shared(); + auto appInfo = std::make_shared(); + + appInfo->name = appName; + appInfo->bundleName = appName; // specify process condition + appInfo->uid = 0; + abilityInfo->name = abilityName; + abilityInfo->applicationInfo.uid = 0; sptr token = new (std::nothrow) MockAbilityToken(); - auto appRecord = serviceInner_->GetOrCreateAppRunningRecord(token, - std::make_shared(appInfo), - std::make_shared(abilityInfo), - appInfo.bundleName, - 0, - result); + + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist + (appInfo->name, appName, appInfo->uid, bundleInfo); + if (!appRecord) { + appRecord = serviceInner_->CreateAppRunningRecord(token, nullptr, + appInfo, abilityInfo, appName, bundleInfo, hapModuleInfo); + appRecord->GetPriorityObject()->SetPid(TestApplicationPreRunningRecord::g_pid++); + } else { + serviceInner_->StartAbility(token, nullptr, abilityInfo, appRecord, hapModuleInfo); + } EXPECT_TRUE(appRecord); appRecord->SetUid(0); appRecord->SetEventHandler(handler_); - if (!result.appExists && appRecord) { - appRecord->GetPriorityObject()->SetPid(TestApplicationPreRunningRecord::g_pid++); - } auto abilityRecord = appRecord->GetAbilityRunningRecordByToken(token); EXPECT_NE(abilityRecord, nullptr); abilityRecord->SetState(abilityState);