!19393 merge abilitystage into master

abilitystage set launchElement

Created-by: hanchen45
Commit-by: hanchen45
Merged-by: openharmony_ci
Description: **IssueNo**:

**Description**:

**稳定性自检:**
| 自检项                                                       | 自检结果  |
| ------------------------------------------------------------ | -------- |
| 涉及跨进程调用的相关操作需要抛至主线程或加锁防止并发              |     pass     |
| 成员变量进行赋值或创建需要排查并发                               |   pass       |
| 谨慎在lambda表达式中使用引用捕获                                |   pass       |
| 谨慎在未经拷贝的情况下使用外部传入的string、C字符串               |       pass   |
| map\vector\list\set等stl模板类使用时需要排查并发                |   pass       |
| 谨慎考虑加锁范围                                               |     pass     |
| 在IPC通信中谨慎使用同步通信方式                                 |      pass    |
| 禁止传递this指针至其他模块或线程(特别是eventhandler任务)        |     pass     |
| 禁止将外部传入的裸指针在内部直接构造智能指针                      |   pass       |
| 禁止多个独立创建的智能指针管理同一地址                           | pass         |
| 禁止在析构函数中抛异步任务                                      |     pass     |
| 禁止js对象在非js线程(例如在IPC线程)创建、使用或销毁             |   pass       |
| 禁止在对外接口中未经判空直接使用外部传入的指针                    |   pass       |
| 禁止接口返回局部变量引用                                        |    pass      |
| 禁止在信号函数中加锁                                            |     pass     |
| 禁止在关键流程(SA启动、应用启动等主流程)执行耗时的操作           |      pass    |
| 禁止将同一个cpp编译在不同的so中                                 |      pass    |

**安全编码自检:**
| 自检项                                                          | 自检结果 |
| -------------------------------------------------------------- | -------- |
| 裸指针避免通过隐式转换构造为sptr                                 |     pass     |
| json对象在取值之前必须先判断类型,避免类型不匹配                   |       pass   |
| 序列化时必须对传入的数组大小进行校验,避免出现超大数组              |    pass      |
| 避免使用未明确位宽的整型,选择使用int8_t、uint8_t等类型            |    pass      |
| 外部传入的路径要做规范化校验,对路径中的.、..、../等特殊字符严格校验 |     pass     |
| 指针变量、表示资源描述符的变量、bool变量必须赋初值                  |      pass    |
| readParcelable获取的对象使用前需要判空                            |    pass      |
| 分配和释放内存的函数需要成对出现                                   |    pass      |
| 申请内存后异常退出前需要及时进行内存释放                            |    pass      |
| 内存申请前必须对内存大小进行合法性校验                              |     pass     |
| 内存分配后必须判断是否成功                                         |     pass     |
| 禁止使用realloc、alloca函数                                       |   pass       |
| 禁止打印文件路径、口令等敏感信息,如有需要,使用private修饰          |     pass     |
| 禁止打印内存地址                                                  |    pass      |
| 整数之间运算时必须严格检查,确保不会出现溢出、反转、除0               |   pass       |
| 禁止对有符号整数进行位操作符运算                                    |      pass    |
| 禁止对指针进行逻辑或位运算                                         |    pass      |
| 循环次数如果收外部数据控制,需要检验其合法性                         |       pass   |
| 禁止使用内存操作类危险函数,需要使用安全函数                         |    pass      |
| 谨慎使用不可重入函数                                               |       pass   |
| 必须检查安全函数的返回值,并进行正确处理                             |    pass      |
| 禁止仅通过TokenType类型判断绕过权限校验                             |    pass      |

**TDD Result**:

**XTS Result**:

### 是否已执行L0用例
- [x] 已验证
- [ ] 不涉及。如不涉及,请写明理由


See merge request: openharmony/ability_ability_runtime!19393
This commit is contained in:
openharmony_ci
2026-06-02 10:12:40 +08:00
5 changed files with 565 additions and 33 deletions
+1 -1
View File
@@ -2363,7 +2363,7 @@ void MainThread::PreloadModule(const BundleInfo &bundleInfo, const AppLaunchData
TAG_LOGI(AAFwkTag::APPKIT, "preload module %{public}s", preloadModuleInfo->moduleName.c_str());
auto callback = []() {};
bool isAsyncCallback = false;
application_->AddAbilityStage(*preloadModuleInfo, callback, isAsyncCallback);
application_->AddAbilityStage(*preloadModuleInfo, callback, isAsyncCallback, preloadAbilityName);
if (isAsyncCallback) {
return;
}
@@ -470,6 +470,80 @@ void OHOSApplication::PreloadHybridModule(const HapModuleInfo &hapModuleInfo) co
runtime_->PreloadModule(hapModuleInfo.moduleName, hapModuleInfo.hapPath, isEsmode, useCommonTrunk);
}
void OHOSApplication::SetLaunchElementForStage(
const std::shared_ptr<AbilityRuntime::AbilityStageContext> &stageContext,
const std::shared_ptr<AppExecFwk::HapModuleInfo> &moduleInfo,
const std::string &abilityName)
{
if (!stageContext || !moduleInfo) {
TAG_LOGE(AAFwkTag::APPKIT, "null stageContext or moduleInfo");
return;
}
AppExecFwk::ElementName elementName;
elementName.SetBundleName(moduleInfo->bundleName);
elementName.SetModuleName(moduleInfo->moduleName);
elementName.SetAbilityName(abilityName);
TAG_LOGD(AAFwkTag::APPKIT, "Set launchElement to stageContext: %{public}s/%{public}s",
elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
stageContext->SetLaunchElement(elementName);
}
std::shared_ptr<AbilityRuntime::AbilityStageContext> OHOSApplication::CreateAndInitStageContext(
const AppExecFwk::HapModuleInfo &hapModuleInfo)
{
auto stageContext = std::make_shared<AbilityRuntime::AbilityStageContext>();
stageContext->SetParentContext(abilityRuntimeContext_);
stageContext->InitHapModuleInfo(hapModuleInfo);
stageContext->SetConfiguration(GetConfiguration());
stageContext->SetProcessName(GetProcessName());
auto moduleInfo = stageContext->GetHapModuleInfo();
if (moduleInfo == nullptr) {
TAG_LOGE(AAFwkTag::APPKIT, "null moduleInfo");
return nullptr;
}
if (abilityRuntimeContext_->GetApplicationInfo() &&
abilityRuntimeContext_->GetApplicationInfo()->multiProjects) {
auto rm = stageContext->CreateModuleContext(hapModuleInfo.moduleName)->GetResourceManager();
stageContext->SetResourceManager(rm);
}
LoadDeduplicatedHarResource(stageContext);
return stageContext;
}
bool OHOSApplication::ExecuteAutoStartupTasks(std::shared_ptr<AbilityRuntime::AbilityStage> abilityStage,
const AppExecFwk::HapModuleInfo &hapModuleInfo,
const std::function<void()> &callback,
bool &isAsyncCallback,
const std::shared_ptr<AbilityRuntime::AbilityStageContext> &stageContext)
{
if (abilityStage == nullptr) {
TAG_LOGE(AAFwkTag::APPKIT, "null abilityStage");
return false;
}
auto firstCallback = CreateFirstStartupCallbackForHap(abilityStage, hapModuleInfo, callback);
if (firstCallback != nullptr) {
abilityStage->RunAutoStartupTask(firstCallback, nullptr, isAsyncCallback, stageContext, true);
if (isAsyncCallback) {
TAG_LOGI(AAFwkTag::APPKIT, "wait startup first");
return false;
}
}
TAG_LOGD(AAFwkTag::APPKIT, "no wait startup first");
abilityStage->LoadModule(hapModuleInfo);
auto secondCallback = CreateSecondStartupCallbackForHap(abilityStage, hapModuleInfo, callback);
if (firstCallback != nullptr) {
abilityStage->RunAutoStartupTask(secondCallback, nullptr, isAsyncCallback, stageContext, false);
if (isAsyncCallback) {
TAG_LOGI(AAFwkTag::APPKIT, "wait startup second");
return false;
}
}
return true;
}
std::shared_ptr<AbilityRuntime::Context> OHOSApplication::AddAbilityStage(
const std::shared_ptr<AbilityLocalRecord> &abilityRecord,
const std::function<void(const std::shared_ptr<AbilityRuntime::Context> &)> &callback, bool &isAsyncCallback)
@@ -805,7 +879,7 @@ void OHOSApplication::UpdateApplicationInfoInstalled(const AppExecFwk::Applicati
bool OHOSApplication::AddAbilityStage(
const AppExecFwk::HapModuleInfo &hapModuleInfo,
const std::function<void()> &callback, bool &isAsyncCallback)
const std::function<void()> &callback, bool &isAsyncCallback, const std::string &preloadAbilityName)
{
TAG_LOGD(AAFwkTag::APPKIT, "called");
if (abilityRuntimeContext_ == nullptr) {
@@ -823,48 +897,27 @@ bool OHOSApplication::AddAbilityStage(
return false;
}
auto stageContext = std::make_shared<AbilityRuntime::AbilityStageContext>();
stageContext->SetParentContext(abilityRuntimeContext_);
stageContext->InitHapModuleInfo(hapModuleInfo);
stageContext->SetConfiguration(GetConfiguration());
stageContext->SetProcessName(GetProcessName());
auto moduleInfo = stageContext->GetHapModuleInfo();
if (moduleInfo == nullptr) {
TAG_LOGE(AAFwkTag::APPKIT, "null moduleInfo");
auto stageContext = CreateAndInitStageContext(hapModuleInfo);
if (stageContext == nullptr) {
return false;
}
if (abilityRuntimeContext_->GetApplicationInfo() && abilityRuntimeContext_->GetApplicationInfo()->multiProjects) {
auto rm = stageContext->CreateModuleContext(hapModuleInfo.moduleName)->GetResourceManager();
stageContext->SetResourceManager(rm);
}
LoadDeduplicatedHarResource(stageContext);
auto moduleInfo = stageContext->GetHapModuleInfo();
auto &runtime = GetSpecifiedRuntime(moduleInfo->arkTSMode);
auto abilityStage = AbilityRuntime::AbilityStage::Create(runtime, *moduleInfo);
if (abilityStage == nullptr) {
TAG_LOGE(AAFwkTag::APPKIT, "null abilityStage");
return false;
}
std::string abilityName = preloadAbilityName.empty() ? moduleInfo->mainAbility : preloadAbilityName;
SetLaunchElementForStage(stageContext, moduleInfo, abilityName);
auto application = std::static_pointer_cast<OHOSApplication>(shared_from_this());
std::weak_ptr<OHOSApplication> weak = application;
abilityStage->Init(stageContext, weak);
auto firstCallback = CreateFirstStartupCallbackForHap(abilityStage, hapModuleInfo, callback);
if (firstCallback != nullptr) {
abilityStage->RunAutoStartupTask(firstCallback, nullptr, isAsyncCallback, stageContext, true);
if (isAsyncCallback) {
TAG_LOGI(AAFwkTag::APPKIT, "wait startup first");
return false;
}
}
TAG_LOGD(AAFwkTag::APPKIT, "no wait startup first");
abilityStage->LoadModule(hapModuleInfo);
auto secondCallback = CreateSecondStartupCallbackForHap(abilityStage, hapModuleInfo, callback);
if (firstCallback != nullptr) {
abilityStage->RunAutoStartupTask(secondCallback, nullptr, isAsyncCallback, stageContext, false);
if (isAsyncCallback) {
TAG_LOGI(AAFwkTag::APPKIT, "wait startup second");
return false;
}
if (!ExecuteAutoStartupTasks(abilityStage, hapModuleInfo, callback, isAsyncCallback, stageContext)) {
return false;
}
TAG_LOGD(AAFwkTag::APPKIT, "no wait startup second");
@@ -152,11 +152,13 @@ public:
* @brief add the ability stage when a hap first load
*
* @param hapModuleInfo
* @param preloadAbilityName The ability name for preload scenario
* @return Returns true on success, false on failure
*/
bool AddAbilityStage(
const AppExecFwk::HapModuleInfo &hapModuleInfo,
const std::function<void()> &callback, bool &isAsyncCallback);
const std::function<void()> &callback, bool &isAsyncCallback,
const std::string &preloadAbilityName = "");
/**
* @brief remove the ability stage when all of the abilities in the hap have been removed
@@ -286,6 +288,17 @@ private:
void PreloadHybridModule(const HapModuleInfo &hapModuleInfo) const;
void LoadDeduplicatedHarResource(
const std::shared_ptr<AbilityRuntime::AbilityStageContext> &stageContext);
void SetLaunchElementForStage(
const std::shared_ptr<AbilityRuntime::AbilityStageContext> &stageContext,
const std::shared_ptr<AppExecFwk::HapModuleInfo> &moduleInfo,
const std::string &abilityName);
std::shared_ptr<AbilityRuntime::AbilityStageContext> CreateAndInitStageContext(
const AppExecFwk::HapModuleInfo &hapModuleInfo);
bool ExecuteAutoStartupTasks(std::shared_ptr<AbilityRuntime::AbilityStage> abilityStage,
const AppExecFwk::HapModuleInfo &hapModuleInfo,
const std::function<void()> &callback,
bool &isAsyncCallback,
const std::shared_ptr<AbilityRuntime::AbilityStageContext> &stageContext);
const std::function<void()> CreateFirstStartupCallbackForRecord(
std::shared_ptr<AbilityRuntime::AbilityStage> abilityStage,
@@ -3059,5 +3059,119 @@ HWTEST_F(MainThreadTest, GetPluginNativeLibPath_0500, TestSize.Level1)
EXPECT_EQ(appLibPaths["pluginBundleName/validModule"][0],
"/data/storage/el1/bundle/+plugins/libs/arm");
}
/*
* Feature: MainThread
* Function: PreloadModule
* SubFunction: NA
* FunctionPoints: PreloadModule with preloadAbilityName
* EnvConditions: NA
* CaseDescription: Verify PreloadModule calls AddAbilityStage with preloadAbilityName
*/
HWTEST_F(MainThreadTest, PreloadModule_WithPreloadAbilityName_0100, TestSize.Level1)
{
TAG_LOGI(AAFwkTag::TEST, "%{public}s start.", __func__);
// Setup application
mainThread_->application_ = std::make_shared<OHOSApplication>();
mainThread_->application_->SetRuntime(std::make_unique<AbilityRuntime::MockRuntime>());
// Prepare BundleInfo
BundleInfo bundleInfo;
bundleInfo.name = "com.example.test";
bundleInfo.bundleName = "com.example.test";
// Prepare HapModuleInfo for preload
HapModuleInfo preloadModuleInfo;
preloadModuleInfo.bundleName = "com.example.test";
preloadModuleInfo.moduleName = "entry";
preloadModuleInfo.mainAbility = "MainAbility";
preloadModuleInfo.arkTSMode = AbilityRuntime::CODE_LANGUAGE_ARKTS_1_0;
bundleInfo.hapModuleInfos.emplace_back(preloadModuleInfo);
// Prepare AppLaunchData
AppLaunchData appLaunchData;
appLaunchData.SetPreloadModuleName("entry");
appLaunchData.SetPreloadAbilityName("PreloadTargetAbility");
// Call PreloadModule
mainThread_->PreloadModule(bundleInfo, appLaunchData, preloadModuleInfo,
mainThread_->application_->GetRuntime());
// Verify abilityStage was created with launchElement set
auto& abilityStages = mainThread_->application_->abilityStages_;
EXPECT_GT(abilityStages.size(), 0u);
auto it = abilityStages.find("entry");
if (it != abilityStages.end()) {
auto abilityStage = it->second;
auto stageContext = std::static_pointer_cast<AbilityRuntime::AbilityStageContext>(abilityStage->GetContext());
ASSERT_NE(stageContext, nullptr);
auto launchElement = stageContext->GetLaunchElement();
EXPECT_EQ(launchElement.GetAbilityName(), "PreloadTargetAbility");
EXPECT_EQ(launchElement.GetBundleName(), "com.example.test");
EXPECT_EQ(launchElement.GetModuleName(), "entry");
}
TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__);
}
/*
* Feature: MainThread
* Function: PreloadModule
* SubFunction: NA
* FunctionPoints: PreloadModule with empty preloadAbilityName
* EnvConditions: NA
* CaseDescription: Verify PreloadModule uses mainAbility when preloadAbilityName is empty
*/
HWTEST_F(MainThreadTest, PreloadModule_WithEmptyPreloadAbilityName_0200, TestSize.Level1)
{
TAG_LOGI(AAFwkTag::TEST, "%{public}s start.", __func__);
// Setup application
mainThread_->application_ = std::make_shared<OHOSApplication>();
mainThread_->application_->SetRuntime(std::make_unique<AbilityRuntime::MockRuntime>());
// Prepare BundleInfo
BundleInfo bundleInfo;
bundleInfo.name = "com.example.test";
bundleInfo.bundleName = "com.example.test";
// Prepare HapModuleInfo for preload
HapModuleInfo preloadModuleInfo;
preloadModuleInfo.bundleName = "com.example.test";
preloadModuleInfo.moduleName = "entry";
preloadModuleInfo.mainAbility = "MainAbility";
preloadModuleInfo.arkTSMode = AbilityRuntime::CODE_LANGUAGE_ARKTS_1_0;
bundleInfo.hapModuleInfos.emplace_back(preloadModuleInfo);
// Prepare AppLaunchData with empty preloadAbilityName
AppLaunchData appLaunchData;
appLaunchData.SetPreloadModuleName("entry");
appLaunchData.SetPreloadAbilityName(""); // Empty - should use mainAbility
// Call PreloadModule
mainThread_->PreloadModule(bundleInfo, appLaunchData, preloadModuleInfo,
mainThread_->application_->GetRuntime());
// Verify abilityStage was created with mainAbility as fallback
auto& abilityStages = mainThread_->application_->abilityStages_;
EXPECT_GT(abilityStages.size(), 0u);
auto it = abilityStages.find("entry");
if (it != abilityStages.end()) {
auto abilityStage = it->second;
auto stageContext = std::static_pointer_cast<AbilityRuntime::AbilityStageContext>(abilityStage->GetContext());
ASSERT_NE(stageContext, nullptr);
auto launchElement = stageContext->GetLaunchElement();
EXPECT_EQ(launchElement.GetAbilityName(), "MainAbility"); // Should use mainAbility
EXPECT_EQ(launchElement.GetBundleName(), "com.example.test");
EXPECT_EQ(launchElement.GetModuleName(), "entry");
}
TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__);
}
} // namespace AppExecFwk
} // namespace OHOS
@@ -2289,5 +2289,357 @@ HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_OnTerminate_0200, T
ohosApplication_->OnTerminate();
EXPECT_NE(ohosApplication_->abilityRuntimeContext_, nullptr);
}
/*
* @tc.number: AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0100
* @tc.name: SetLaunchElementForStage
* @tc.desc: Verify SetLaunchElementForStage with valid parameters
*/
HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0100, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0100 start.";
auto stageContext = std::make_shared<AbilityRuntime::AbilityStageContext>();
ASSERT_NE(stageContext, nullptr);
auto moduleInfo = std::make_shared<AppExecFwk::HapModuleInfo>();
moduleInfo->bundleName = "com.example.test";
moduleInfo->moduleName = "entry";
moduleInfo->mainAbility = "MainAbility";
std::string abilityName = "MainAbility";
ohosApplication_->SetLaunchElementForStage(stageContext, moduleInfo, abilityName);
auto launchElement = stageContext->GetLaunchElement();
EXPECT_EQ(launchElement.GetBundleName(), "com.example.test");
EXPECT_EQ(launchElement.GetModuleName(), "entry");
EXPECT_EQ(launchElement.GetAbilityName(), "MainAbility");
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0100 end.";
}
/*
* @tc.number: AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0200
* @tc.name: SetLaunchElementForStage
* @tc.desc: Verify SetLaunchElementForStage with null stageContext
*/
HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0200, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0200 start.";
std::shared_ptr<AbilityRuntime::AbilityStageContext> stageContext = nullptr;
auto moduleInfo = std::make_shared<AppExecFwk::HapModuleInfo>();
moduleInfo->bundleName = "com.example.test";
moduleInfo->moduleName = "entry";
std::string abilityName = "MainAbility";
ohosApplication_->SetLaunchElementForStage(stageContext, moduleInfo, abilityName);
EXPECT_TRUE(true);
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0200 end.";
}
/*
* @tc.number: AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0300
* @tc.name: SetLaunchElementForStage
* @tc.desc: Verify SetLaunchElementForStage with null moduleInfo
*/
HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0300, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0300 start.";
auto stageContext = std::make_shared<AbilityRuntime::AbilityStageContext>();
ASSERT_NE(stageContext, nullptr);
std::shared_ptr<AppExecFwk::HapModuleInfo> moduleInfo = nullptr;
std::string abilityName = "MainAbility";
ohosApplication_->SetLaunchElementForStage(stageContext, moduleInfo, abilityName);
EXPECT_TRUE(true);
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0300 end.";
}
/*
* @tc.number: AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0400
* @tc.name: SetLaunchElementForStage
* @tc.desc: Verify SetLaunchElementForStage with custom abilityName (preload scenario)
*/
HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0400, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0400 start.";
auto stageContext = std::make_shared<AbilityRuntime::AbilityStageContext>();
ASSERT_NE(stageContext, nullptr);
auto moduleInfo = std::make_shared<AppExecFwk::HapModuleInfo>();
moduleInfo->bundleName = "com.example.test";
moduleInfo->moduleName = "entry";
moduleInfo->mainAbility = "MainAbility";
std::string abilityName = "PreloadAbility";
ohosApplication_->SetLaunchElementForStage(stageContext, moduleInfo, abilityName);
auto launchElement = stageContext->GetLaunchElement();
EXPECT_EQ(launchElement.GetBundleName(), "com.example.test");
EXPECT_EQ(launchElement.GetModuleName(), "entry");
EXPECT_EQ(launchElement.GetAbilityName(), "PreloadAbility");
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_SetLaunchElementForStage_0400 end.";
}
/*
* @tc.number: AppExecFwk_OHOSApplicationTest_CreateAndInitStageContext_0100
* @tc.name: CreateAndInitStageContext
* @tc.desc: Verify CreateAndInitStageContext success
*/
HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_CreateAndInitStageContext_0100, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CreateAndInitStageContext_0100 start.";
// Setup application context
ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
ohosApplication_->configuration_ = std::make_shared<AppExecFwk::Configuration>();
AppExecFwk::HapModuleInfo hapModuleInfo;
hapModuleInfo.bundleName = "com.example.test";
hapModuleInfo.moduleName = "entry";
hapModuleInfo.mainAbility = "MainAbility";
auto stageContext = ohosApplication_->CreateAndInitStageContext(hapModuleInfo);
ASSERT_NE(stageContext, nullptr);
auto moduleInfo = stageContext->GetHapModuleInfo();
ASSERT_NE(moduleInfo, nullptr);
EXPECT_EQ(moduleInfo->bundleName, "com.example.test");
EXPECT_EQ(moduleInfo->moduleName, "entry");
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CreateAndInitStageContext_0100 end.";
}
/*
* @tc.number: AppExecFwk_OHOSApplicationTest_CreateAndInitStageContext_0200
* @tc.name: CreateAndInitStageContext
* @tc.desc: Verify CreateAndInitStageContext with multiProjects scenario
*/
HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_CreateAndInitStageContext_0200, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CreateAndInitStageContext_0200 start.";
// Setup application context with multiProjects
auto applicationContext = std::make_shared<AbilityRuntime::ApplicationContext>();
auto appInfo = std::make_shared<AppExecFwk::ApplicationInfo>();
appInfo->multiProjects = true;
applicationContext->SetApplicationInfo(appInfo);
ohosApplication_->abilityRuntimeContext_ = applicationContext;
ohosApplication_->configuration_ = std::make_shared<AppExecFwk::Configuration>();
AppExecFwk::HapModuleInfo hapModuleInfo;
hapModuleInfo.bundleName = "com.example.test";
hapModuleInfo.moduleName = "entry";
auto stageContext = ohosApplication_->CreateAndInitStageContext(hapModuleInfo);
ASSERT_NE(stageContext, nullptr);
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_CreateAndInitStageContext_0200 end.";
}
/*
* @tc.number: AppExecFwk_OHOSApplicationTest_ExecuteAutoStartupTasks_0100
* @tc.name: ExecuteAutoStartupTasks
* @tc.desc: Verify ExecuteAutoStartupTasks with null abilityStage
*/
HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_ExecuteAutoStartupTasks_0100, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_ExecuteAutoStartupTasks_0100 start.";
std::shared_ptr<AbilityRuntime::AbilityStage> abilityStage = nullptr;
AppExecFwk::HapModuleInfo hapModuleInfo;
auto callback = []() {};
bool isAsyncCallback = false;
auto stageContext = std::make_shared<AbilityRuntime::AbilityStageContext>();
auto result = ohosApplication_->ExecuteAutoStartupTasks(
abilityStage, hapModuleInfo, callback, isAsyncCallback, stageContext);
EXPECT_FALSE(result);
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_ExecuteAutoStartupTasks_0100 end.";
}
/*
* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_WithPreloadAbilityName_0100
* @tc.name: AddAbilityStage with preloadAbilityName
* @tc.desc: Verify AddAbilityStage with non-empty preloadAbilityName (preload scenario)
*/
HWTEST_F(OHOSApplicationTest,
AppExecFwk_OHOSApplicationTest_AddAbilityStage_WithPreloadAbilityName_0100, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_WithPreloadAbilityName_0100 start.";
ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
ohosApplication_->configuration_ = std::make_shared<AppExecFwk::Configuration>();
AppExecFwk::HapModuleInfo hapModuleInfo;
hapModuleInfo.bundleName = "com.example.test";
hapModuleInfo.moduleName = "entry";
hapModuleInfo.mainAbility = "MainAbility";
hapModuleInfo.arkTSMode = AbilityRuntime::CODE_LANGUAGE_ARKTS_1_0;
auto callback = []() {};
bool isAsyncCallback = false;
std::string preloadAbilityName = "PreloadAbility";
auto result = ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback, preloadAbilityName);
EXPECT_TRUE(result);
EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
auto abilityStage = ohosApplication_->abilityStages_["entry"];
ASSERT_NE(abilityStage, nullptr);
auto stageContext = std::static_pointer_cast<AbilityRuntime::AbilityStageContext>(abilityStage->GetContext());
ASSERT_NE(stageContext, nullptr);
auto launchElement = stageContext->GetLaunchElement();
EXPECT_EQ(launchElement.GetAbilityName(), "PreloadAbility");
EXPECT_EQ(launchElement.GetBundleName(), "com.example.test");
EXPECT_EQ(launchElement.GetModuleName(), "entry");
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_WithPreloadAbilityName_0100 end.";
}
/*
* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_WithPreloadAbilityName_0200
* @tc.name: AddAbilityStage with empty preloadAbilityName
* @tc.desc: Verify AddAbilityStage with empty preloadAbilityName (fallback to mainAbility)
*/
HWTEST_F(OHOSApplicationTest,
AppExecFwk_OHOSApplicationTest_AddAbilityStage_WithPreloadAbilityName_0200, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_WithPreloadAbilityName_0200 start.";
ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
ohosApplication_->configuration_ = std::make_shared<AppExecFwk::Configuration>();
AppExecFwk::HapModuleInfo hapModuleInfo;
hapModuleInfo.bundleName = "com.example.test";
hapModuleInfo.moduleName = "feature";
hapModuleInfo.mainAbility = "FeatureAbility";
hapModuleInfo.arkTSMode = AbilityRuntime::CODE_LANGUAGE_ARKTS_1_0;
auto callback = []() {};
bool isAsyncCallback = false;
std::string preloadAbilityName = "";
auto result = ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback, preloadAbilityName);
EXPECT_TRUE(result);
EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
auto abilityStage = ohosApplication_->abilityStages_["feature"];
ASSERT_NE(abilityStage, nullptr);
auto stageContext = std::static_pointer_cast<AbilityRuntime::AbilityStageContext>(abilityStage->GetContext());
ASSERT_NE(stageContext, nullptr);
auto launchElement = stageContext->GetLaunchElement();
EXPECT_EQ(launchElement.GetAbilityName(), "FeatureAbility");
EXPECT_EQ(launchElement.GetBundleName(), "com.example.test");
EXPECT_EQ(launchElement.GetModuleName(), "feature");
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_WithPreloadAbilityName_0200 end.";
}
/*
* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_WithPreloadAbilityName_0300
* @tc.name: AddAbilityStage without preloadAbilityName
* @tc.desc: Verify AddAbilityStage backward compatibility (default parameter)
*/
HWTEST_F(OHOSApplicationTest,
AppExecFwk_OHOSApplicationTest_AddAbilityStage_WithPreloadAbilityName_0300, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_WithPreloadAbilityName_0300 start.";
ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
ohosApplication_->configuration_ = std::make_shared<AppExecFwk::Configuration>();
AppExecFwk::HapModuleInfo hapModuleInfo;
hapModuleInfo.bundleName = "com.example.test";
hapModuleInfo.moduleName = "service";
hapModuleInfo.mainAbility = "ServiceAbility";
hapModuleInfo.arkTSMode = AbilityRuntime::CODE_LANGUAGE_ARKTS_1_0;
auto callback = []() {};
bool isAsyncCallback = false;
auto result = ohosApplication_->AddAbilityStage(hapModuleInfo, callback, isAsyncCallback);
EXPECT_TRUE(result);
EXPECT_FALSE(ohosApplication_->abilityStages_.empty());
auto abilityStage = ohosApplication_->abilityStages_["service"];
ASSERT_NE(abilityStage, nullptr);
auto stageContext = std::static_pointer_cast<AbilityRuntime::AbilityStageContext>(abilityStage->GetContext());
ASSERT_NE(stageContext, nullptr);
auto launchElement = stageContext->GetLaunchElement();
EXPECT_EQ(launchElement.GetAbilityName(), "ServiceAbility");
EXPECT_EQ(launchElement.GetBundleName(), "com.example.test");
EXPECT_EQ(launchElement.GetModuleName(), "service");
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_WithPreloadAbilityName_0300 end.";
}
/*
* @tc.number: AppExecFwk_OHOSApplicationTest_AddAbilityStage_PreloadScenario_0100
* @tc.name: AddAbilityStage preload scenario integration test
* @tc.desc: Verify complete preload scenario with launchElement
*/
HWTEST_F(OHOSApplicationTest, AppExecFwk_OHOSApplicationTest_AddAbilityStage_PreloadScenario_0100, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_PreloadScenario_0100 start.";
ohosApplication_->abilityRuntimeContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
ohosApplication_->runtime_ = std::make_unique<AbilityRuntime::MockRuntime>();
ohosApplication_->configuration_ = std::make_shared<AppExecFwk::Configuration>();
AppExecFwk::HapModuleInfo preloadModuleInfo;
preloadModuleInfo.bundleName = "com.example.preload";
preloadModuleInfo.moduleName = "preload_entry";
preloadModuleInfo.mainAbility = "EntryAbility";
preloadModuleInfo.arkTSMode = AbilityRuntime::CODE_LANGUAGE_ARKTS_1_0;
std::string preloadAbilityName = "TargetPreloadAbility";
auto callback = []() {};
bool isAsyncCallback = false;
auto result = ohosApplication_->AddAbilityStage(
preloadModuleInfo, callback, isAsyncCallback, preloadAbilityName);
EXPECT_TRUE(result);
EXPECT_EQ(ohosApplication_->abilityStages_.size(), 1u);
auto abilityStage = ohosApplication_->abilityStages_["preload_entry"];
ASSERT_NE(abilityStage, nullptr);
auto stageContext = std::static_pointer_cast<AbilityRuntime::AbilityStageContext>(abilityStage->GetContext());
ASSERT_NE(stageContext, nullptr);
auto launchElement = stageContext->GetLaunchElement();
EXPECT_EQ(launchElement.GetBundleName(), "com.example.preload");
EXPECT_EQ(launchElement.GetModuleName(), "preload_entry");
EXPECT_EQ(launchElement.GetAbilityName(), "TargetPreloadAbility");
GTEST_LOG_(INFO) << "AppExecFwk_OHOSApplicationTest_AddAbilityStage_PreloadScenario_0100 end.";
}
} // namespace AppExecFwk
} // namespace OHOS