From 5354017f5bcc194112e1eabce7f015c27232dfd7 Mon Sep 17 00:00:00 2001 From: zhangzezhong Date: Thu, 15 May 2025 10:28:25 +0800 Subject: [PATCH] startup support feature module Signed-off-by: zhangzezhong --- .../ability_runtime/app/js_ability_stage.cpp | 34 ++++-- frameworks/native/appkit/app/main_thread.cpp | 2 +- .../native/appkit/app/ohos_application.cpp | 14 ++- .../appkit/app_startup/app_startup_task.cpp | 20 ++++ .../appkit/app_startup/js_startup_task.cpp | 5 + .../appkit/app_startup/startup_manager.cpp | 109 +++++++++++++++--- .../app_startup/startup_task_manager.cpp | 21 ++++ .../ability_runtime/app/js_ability_stage.h | 6 +- .../kits/native/appkit/app/ohos_application.h | 3 +- .../appkit/app_startup/app_startup_task.h | 11 ++ .../appkit/app_startup/js_startup_task.h | 2 + .../appkit/app_startup/startup_manager.h | 16 ++- .../appkit/app_startup/startup_task_manager.h | 3 + .../startup_manager_test.cpp | 42 ++++++- 14 files changed, 249 insertions(+), 39 deletions(-) diff --git a/frameworks/native/appkit/ability_runtime/app/js_ability_stage.cpp b/frameworks/native/appkit/ability_runtime/app/js_ability_stage.cpp index c8739b4a05..9819cc243f 100644 --- a/frameworks/native/appkit/ability_runtime/app/js_ability_stage.cpp +++ b/frameworks/native/appkit/ability_runtime/app/js_ability_stage.cpp @@ -489,12 +489,13 @@ int32_t JsAbilityStage::RunAutoStartupTask(const std::function &callback TAG_LOGE(AAFwkTag::APPKIT, "null hapModuleInfo"); return ERR_INVALID_VALUE; } - if (hapModuleInfo->moduleType != AppExecFwk::ModuleType::ENTRY) { - TAG_LOGD(AAFwkTag::APPKIT, "not entry module"); + if (hapModuleInfo->moduleType != AppExecFwk::ModuleType::ENTRY && + hapModuleInfo->moduleType != AppExecFwk::ModuleType::FEATURE) { + TAG_LOGD(AAFwkTag::APPKIT, "not entry module or feature module"); return ERR_INVALID_VALUE; } if (hapModuleInfo->appStartup.empty()) { - TAG_LOGD(AAFwkTag::APPKIT, "entry module no app startup config"); + TAG_LOGD(AAFwkTag::APPKIT, "module no app startup config"); return ERR_INVALID_VALUE; } if (!shellContextRef_) { @@ -504,7 +505,7 @@ int32_t JsAbilityStage::RunAutoStartupTask(const std::function &callback if (result != ERR_OK) { return result; } - return RunAutoStartupTaskInner(callback, isAsyncCallback); + return RunAutoStartupTaskInner(callback, isAsyncCallback, hapModuleInfo->name); } int32_t JsAbilityStage::RegisterAppStartupTask(const std::shared_ptr& hapModuleInfo) @@ -519,18 +520,22 @@ int32_t JsAbilityStage::RegisterAppStartupTask(const std::shared_ptrRunLoadModuleStartupConfigTask(needRunAutoStartupTask, hapModuleInfo); + if (result != ERR_OK) { + return result; + } if (!needRunAutoStartupTask) { return ERR_OK; } jsRuntime_.UpdateModuleNameAndAssetPath(hapModuleInfo->moduleName); const std::string &configEntry = startupManager->GetPendingConfigEntry(); - if (!LoadJsStartupConfig(configEntry)) { + if (!LoadJsStartupConfig(configEntry, hapModuleInfo->moduleName, hapModuleInfo->moduleType)) { TAG_LOGE(AAFwkTag::APPKIT, "load js appStartup config failed."); return ERR_INVALID_VALUE; } - const std::vector &startupTaskInfos = startupManager->GetStartupTaskInfos(); + const std::vector startupTaskInfos = startupManager->GetStartupTaskInfos(hapModuleInfo->name); for (const auto& item : startupTaskInfos) { std::unique_ptr startupJsRef = LoadJsOhmUrl( item.srcEntry, item.ohmUrl, item.moduleName, item.hapPath, item.esModule); @@ -543,12 +548,15 @@ int32_t JsAbilityStage::RegisterAppStartupTask(const std::shared_ptrSetIsExcludeFromAutoStart(item.excludeFromAutoStart); jsStartupTask->SetCallCreateOnMainThread(item.callCreateOnMainThread); jsStartupTask->SetWaitOnMainThread(item.waitOnMainThread); + jsStartupTask->SetModuleName(hapModuleInfo->moduleName); + jsStartupTask->SetModuleType(hapModuleInfo->moduleType); startupManager->RegisterAppStartupTask(item.name, jsStartupTask); } return ERR_OK; } -int32_t JsAbilityStage::RunAutoStartupTaskInner(const std::function &callback, bool &isAsyncCallback) +int32_t JsAbilityStage::RunAutoStartupTaskInner(const std::function &callback, bool &isAsyncCallback, + const std::string &moduleName) { std::shared_ptr startupManager = DelayedSingleton::GetInstance(); if (startupManager == nullptr) { @@ -556,10 +564,15 @@ int32_t JsAbilityStage::RunAutoStartupTaskInner(const std::function &cal return ERR_INVALID_VALUE; } std::shared_ptr startupTaskManager = nullptr; - int32_t result = startupManager->BuildAutoAppStartupTaskManager(startupTaskManager); + int32_t result = startupManager->BuildAutoAppStartupTaskManager(startupTaskManager, moduleName); if (result != ERR_OK) { return result; } + if (startupTaskManager == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null startupTaskManager"); + return ERR_INVALID_VALUE; + } + startupTaskManager->UpdateStartupTaskContextRef(shellContextRef_); result = startupTaskManager->Prepare(); if (result != ERR_OK) { return result; @@ -634,7 +647,8 @@ std::unique_ptr JsAbilityStage::LoadJsSrcEntry(const std::strin return jsCode; } -bool JsAbilityStage::LoadJsStartupConfig(const std::string &srcEntry) +bool JsAbilityStage::LoadJsStartupConfig(const std::string &srcEntry, const std::string &moduleName, + AppExecFwk::ModuleType moduleType) { std::unique_ptr startupConfigEntry = LoadJsSrcEntry(srcEntry); if (startupConfigEntry == nullptr) { @@ -655,7 +669,7 @@ bool JsAbilityStage::LoadJsStartupConfig(const std::string &srcEntry) TAG_LOGE(AAFwkTag::APPKIT, "null startupManager"); return false; } - startupManager->SetDefaultConfig(startupConfig); + startupManager->SetModuleConfig(startupConfig, moduleName, moduleType == AppExecFwk::ModuleType::ENTRY); return true; } diff --git a/frameworks/native/appkit/app/main_thread.cpp b/frameworks/native/appkit/app/main_thread.cpp index 0c262bb46e..ed318653c5 100644 --- a/frameworks/native/appkit/app/main_thread.cpp +++ b/frameworks/native/appkit/app/main_thread.cpp @@ -1526,7 +1526,7 @@ void MainThread::HandleLaunchApplication(const AppLaunchData &appLaunchData, con } #endif - application_->PreloadAppStartup(bundleInfo, entryHapModuleInfo, appLaunchData.GetPreloadModuleName()); + application_->PreloadAppStartup(bundleInfo, appLaunchData.GetPreloadModuleName()); if (isStageBased) { // Create runtime diff --git a/frameworks/native/appkit/app/ohos_application.cpp b/frameworks/native/appkit/app/ohos_application.cpp index 564e10b6f8..0be26d6fef 100644 --- a/frameworks/native/appkit/app/ohos_application.cpp +++ b/frameworks/native/appkit/app/ohos_application.cpp @@ -869,8 +869,7 @@ void OHOSApplication::CleanEmptyAbilityStage() } } -void OHOSApplication::PreloadAppStartup(const BundleInfo &bundleInfo, - const HapModuleInfo &entryHapModuleInfo, const std::string &preloadModuleName) +void OHOSApplication::PreloadAppStartup(const BundleInfo &bundleInfo, const std::string &preloadModuleName) { if (!IsMainProcess(bundleInfo.applicationInfo.name, bundleInfo.applicationInfo.process)) { TAG_LOGD(AAFwkTag::STARTUP, "not main process"); @@ -883,7 +882,16 @@ void OHOSApplication::PreloadAppStartup(const BundleInfo &bundleInfo, TAG_LOGE(AAFwkTag::STARTUP, "failed to get startupManager"); return; } - startupManager->PreloadAppHintStartup(bundleInfo, entryHapModuleInfo, preloadModuleName); + + AppExecFwk::HapModuleInfo preloadHapModuleInfo; + if (!bundleInfo.hapModuleInfos.empty()) { + for (const auto& hapModuleInfo : bundleInfo.hapModuleInfos) { + if (hapModuleInfo.name == preloadModuleName) { + startupManager->PreloadAppHintStartup(bundleInfo, hapModuleInfo, preloadModuleName); + break; + } + } + } } bool OHOSApplication::IsUpdateColorNeeded(Configuration &config, AbilityRuntime::SetLevel level) diff --git a/frameworks/native/appkit/app_startup/app_startup_task.cpp b/frameworks/native/appkit/app_startup/app_startup_task.cpp index 8cb07a2475..8e591f5648 100644 --- a/frameworks/native/appkit/app_startup/app_startup_task.cpp +++ b/frameworks/native/appkit/app_startup/app_startup_task.cpp @@ -32,5 +32,25 @@ void AppStartupTask::SetIsExcludeFromAutoStart(bool excludeFromAutoStart) { isExcludeFromAutoStart_ = excludeFromAutoStart; } + +void AppStartupTask::SetModuleName(const std::string &moduleName) +{ + moduleName_ = moduleName; +} + +const std::string& AppStartupTask::GetModuleName() const +{ + return moduleName_; +} + +void AppStartupTask::SetModuleType(AppExecFwk::ModuleType moduleType) +{ + moduleType_ = moduleType; +} + +AppExecFwk::ModuleType AppStartupTask::GetModuleType() const +{ + return moduleType_; +} } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/native/appkit/app_startup/js_startup_task.cpp b/frameworks/native/appkit/app_startup/js_startup_task.cpp index 06403b96c6..1beb8f98f2 100644 --- a/frameworks/native/appkit/app_startup/js_startup_task.cpp +++ b/frameworks/native/appkit/app_startup/js_startup_task.cpp @@ -171,6 +171,11 @@ void JsStartupTask::OnAsyncTaskCompleted(const std::shared_ptrCall(result); } +void JsStartupTask::UpdateContextRef(std::shared_ptr &contextJsRef) +{ + contextJsRef_ = contextJsRef; +} + int32_t JsStartupTask::RunTaskOnDependencyCompleted(const std::string &dependencyName, const std::shared_ptr &result) { diff --git a/frameworks/native/appkit/app_startup/startup_manager.cpp b/frameworks/native/appkit/app_startup/startup_manager.cpp index 8073b838e7..a679f540a6 100644 --- a/frameworks/native/appkit/app_startup/startup_manager.cpp +++ b/frameworks/native/appkit/app_startup/startup_manager.cpp @@ -73,23 +73,25 @@ StartupManager::StartupManager() StartupManager::~StartupManager() = default; int32_t StartupManager::PreloadAppHintStartup(const AppExecFwk::BundleInfo& bundleInfo, - const AppExecFwk::HapModuleInfo& entryInfo, const std::string &preloadModuleName) + const AppExecFwk::HapModuleInfo& preloadHapModuleInfo, const std::string &preloadModuleName) { moduleStartupConfigInfos_.clear(); - if (entryInfo.appStartup.empty()) { - TAG_LOGD(AAFwkTag::STARTUP, "entry module no app startup config"); + if (preloadHapModuleInfo.appStartup.empty()) { + TAG_LOGD(AAFwkTag::STARTUP, "module no app startup config"); return ERR_OK; } bundleName_ = bundleInfo.name; - moduleStartupConfigInfos_.emplace_back(entryInfo.name, entryInfo.appStartup, entryInfo.hapPath, - entryInfo.moduleType, entryInfo.compileMode == AppExecFwk::CompileMode::ES_MODULE); + moduleStartupConfigInfos_.emplace_back(preloadHapModuleInfo.name, preloadHapModuleInfo.appStartup, + preloadHapModuleInfo.hapPath, preloadHapModuleInfo.moduleType, + preloadHapModuleInfo.compileMode == AppExecFwk::CompileMode::ES_MODULE); + isModuleStartupConfigInited_.emplace(preloadHapModuleInfo.name); for (const auto& module : bundleInfo.hapModuleInfos) { if (module.appStartup.empty()) { continue; } if (module.moduleType != AppExecFwk::ModuleType::SHARED) { - // ENTRY has been added and FEATURE is not supported. + // ENTRY or FEATURE has been added. continue; } moduleStartupConfigInfos_.emplace_back(module.name, module.appStartup, module.hapPath, module.moduleType, @@ -101,9 +103,8 @@ int32_t StartupManager::PreloadAppHintStartup(const AppExecFwk::BundleInfo& bund return ERR_STARTUP_INTERNAL_ERROR; } - if (entryInfo.name != preloadModuleName) { - // not entry module, no need to load app startup config and preload so now. - TAG_LOGD(AAFwkTag::STARTUP, "not entry module: %{public}s", preloadModuleName.c_str()); + if (preloadHapModuleInfo.name != preloadModuleName) { + TAG_LOGD(AAFwkTag::STARTUP, "preload module name: %{public}s", preloadModuleName.c_str()); return ERR_OK; } TAG_LOGD(AAFwkTag::STARTUP, "appStartup modules: %{public}zu", moduleStartupConfigInfos_.size()); @@ -118,7 +119,8 @@ int32_t StartupManager::PreloadAppHintStartup(const AppExecFwk::BundleInfo& bund return ERR_OK; } -int32_t StartupManager::BuildAutoAppStartupTaskManager(std::shared_ptr &startupTaskManager) +int32_t StartupManager::BuildAutoAppStartupTaskManager(std::shared_ptr &startupTaskManager, + const std::string &moduleName) { std::map> autoStartupTasks; std::set dependenciesSet; @@ -127,6 +129,10 @@ int32_t StartupManager::BuildAutoAppStartupTaskManager(std::shared_ptrGetModuleName() != moduleName && + iter.second->GetModuleType() != AppExecFwk::ModuleType::SHARED) { + continue; + } if (iter.second->GetIsExcludeFromAutoStart()) { continue; } @@ -148,7 +154,7 @@ int32_t StartupManager::BuildAutoAppStartupTaskManager(std::shared_ptr(startupTaskManagerId, autoStartupTasks); - startupTaskManager->SetConfig(defaultConfig_); + startupTaskManager->SetConfig(moduleConfigs_[moduleName]); startupTaskManagerMap_.emplace(startupTaskManagerId, startupTaskManager); startupTaskManagerId++; return ERR_OK; @@ -189,6 +195,10 @@ int32_t StartupManager::BuildAppStartupTaskManager(const std::vectorsecond->GetModuleType() == AppExecFwk::ModuleType::FEATURE) { + TAG_LOGE(AAFwkTag::STARTUP, "manual task of feature type is not supported"); + return ERR_STARTUP_DEPENDENCY_NOT_FOUND; + } currentStartupTasks.emplace(iter, findResult->second); auto dependencies = findResult->second->GetDependencies(); for (auto &dep : dependencies) { @@ -230,6 +240,15 @@ int32_t StartupManager::OnStartupTaskManagerComplete(uint32_t id) return ERR_OK; } +void StartupManager::SetModuleConfig(const std::shared_ptr &config, const std::string &moduleName, + bool isDefaultConfig = false) +{ + moduleConfigs_[moduleName] = config; + if (isDefaultConfig) { + defaultConfig_ = config; + } +} + void StartupManager::SetDefaultConfig(const std::shared_ptr &config) { defaultConfig_ = config; @@ -332,9 +351,19 @@ bool StartupManager::HasAppStartupConfig() const return !moduleStartupConfigInfos_.empty(); } -const std::vector &StartupManager::GetStartupTaskInfos() const +const std::vector StartupManager::GetStartupTaskInfos(const std::string &name) { - return pendingStartupTaskInfos_; + if (!isAppStartupTaskRegistered_) { + isAppStartupTaskRegistered_ = true; + return pendingStartupTaskInfos_; + } + std::vector pendingStartupTaskInfos; + for (const auto &iter : pendingStartupTaskInfos_) { + if (iter.moduleName == name) { + pendingStartupTaskInfos.emplace_back(iter); + } + } + return pendingStartupTaskInfos; } const std::string &StartupManager::GetPendingConfigEntry() const @@ -393,6 +422,11 @@ int32_t StartupManager::RegisterPreloadSoStartupTask( return ERR_OK; } +void StartupManager::ClearAppStartupTask() +{ + appStartupTasks_.clear(); +} + int32_t StartupManager::RegisterAppStartupTask( const std::string &name, const std::shared_ptr &startupTask) { @@ -401,7 +435,6 @@ int32_t StartupManager::RegisterAppStartupTask( TAG_LOGE(AAFwkTag::STARTUP, "exist preload so startup task %{public}s", name.c_str()); return ERR_STARTUP_INVALID_VALUE; } - auto result = appStartupTasks_.emplace(name, startupTask); if (!result.second) { TAG_LOGE(AAFwkTag::STARTUP, "exist app startup task %{public}s", name.c_str()); @@ -549,6 +582,48 @@ int32_t StartupManager::AddLoadAppStartupConfigTask( return ERR_OK; } +int32_t StartupManager::RunLoadModuleStartupConfigTask( + bool &needRunAutoStartupTask, const std::shared_ptr& hapModuleInfo) +{ + if (isModuleStartupConfigInited_.count(hapModuleInfo->name) != 0) { + TAG_LOGD(AAFwkTag::STARTUP, "module startup config already loaded"); + return ERR_OK; + } + ModuleStartupConfigInfo configInfo(hapModuleInfo->name, hapModuleInfo->appStartup, hapModuleInfo->hapPath, + hapModuleInfo->moduleType, hapModuleInfo->compileMode == AppExecFwk::CompileMode::ES_MODULE); + if (hapModuleInfo->appStartup.empty()) { + TAG_LOGD(AAFwkTag::STARTUP, "module startup config is empty"); + return ERR_OK; + } + TAG_LOGD(AAFwkTag::STARTUP, "load module %{public}s, type: %{public}d", hapModuleInfo->name.c_str(), + hapModuleInfo->moduleType); + std::string configStr; + int32_t result = GetStartupConfigString(configInfo, configStr); + if (result != ERR_OK) { + return result; + } + std::map> preloadSoStartupTasks; + std::vector pendingStartupTaskInfos; + std::string pendingConfigEntry; + bool success = AnalyzeStartupConfig(configInfo, configStr, + preloadSoStartupTasks_, pendingStartupTaskInfos_, pendingConfigEntry); + if (!success) { + TAG_LOGE(AAFwkTag::STARTUP, "failed to parse app startup module %{public}s, type: %{public}d", + configInfo.name_.c_str(), configInfo.moduleType_); + return ERR_STARTUP_CONFIG_PARSE_ERROR; + } + std::lock_guard guard(appStartupConfigInitializationMutex_); + preloadSoStartupTasks_.insert(preloadSoStartupTasks.begin(), preloadSoStartupTasks.end()); + pendingStartupTaskInfos_.insert(pendingStartupTaskInfos_.end(), pendingStartupTaskInfos.begin(), + pendingStartupTaskInfos.end()); + pendingConfigEntry_ = pendingConfigEntry; + isModuleStartupConfigInited_.emplace(hapModuleInfo->name); + if (!needRunAutoStartupTask && pendingConfigEntry.size() > 0) { + needRunAutoStartupTask = true; + } + return ERR_OK; +} + int32_t StartupManager::RunLoadAppStartupConfigTask() { if (isAppStartupConfigInited_) { @@ -814,7 +889,7 @@ bool StartupManager::AnalyzeStartupConfig(const ModuleStartupConfigInfo& info, c return false; } - if (info.moduleType_ == AppExecFwk::ModuleType::ENTRY) { + if (info.moduleType_ == AppExecFwk::ModuleType::ENTRY || info.moduleType_ == AppExecFwk::ModuleType::FEATURE) { if (!(startupConfigJson.contains(CONFIG_ENTRY) && startupConfigJson[CONFIG_ENTRY].is_string())) { TAG_LOGE(AAFwkTag::STARTUP, "no config entry."); return false; @@ -958,7 +1033,7 @@ void StartupManager::SetOptionalParameters(const nlohmann::json& module, AppExec startupTaskInfo.ohmUrl = module.at(OHMURL).get(); } - if (moduleType != AppExecFwk::ModuleType::ENTRY) { + if (moduleType != AppExecFwk::ModuleType::ENTRY && moduleType != AppExecFwk::ModuleType::FEATURE) { startupTaskInfo.excludeFromAutoStart = true; return; } @@ -982,7 +1057,7 @@ void StartupManager::SetOptionalParameters(const nlohmann::json &module, AppExec task->SetDependencies(dependencies); } - if (moduleType != AppExecFwk::ModuleType::ENTRY) { + if (moduleType != AppExecFwk::ModuleType::ENTRY && moduleType != AppExecFwk::ModuleType::FEATURE) { task->SetIsExcludeFromAutoStart(true); return; } diff --git a/frameworks/native/appkit/app_startup/startup_task_manager.cpp b/frameworks/native/appkit/app_startup/startup_task_manager.cpp index e4d77c5854..359d8227b7 100644 --- a/frameworks/native/appkit/app_startup/startup_task_manager.cpp +++ b/frameworks/native/appkit/app_startup/startup_task_manager.cpp @@ -16,6 +16,7 @@ #include "startup_task_manager.h" #include "hilog_tag_wrapper.h" +#include "js_startup_task.h" #include "startup_manager.h" #include "startup_topologysort.h" @@ -181,5 +182,25 @@ void StartupTaskManager::OnTimeout() CallListenerOnCompleted(ERR_STARTUP_TIMEOUT, StartupUtils::GetErrorMessage(ERR_STARTUP_TIMEOUT)); DelayedSingleton::GetInstance()->OnStartupTaskManagerComplete(startupTaskManagerId_); } + +void StartupTaskManager::UpdateStartupTaskContextRef(std::shared_ptr &contextJsRef) +{ + for (auto& iter : tasks_) { + if (iter.second == nullptr) { + continue; + } + if (iter.second->GetType() != JsStartupTask::TASK_TYPE) { + continue; + } + std::shared_ptr jsStartupTask = std::static_pointer_cast(iter.second); + if (jsStartupTask == nullptr) { + TAG_LOGE(AAFwkTag::STARTUP, "null jsStartupTask: %{public}s", iter.first.c_str()); + continue; + } + if (jsStartupTask->GetModuleType() == AppExecFwk::ModuleType::SHARED) { + jsStartupTask->UpdateContextRef(contextJsRef); + } + } +} } // namespace AbilityRuntime } // namespace OHOS diff --git a/interfaces/kits/native/appkit/ability_runtime/app/js_ability_stage.h b/interfaces/kits/native/appkit/ability_runtime/app/js_ability_stage.h index 9d6bee4a48..efd7224b11 100644 --- a/interfaces/kits/native/appkit/ability_runtime/app/js_ability_stage.h +++ b/interfaces/kits/native/appkit/ability_runtime/app/js_ability_stage.h @@ -77,7 +77,8 @@ private: std::unique_ptr LoadJsSrcEntry(const std::string &srcEntry); - bool LoadJsStartupConfig(const std::string &srcEntry); + bool LoadJsStartupConfig(const std::string &srcEntry, const std::string &moduleName, + AppExecFwk::ModuleType moduleType); bool CallOnPrepareTerminate(napi_env env, AppExecFwk::AbilityTransactionCallbackInfo *callbackInfo) const; @@ -88,7 +89,8 @@ private: int32_t RegisterAppStartupTask(const std::shared_ptr& hapModuleInfo); - static int32_t RunAutoStartupTaskInner(const std::function &callback, bool &isAsyncCallback); + int32_t RunAutoStartupTaskInner(const std::function &callback, bool &isAsyncCallback, + const std::string &moduleName); void SetJsAbilityStage(const std::shared_ptr &context); diff --git a/interfaces/kits/native/appkit/app/ohos_application.h b/interfaces/kits/native/appkit/app/ohos_application.h index 4e412b2453..960f2b24c2 100644 --- a/interfaces/kits/native/appkit/app/ohos_application.h +++ b/interfaces/kits/native/appkit/app/ohos_application.h @@ -230,8 +230,7 @@ public: bool GetDisplayConfig(uint64_t displayId, float &density, std::string &directionStr); #endif - void PreloadAppStartup(const BundleInfo &bundleInfo, const HapModuleInfo &entryHapModuleInfo, - const std::string &preloadModuleName); + void PreloadAppStartup(const BundleInfo &bundleInfo, const std::string &preloadModuleName); private: void UpdateAppContextResMgr(const Configuration &config); diff --git a/interfaces/kits/native/appkit/app_startup/app_startup_task.h b/interfaces/kits/native/appkit/app_startup/app_startup_task.h index bde5dadec0..06fb14d8ee 100644 --- a/interfaces/kits/native/appkit/app_startup/app_startup_task.h +++ b/interfaces/kits/native/appkit/app_startup/app_startup_task.h @@ -18,6 +18,7 @@ #include +#include "bundle_info.h" #include "startup_task.h" namespace OHOS { @@ -32,8 +33,18 @@ public: void SetIsExcludeFromAutoStart(bool excludeFromAutoStart); + void SetModuleName(const std::string &moduleName); + + const std::string& GetModuleName() const; + + void SetModuleType(AppExecFwk::ModuleType moduleType); + + AppExecFwk::ModuleType GetModuleType() const; + protected: bool isExcludeFromAutoStart_ = false; + std::string moduleName_; + AppExecFwk::ModuleType moduleType_; }; } // namespace AbilityRuntime } // namespace OHOS diff --git a/interfaces/kits/native/appkit/app_startup/js_startup_task.h b/interfaces/kits/native/appkit/app_startup/js_startup_task.h index 1f664954cd..ca10a87353 100644 --- a/interfaces/kits/native/appkit/app_startup/js_startup_task.h +++ b/interfaces/kits/native/appkit/app_startup/js_startup_task.h @@ -41,6 +41,8 @@ public: void OnAsyncTaskCompleted(const std::shared_ptr &result); + void UpdateContextRef(std::shared_ptr &contextJsRef); + private: JsRuntime &jsRuntime_; std::unique_ptr startupJsRef_; diff --git a/interfaces/kits/native/appkit/app_startup/startup_manager.h b/interfaces/kits/native/appkit/app_startup/startup_manager.h index 9397c8f1f4..f07c2e2257 100644 --- a/interfaces/kits/native/appkit/app_startup/startup_manager.h +++ b/interfaces/kits/native/appkit/app_startup/startup_manager.h @@ -65,20 +65,29 @@ public: int32_t LoadAppStartupTaskConfig(bool &needRunAutoStartupTask); - const std::vector &GetStartupTaskInfos() const; + const std::vector GetStartupTaskInfos(const std::string &name); const std::string &GetPendingConfigEntry() const; + void ClearAppStartupTask(); + int32_t RegisterAppStartupTask( const std::string &name, const std::shared_ptr &startupTask); - int32_t BuildAutoAppStartupTaskManager(std::shared_ptr &startupTaskManager); + int32_t BuildAutoAppStartupTaskManager(std::shared_ptr &startupTaskManager, + const std::string &moduleName); int32_t BuildAppStartupTaskManager(const std::vector &inputDependencies, std::shared_ptr &startupTaskManager); int32_t OnStartupTaskManagerComplete(uint32_t id); + int32_t RunLoadModuleStartupConfigTask( + bool &needRunAutoStartupTask, const std::shared_ptr& hapModuleInfo); + + void SetModuleConfig(const std::shared_ptr &config, const std::string &moduleName, + bool isDefaultConfig); + void SetDefaultConfig(const std::shared_ptr &config); const std::shared_ptr& GetDefaultConfig() const; @@ -104,6 +113,8 @@ private: std::mutex appStartupConfigInitializationMutex_; std::atomic isAppStartupConfigInited_ = false; + std::atomic isAppStartupTaskRegistered_ = false; + std::set isModuleStartupConfigInited_; std::mutex startupTaskManagerMutex_; uint32_t startupTaskManagerId = 0; @@ -120,6 +131,7 @@ private: bool autoPreloadSoStopped_ = false; std::shared_ptr defaultConfig_; + std::map> moduleConfigs_; std::shared_ptr mainHandler_; std::shared_ptr preloadHandler_; diff --git a/interfaces/kits/native/appkit/app_startup/startup_task_manager.h b/interfaces/kits/native/appkit/app_startup/startup_task_manager.h index dc6e50fa64..160950300d 100644 --- a/interfaces/kits/native/appkit/app_startup/startup_task_manager.h +++ b/interfaces/kits/native/appkit/app_startup/startup_task_manager.h @@ -21,6 +21,7 @@ #include #include "event_handler.h" +#include "js_runtime.h" #include "startup_config.h" #include "startup_task.h" #include "startup_task_dispatcher.h" @@ -49,6 +50,8 @@ public: void OnTimeout(); + void UpdateStartupTaskContextRef(std::shared_ptr &contextJsRef); + private: uint32_t startupTaskManagerId_ = 0; std::shared_ptr config_; diff --git a/test/unittest/frameworks_kits_appkit_native_test/startup_manager_test.cpp b/test/unittest/frameworks_kits_appkit_native_test/startup_manager_test.cpp index 4f858bc8fb..e371d5a224 100644 --- a/test/unittest/frameworks_kits_appkit_native_test/startup_manager_test.cpp +++ b/test/unittest/frameworks_kits_appkit_native_test/startup_manager_test.cpp @@ -109,7 +109,7 @@ HWTEST_F(StartupManagerTest, BuildAutoAppStartupTaskManager_0100, Function | Med std::make_shared(startupTaskManagerId, autoStartupTasks); EXPECT_TRUE(startupTaskManager != nullptr); startupManager->appStartupTasks_.emplace(name, nullptr); - int32_t ret = startupManager->BuildAutoAppStartupTaskManager(startupTaskManager); + int32_t ret = startupManager->BuildAutoAppStartupTaskManager(startupTaskManager, ""); EXPECT_EQ(ret, ERR_STARTUP_INTERNAL_ERROR); startupManager->appStartupTasks_.clear(); startupManager->appStartupTasks_.emplace(name, startupTask); @@ -117,7 +117,7 @@ HWTEST_F(StartupManagerTest, BuildAutoAppStartupTaskManager_0100, Function | Med dependencies.emplace_back(name1); startupTask1->SetDependencies(dependencies); startupManager->appStartupTasks_.emplace(name1, startupTask1); - ret = startupManager->BuildAutoAppStartupTaskManager(startupTaskManager); + ret = startupManager->BuildAutoAppStartupTaskManager(startupTaskManager, ""); EXPECT_EQ(ret, ERR_OK); GTEST_LOG_(INFO) << "StartupManagerTest BuildAutoAppStartupTaskManager_0100 end"; } @@ -981,6 +981,44 @@ HWTEST_F(StartupManagerTest, AnalyzePreloadSoStartupTaskInner_0200, Function | M GTEST_LOG_(INFO) << "StartupManagerTest AnalyzePreloadSoStartupTaskInner_0200 end"; } +/** + * @tc.name: GetModuleConfig_0100 + * @tc.type: FUNC + * @tc.Function: GetModuleConfig + */ +HWTEST_F(StartupManagerTest, GetModuleConfig_0100, Function | MediumTest | Level1) +{ + std::shared_ptr startupManager = DelayedSingleton::GetInstance(); + EXPECT_TRUE(startupManager != nullptr); + std::string name = "test_name"; + std::shared_ptr appStartupTask = std::make_shared(name, "duri"); + startupManager->appStartupTasks_.emplace(name, appStartupTask); + std::string moduleName = "application"; + startupManager->SetModuleConfig(nullptr, moduleName, false); + EXPECT_EQ(startupManager->moduleConfigs_[moduleName], nullptr); +} + +/** + * @tc.name: RunLoadModuleStartupConfigTask_0100 + * @tc.type: FUNC + * @tc.Function: RunLoadModuleStartupConfigTask + */ +HWTEST_F(StartupManagerTest, RunLoadModuleStartupConfigTask_0100, Function | MediumTest | Level1) +{ + std::shared_ptr startupManager = DelayedSingleton::GetInstance(); + EXPECT_TRUE(startupManager != nullptr); + std::string name = "test_name"; + std::shared_ptr appStartupTask = std::make_shared(name, "duri"); + startupManager->appStartupTasks_.emplace(name, appStartupTask); + std::string moduleName = "application"; + bool needRunAutoStartupTask = false; + std::shared_ptr hapModuleInfo = std::make_shared(); + hapModuleInfo->name = moduleName; + startupManager->isModuleStartupConfigInited_.emplace(moduleName); + int32_t result = startupManager->RunLoadModuleStartupConfigTask(needRunAutoStartupTask, hapModuleInfo); + EXPECT_EQ(result, ERR_OK); +} + /** * @tc.name: GetStartupConfigString_0200 * @tc.type: FUNC