From 26279bb941eda5bc503ef7d40b2be9dd7d335d59 Mon Sep 17 00:00:00 2001 From: zhangzezhong Date: Fri, 13 Jun 2025 12:05:55 +0800 Subject: [PATCH] add AbilityManagerService unittest cases for ability_runtime Signed-off-by: zhangzezhong --- .../BUILD.gn | 2 +- ...bility_manager_service_fourteenth_test.cpp | 633 +++++++++++++- .../mock/include/mock_my_status.h | 2 + .../mock/src/mock_ability_connect_manager.cpp | 780 ++++++++++++++++++ 4 files changed, 1413 insertions(+), 4 deletions(-) create mode 100644 test/unittest/ability_manager_service_thirteenth_test/mock/src/mock_ability_connect_manager.cpp diff --git a/test/unittest/ability_manager_service_fourteenth_test/BUILD.gn b/test/unittest/ability_manager_service_fourteenth_test/BUILD.gn index 0136f17dc5f..ab184c53caf 100644 --- a/test/unittest/ability_manager_service_fourteenth_test/BUILD.gn +++ b/test/unittest/ability_manager_service_fourteenth_test/BUILD.gn @@ -75,7 +75,6 @@ ohos_unittest("ability_manager_service_fourteenth_test") { "${ability_runtime_services_path}/abilitymgr/src/ability_background_connection.cpp", "${ability_runtime_services_path}/abilitymgr/src/ability_bundle_event_callback.cpp", "${ability_runtime_services_path}/abilitymgr/src/ability_cache_manager.cpp", - "${ability_runtime_services_path}/abilitymgr/src/ability_connect_manager.cpp", "${ability_runtime_services_path}/abilitymgr/src/ability_debug_deal.cpp", "${ability_runtime_services_path}/abilitymgr/src/ability_event_handler.cpp", "${ability_runtime_services_path}/abilitymgr/src/ability_first_frame_state_observer_manager.cpp", @@ -216,6 +215,7 @@ ohos_unittest("ability_manager_service_fourteenth_test") { "${ability_runtime_test_path}/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_client.cpp", "ability_manager_service_fourteenth_test.cpp", "../ability_manager_service_thirteenth_test/mock/src/mock_ability_record.cpp", + "../ability_manager_service_thirteenth_test/mock/src/mock_ability_connect_manager.cpp", "../ability_manager_service_thirteenth_test/mock/src/mock_accesstoken_kit.cpp", "../ability_manager_service_thirteenth_test/mock/src/mock_app_utils.cpp", "../ability_manager_service_thirteenth_test/mock/src/mock_data_ability_manager.cpp", diff --git a/test/unittest/ability_manager_service_fourteenth_test/ability_manager_service_fourteenth_test.cpp b/test/unittest/ability_manager_service_fourteenth_test/ability_manager_service_fourteenth_test.cpp index beb08742e15..790e525d64b 100644 --- a/test/unittest/ability_manager_service_fourteenth_test/ability_manager_service_fourteenth_test.cpp +++ b/test/unittest/ability_manager_service_fourteenth_test/ability_manager_service_fourteenth_test.cpp @@ -25,7 +25,6 @@ using namespace testing::ext; using namespace OHOS::AppExecFwk; using OHOS::AppExecFwk::AbilityType; using OHOS::AppExecFwk::ExtensionAbilityType; - namespace OHOS { namespace AAFwk { class AbilityManagerServiceFourteenthTest : public testing::Test { @@ -36,6 +35,7 @@ public: void TearDown(); std::shared_ptr MockAbilityRecord(AbilityType); sptr MockToken(AbilityType); + sptr MockSessionInfo(int32_t persistentId); }; void AbilityManagerServiceFourteenthTest::SetUpTestCase() {} @@ -64,6 +64,17 @@ sptr AbilityManagerServiceFourteenthTest::MockToken(AbilityType abilityTy return abilityRecord->GetToken(); } +sptr AbilityManagerServiceFourteenthTest::MockSessionInfo(int32_t persistentId) +{ + sptr sessionInfo = new (std::nothrow) SessionInfo(); + if (!sessionInfo) { + TAG_LOGE(AAFwkTag::TEST, "sessionInfo is nullptr"); + return nullptr; + } + sessionInfo->persistentId = persistentId; + return sessionInfo; +} + /* * Feature: AbilityManagerService * Name: NotifyDebugAssertResult_001 @@ -560,7 +571,7 @@ HWTEST_F(AbilityManagerServiceFourteenthTest, GetTopAbility_001, TestSize.Level1 MyStatus::GetInstance().permPermission_ = 0; auto abilityMs_ = std::make_shared(); EXPECT_NE(abilityMs_, nullptr); - sptr token = nullptr; // MockToken(AbilityType::PAGE); + sptr token = nullptr; int retCode = abilityMs_->GetTopAbility(token); EXPECT_EQ(retCode, CHECK_PERMISSION_FAILED); MyStatus::GetInstance().perJudgeCallerIsAllowedToUseSystemAPI_ = true; @@ -581,7 +592,7 @@ HWTEST_F(AbilityManagerServiceFourteenthTest, GetTopAbility_002, TestSize.Level1 MyStatus::GetInstance().sbjIsSceneBoardEnabled_ = true; auto abilityMs_ = std::make_shared(); EXPECT_NE(abilityMs_, nullptr); - sptr token = nullptr; // MockToken(AbilityType::PAGE); + sptr token = nullptr; int retCode = abilityMs_->GetTopAbility(token); EXPECT_EQ(retCode, ERR_INVALID_VALUE); MyStatus::GetInstance().perJudgeCallerIsAllowedToUseSystemAPI_ = true; @@ -609,5 +620,621 @@ HWTEST_F(AbilityManagerServiceFourteenthTest, GetTopAbility_003, TestSize.Level1 MyStatus::GetInstance().perJudgeCallerIsAllowedToUseSystemAPI_ = true; TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest GetTopAbility_003 end"); } + +/* + * Feature: AbilityManagerService + * Name: TerminateAbilityWithFlag_001 + * Function: TerminateAbilityWithFlag + * SubFunction: NA + * FunctionPoints: AbilityManagerService TerminateAbilityWithFlag + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, TerminateAbilityWithFlag_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateAbilityWithFlag_001 start"); + MyStatus::GetInstance().smhVerificationAllToken_ = false; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + + int retCode = abilityMs_->TerminateAbilityWithFlag(nullptr, 0, nullptr, true); + EXPECT_EQ(retCode, ERR_INVALID_VALUE); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateAbilityWithFlag_001 end"); +} + +/* + * Feature: AbilityManagerService + * Name: TerminateAbilityWithFlag_002 + * Function: TerminateAbilityWithFlag + * SubFunction: NA + * FunctionPoints: AbilityManagerService TerminateAbilityWithFlag + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, TerminateAbilityWithFlag_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateAbilityWithFlag_002 start"); + MyStatus::GetInstance().smhVerificationAllToken_ = true; + MyStatus::GetInstance().arGetAbilityRecord_ = nullptr; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + auto mockSubManagersHelper = std::make_shared(nullptr, nullptr); + EXPECT_NE(mockSubManagersHelper, nullptr); + abilityMs_->subManagersHelper_ = mockSubManagersHelper; + int retCode = abilityMs_->TerminateAbilityWithFlag(nullptr, 0, nullptr, true); + EXPECT_EQ(retCode, ERR_INVALID_VALUE); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateAbilityWithFlag_002 end"); +} + +/* + * Feature: AbilityManagerService + * Name: TerminateAbilityWithFlag_003 + * Function: TerminateAbilityWithFlag + * SubFunction: NA + * FunctionPoints: AbilityManagerService TerminateAbilityWithFlag + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, TerminateAbilityWithFlag_003, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateAbilityWithFlag_003 start"); + MyStatus::GetInstance().smhVerificationAllToken_ = true; + MyStatus::GetInstance().arGetAbilityRecord_ = MockAbilityRecord(AbilityType::SERVICE); + MyStatus::GetInstance().ipcGetCallingUid_ = 1; + MyStatus::GetInstance().arGetAbilityInfo_.bundleName = AbilityConfig::SYSTEM_UI_BUNDLE_NAME; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + auto mockSubManagersHelper = std::make_shared(nullptr, nullptr); + EXPECT_NE(mockSubManagersHelper, nullptr); + abilityMs_->subManagersHelper_ = mockSubManagersHelper; + int retCode = abilityMs_->TerminateAbilityWithFlag(nullptr, 0, nullptr, true); + EXPECT_EQ(retCode, ERR_INVALID_VALUE); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateAbilityWithFlag_003 end"); +} + +/* + * Feature: AbilityManagerService + * Name: TerminateAbilityWithFlag_004 + * Function: TerminateAbilityWithFlag + * SubFunction: NA + * FunctionPoints: AbilityManagerService TerminateAbilityWithFlag + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, TerminateAbilityWithFlag_004, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateAbilityWithFlag_004 start"); + MyStatus::GetInstance().smhVerificationAllToken_ = true; + MyStatus::GetInstance().arGetAbilityRecord_ = MockAbilityRecord(AbilityType::SERVICE); + MyStatus::GetInstance().ipcGetCallingUid_ = 1; + MyStatus::GetInstance().arGetAbilityInfo_.bundleName = AbilityConfig::SYSTEM_UI_NAVIGATION_BAR; + MyStatus::GetInstance().arGetAbilityInfo_.type = AbilityType::SERVICE; + MyStatus::GetInstance().smhGetConnectManagerByToken_ = false; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + auto mockSubManagersHelper = std::make_shared(nullptr, nullptr); + EXPECT_NE(mockSubManagersHelper, nullptr); + abilityMs_->subManagersHelper_ = mockSubManagersHelper; + int retCode = abilityMs_->TerminateAbilityWithFlag(nullptr, 0, nullptr, true); + EXPECT_EQ(retCode, ERR_INVALID_VALUE); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateAbilityWithFlag_004 end"); +} + +/* + * Feature: AbilityManagerService + * Name: TerminateAbilityWithFlag_005 + * Function: TerminateAbilityWithFlag + * SubFunction: NA + * FunctionPoints: AbilityManagerService TerminateAbilityWithFlag + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, TerminateAbilityWithFlag_005, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateAbilityWithFlag_005 start"); + MyStatus::GetInstance().smhVerificationAllToken_ = true; + MyStatus::GetInstance().arGetAbilityRecord_ = MockAbilityRecord(AbilityType::SERVICE); + MyStatus::GetInstance().ipcGetCallingUid_ = 1; + MyStatus::GetInstance().arGetAbilityInfo_.bundleName = AbilityConfig::SYSTEM_UI_NAVIGATION_BAR; + MyStatus::GetInstance().arGetAbilityInfo_.type = AbilityType::SERVICE; + MyStatus::GetInstance().smhGetConnectManagerByToken_ = true; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + + auto mockSubManagersHelper = std::make_shared(nullptr, nullptr); + EXPECT_NE(mockSubManagersHelper, nullptr); + auto mockCurrentConnectManager = std::make_shared(0); + EXPECT_NE(mockCurrentConnectManager, nullptr); + mockCurrentConnectManager->sceneBoardTokenId_ = 0; + abilityMs_->subManagersHelper_ = mockSubManagersHelper; + abilityMs_->subManagersHelper_->currentConnectManager_ = mockCurrentConnectManager; + + int retCode = abilityMs_->TerminateAbilityWithFlag(nullptr, 0, nullptr, true); + EXPECT_EQ(retCode, ERR_OK); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateAbilityWithFlag_005 end"); +} + +/* + * Feature: AbilityManagerService + * Name: TerminateAbilityWithFlag_006 + * Function: TerminateAbilityWithFlag + * SubFunction: NA + * FunctionPoints: AbilityManagerService TerminateAbilityWithFlag + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, TerminateAbilityWithFlag_006, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateAbilityWithFlag_006 start"); + MyStatus::GetInstance().smhVerificationAllToken_ = true; + MyStatus::GetInstance().arGetAbilityRecord_ = MockAbilityRecord(AbilityType::SERVICE); + MyStatus::GetInstance().ipcGetCallingUid_ = 1; + MyStatus::GetInstance().arGetAbilityInfo_.bundleName = AbilityConfig::SYSTEM_UI_NAVIGATION_BAR; + MyStatus::GetInstance().arGetAbilityInfo_.type = AbilityType::DATA; + MyStatus::GetInstance().smhGetConnectManagerByToken_ = false; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + auto mockSubManagersHelper = std::make_shared(nullptr, nullptr); + EXPECT_NE(mockSubManagersHelper, nullptr); + abilityMs_->subManagersHelper_ = mockSubManagersHelper; + int retCode = abilityMs_->TerminateAbilityWithFlag(nullptr, 0, nullptr, true); + EXPECT_EQ(retCode, ERR_WRONG_INTERFACE_CALL); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateAbilityWithFlag_006 end"); +} + +/* + * Feature: AbilityManagerService + * Name: GetConnectManagerAndUIExtensionBySessionInfo_001 + * Function: GetConnectManagerAndUIExtensionBySessionInfo + * SubFunction: NA + * FunctionPoints: AbilityManagerService GetConnectManagerAndUIExtensionBySessionInfo + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, GetConnectManagerAndUIExtensionBySessionInfo_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, + "AbilityManagerServiceFourteenthTest GetConnectManagerAndUIExtensionBySessionInfo_001 start"); + MyStatus::GetInstance().smhGetConnectManagerByToken_ = false; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + std::shared_ptr connectManager = nullptr; + std::shared_ptr targetAbility = nullptr; + abilityMs_->GetConnectManagerAndUIExtensionBySessionInfo(MockSessionInfo(0), connectManager, targetAbility, true); + EXPECT_EQ(connectManager, nullptr); + TAG_LOGI(AAFwkTag::TEST, + "AbilityManagerServiceFourteenthTest GetConnectManagerAndUIExtensionBySessionInfo_001 end"); +} + +/* + * Feature: AbilityManagerService + * Name: GetConnectManagerAndUIExtensionBySessionInfo_002 + * Function: GetConnectManagerAndUIExtensionBySessionInfo + * SubFunction: NA + * FunctionPoints: AbilityManagerService GetConnectManagerAndUIExtensionBySessionInfo + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, GetConnectManagerAndUIExtensionBySessionInfo_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, + "AbilityManagerServiceFourteenthTest GetConnectManagerAndUIExtensionBySessionInfo_002 start"); + MyStatus::GetInstance().smhGetConnectManagerByToken_ = true; + MyStatus::GetInstance().acmGetUIExtensionBySessionInfo_ = nullptr; + MyStatus::GetInstance().acmGetUIExtensionBySessionFromServiceMap_ = MockAbilityRecord(AbilityType::SERVICE); + + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + + auto mockSubManagersHelper = std::make_shared(nullptr, nullptr); + EXPECT_NE(mockSubManagersHelper, nullptr); + auto mockCurrentConnectManager = std::make_shared(0); + EXPECT_NE(mockCurrentConnectManager, nullptr); + mockCurrentConnectManager->sceneBoardTokenId_ = 0; + abilityMs_->subManagersHelper_ = mockSubManagersHelper; + abilityMs_->subManagersHelper_->currentConnectManager_ = mockCurrentConnectManager; + + std::shared_ptr connectManager = nullptr; + std::shared_ptr targetAbility = nullptr; + abilityMs_->GetConnectManagerAndUIExtensionBySessionInfo(MockSessionInfo(0), connectManager, targetAbility, true); + EXPECT_NE(connectManager, nullptr); + EXPECT_NE(targetAbility, nullptr); + TAG_LOGI(AAFwkTag::TEST, + "AbilityManagerServiceFourteenthTest GetConnectManagerAndUIExtensionBySessionInfo_002 end"); +} + +/* + * Feature: AbilityManagerService + * Name: GetConnectManagerAndUIExtensionBySessionInfo_003 + * Function: GetConnectManagerAndUIExtensionBySessionInfo + * SubFunction: NA + * FunctionPoints: AbilityManagerService GetConnectManagerAndUIExtensionBySessionInfo + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, GetConnectManagerAndUIExtensionBySessionInfo_003, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, + "AbilityManagerServiceFourteenthTest GetConnectManagerAndUIExtensionBySessionInfo_003 start"); + MyStatus::GetInstance().smhGetConnectManagerByToken_ = true; + MyStatus::GetInstance().acmGetUIExtensionBySessionInfo_ = nullptr; + MyStatus::GetInstance().ipcGetCallingUid_ = U0_USER_ID; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + + auto mockSubManagersHelper = std::make_shared(nullptr, nullptr); + EXPECT_NE(mockSubManagersHelper, nullptr); + auto mockCurrentConnectManager = std::make_shared(0); + EXPECT_NE(mockCurrentConnectManager, nullptr); + mockCurrentConnectManager->sceneBoardTokenId_ = 0; + abilityMs_->subManagersHelper_ = mockSubManagersHelper; + abilityMs_->subManagersHelper_->currentConnectManager_ = mockCurrentConnectManager; + + std::shared_ptr connectManager = nullptr; + std::shared_ptr targetAbility = nullptr; + abilityMs_->GetConnectManagerAndUIExtensionBySessionInfo( + MockSessionInfo(0), connectManager, targetAbility, false); + EXPECT_NE(connectManager, nullptr); + EXPECT_EQ(targetAbility, nullptr); + TAG_LOGI(AAFwkTag::TEST, + "AbilityManagerServiceFourteenthTest GetConnectManagerAndUIExtensionBySessionInfo_003 end"); +} + +/* + * Feature: AbilityManagerService + * Name: GetConnectManagerAndUIExtensionBySessionInfo_004 + * Function: GetConnectManagerAndUIExtensionBySessionInfo + * SubFunction: NA + * FunctionPoints: AbilityManagerService GetConnectManagerAndUIExtensionBySessionInfo + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, GetConnectManagerAndUIExtensionBySessionInfo_004, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, + "AbilityManagerServiceFourteenthTest GetConnectManagerAndUIExtensionBySessionInfo_004 start"); + MyStatus::GetInstance().smhGetConnectManagerByToken_ = true; + MyStatus::GetInstance().acmGetUIExtensionBySessionInfo_ = nullptr; + MyStatus::GetInstance().ipcGetCallingUid_ = -1; + MyStatus::GetInstance().acmGetUIExtensionBySessionFromServiceMap_ = nullptr; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + + auto mockSubManagersHelper = std::make_shared(nullptr, nullptr); + EXPECT_NE(mockSubManagersHelper, nullptr); + auto mockCurrentConnectManager = std::make_shared(0); + EXPECT_NE(mockCurrentConnectManager, nullptr); + mockCurrentConnectManager->sceneBoardTokenId_ = 0; + abilityMs_->subManagersHelper_ = mockSubManagersHelper; + abilityMs_->subManagersHelper_->currentConnectManager_ = mockCurrentConnectManager; + + std::shared_ptr connectManager = nullptr; + std::shared_ptr targetAbility = nullptr; + abilityMs_->GetConnectManagerAndUIExtensionBySessionInfo(MockSessionInfo(0), connectManager, targetAbility, true); + EXPECT_NE(connectManager, nullptr); + EXPECT_EQ(targetAbility, nullptr); + TAG_LOGI(AAFwkTag::TEST, + "AbilityManagerServiceFourteenthTest GetConnectManagerAndUIExtensionBySessionInfo_004 end"); +} + +/* + * Feature: AbilityManagerService + * Name: GetConnectManagerAndUIExtensionBySessionInfo_005 + * Function: GetConnectManagerAndUIExtensionBySessionInfo + * SubFunction: NA + * FunctionPoints: AbilityManagerService GetConnectManagerAndUIExtensionBySessionInfo + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, GetConnectManagerAndUIExtensionBySessionInfo_005, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, + "AbilityManagerServiceFourteenthTest GetConnectManagerAndUIExtensionBySessionInfo_005 start"); + MyStatus::GetInstance().smhGetConnectManagerByToken_ = true; + MyStatus::GetInstance().acmGetUIExtensionBySessionInfo_ = nullptr; + MyStatus::GetInstance().ipcGetCallingUid_ = -1; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + + auto mockSubManagersHelper = std::make_shared(nullptr, nullptr); + EXPECT_NE(mockSubManagersHelper, nullptr); + auto mockCurrentConnectManager = std::make_shared(0); + EXPECT_NE(mockCurrentConnectManager, nullptr); + mockCurrentConnectManager->sceneBoardTokenId_ = 0; + abilityMs_->subManagersHelper_ = mockSubManagersHelper; + abilityMs_->subManagersHelper_->currentConnectManager_ = mockCurrentConnectManager; + + std::shared_ptr connectManager = nullptr; + std::shared_ptr targetAbility = nullptr; + abilityMs_->GetConnectManagerAndUIExtensionBySessionInfo(MockSessionInfo(0), connectManager, targetAbility, false); + EXPECT_NE(connectManager, nullptr); + EXPECT_EQ(targetAbility, nullptr); + TAG_LOGI(AAFwkTag::TEST, + "AbilityManagerServiceFourteenthTest GetConnectManagerAndUIExtensionBySessionInfo_005 end"); +} + +/* + * Feature: AbilityManagerService + * Name: GetConnectManagerAndUIExtensionBySessionInfo_006 + * Function: GetConnectManagerAndUIExtensionBySessionInfo + * SubFunction: NA + * FunctionPoints: AbilityManagerService GetConnectManagerAndUIExtensionBySessionInfo + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, GetConnectManagerAndUIExtensionBySessionInfo_006, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, + "AbilityManagerServiceFourteenthTest GetConnectManagerAndUIExtensionBySessionInfo_006 start"); + MyStatus::GetInstance().smhGetConnectManagerByToken_ = false; + MyStatus::GetInstance().acmGetUIExtensionBySessionInfo_ = nullptr; + MyStatus::GetInstance().ipcGetCallingUid_ = -1; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + std::shared_ptr connectManager = nullptr; + std::shared_ptr targetAbility = nullptr; + abilityMs_->GetConnectManagerAndUIExtensionBySessionInfo(MockSessionInfo(0), connectManager, targetAbility, false); + EXPECT_EQ(connectManager, nullptr); + EXPECT_EQ(targetAbility, nullptr); + TAG_LOGI(AAFwkTag::TEST, + "AbilityManagerServiceFourteenthTest GetConnectManagerAndUIExtensionBySessionInfo_006 end"); +} + +/* + * Feature: AbilityManagerService + * Name: TerminateUIExtensionAbility_001 + * Function: TerminateUIExtensionAbility + * SubFunction: NA + * FunctionPoints: AbilityManagerService TerminateUIExtensionAbility + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, TerminateUIExtensionAbility_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateUIExtensionAbility_001 start"); + MyStatus::GetInstance().smhGetConnectManagerByToken_ = false; + MyStatus::GetInstance().acmGetUIExtensionBySessionInfo_ = nullptr; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + + int retCode = abilityMs_->TerminateUIExtensionAbility(MockSessionInfo(0), 0, nullptr); + EXPECT_EQ(retCode, ERR_INVALID_VALUE); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateUIExtensionAbility_001 end"); +} + +/* + * Feature: AbilityManagerService + * Name: TerminateUIExtensionAbility_002 + * Function: TerminateUIExtensionAbility + * SubFunction: NA + * FunctionPoints: AbilityManagerService TerminateUIExtensionAbility + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, TerminateUIExtensionAbility_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateUIExtensionAbility_002 start"); + MyStatus::GetInstance().smhGetConnectManagerByToken_ = true; + MyStatus::GetInstance().acmGetUIExtensionBySessionInfo_ = MockAbilityRecord(AbilityType::SERVICE); + MyStatus::GetInstance().ipcGetCallingTokenID_ = -1; + MyStatus::GetInstance().arGetAbilityInfo_.applicationInfo.accessTokenId = 1; + MyStatus::GetInstance().arGetAbilityRecord_ = nullptr; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + auto mockSubManagersHelper = std::make_shared(nullptr, nullptr); + EXPECT_NE(mockSubManagersHelper, nullptr); + auto mockCurrentConnectManager = std::make_shared(0); + EXPECT_NE(mockCurrentConnectManager, nullptr); + mockCurrentConnectManager->sceneBoardTokenId_ = 0; + abilityMs_->subManagersHelper_ = mockSubManagersHelper; + abilityMs_->subManagersHelper_->currentConnectManager_ = mockCurrentConnectManager; + + int retCode = abilityMs_->TerminateUIExtensionAbility(MockSessionInfo(0), 0, nullptr); + EXPECT_EQ(retCode, CHECK_PERMISSION_FAILED); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateUIExtensionAbility_002 end"); +} + +/* + * Feature: AbilityManagerService + * Name: TerminateUIExtensionAbility_003 + * Function: TerminateUIExtensionAbility + * SubFunction: NA + * FunctionPoints: AbilityManagerService TerminateUIExtensionAbility + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, TerminateUIExtensionAbility_003, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateUIExtensionAbility_003 start"); + MyStatus::GetInstance().smhGetConnectManagerByToken_ = true; + MyStatus::GetInstance().acmGetUIExtensionBySessionInfo_ = MockAbilityRecord(AbilityType::SERVICE); + MyStatus::GetInstance().ipcGetCallingTokenID_ = 1; + MyStatus::GetInstance().arGetAbilityInfo_.applicationInfo.accessTokenId = 1; + MyStatus::GetInstance().arGetAbilityInfo_.visible = false; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + auto mockSubManagersHelper = std::make_shared(nullptr, nullptr); + EXPECT_NE(mockSubManagersHelper, nullptr); + auto mockCurrentConnectManager = std::make_shared(0); + EXPECT_NE(mockCurrentConnectManager, nullptr); + mockCurrentConnectManager->sceneBoardTokenId_ = 0; + abilityMs_->subManagersHelper_ = mockSubManagersHelper; + abilityMs_->subManagersHelper_->currentConnectManager_ = mockCurrentConnectManager; + + int retCode = abilityMs_->TerminateUIExtensionAbility(MockSessionInfo(0), 0, nullptr); + EXPECT_EQ(retCode, ERR_WRONG_INTERFACE_CALL); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest TerminateUIExtensionAbility_003 end"); +} + +/* + * Feature: AbilityManagerService + * Name: IsDelegatorCall_001 + * Function: IsDelegatorCall + * SubFunction: NA + * FunctionPoints: AbilityManagerService IsDelegatorCall + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, IsDelegatorCall_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest IsDelegatorCall_001 start"); + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + RunningProcessInfo processInfo; + processInfo.isTestProcess = false; + AbilityRequest abilityRequest; + bool retCode = abilityMs_->IsDelegatorCall(processInfo, abilityRequest); + EXPECT_FALSE(retCode); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest IsDelegatorCall_001 end"); +} + +/* + * Feature: AbilityManagerService + * Name: IsTargetPermission_001 + * Function: IsTargetPermission + * SubFunction: NA + * FunctionPoints: AbilityManagerService IsTargetPermission + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, IsTargetPermission_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest IsTargetPermission_001 start"); + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + Want want; + ElementName element("", "com.ix.hiAccount", "AccountTest"); + want.SetElement(element); + bool retCode = abilityMs_->IsTargetPermission(want); + EXPECT_FALSE(retCode); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest IsTargetPermission_001 end"); +} + +/* + * Feature: AbilityManagerService + * Name: CheckNewRuleSwitchState_001 + * Function: CheckNewRuleSwitchState + * SubFunction: NA + * FunctionPoints: AbilityManagerService CheckNewRuleSwitchState + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, CheckNewRuleSwitchState_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest CheckNewRuleSwitchState_001 start"); + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + bool retCode = abilityMs_->CheckNewRuleSwitchState("component.startup.newRules"); + EXPECT_TRUE(retCode); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest CheckNewRuleSwitchState_001 end"); +} + +/* + * Feature: AbilityManagerService + * Name: CheckNewRuleSwitchState_002 + * Function: CheckNewRuleSwitchState + * SubFunction: NA + * FunctionPoints: AbilityManagerService CheckNewRuleSwitchState + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, CheckNewRuleSwitchState_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest CheckNewRuleSwitchState_002 start"); + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + bool retCode = abilityMs_->CheckNewRuleSwitchState(""); + EXPECT_FALSE(retCode); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest CheckNewRuleSwitchState_002 end"); +} + +/* + * Feature: AbilityManagerService + * Name: CheckDlpForExtension_001 + * Function: CheckDlpForExtension + * SubFunction: NA + * FunctionPoints: AbilityManagerService CheckDlpForExtension + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, CheckDlpForExtension_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest CheckDlpForExtension_001 start"); + MyStatus::GetInstance().ipcGetCallingUid_ = AppExecFwk::Constants::FOUNDATION_UID; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + Want want; + want.SetBundle("com.ohos.formrenderservice"); + sptr token = nullptr; + EventInfo eventInfo; + EventName eventName = static_cast(-1); + int retCode = abilityMs_->CheckDlpForExtension(want, token, 0, eventInfo, eventName); + EXPECT_EQ(retCode, ERR_OK); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest CheckDlpForExtension_001 end"); +} + +/* + * Feature: AbilityManagerService + * Name: CheckDlpForExtension_002 + * Function: CheckDlpForExtension + * SubFunction: NA + * FunctionPoints: AbilityManagerService CheckDlpForExtension + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, CheckDlpForExtension_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest CheckDlpForExtension_002 start"); + MyStatus::GetInstance().ipcGetCallingUid_ = -1; + MyStatus::GetInstance().permPermission_ = false; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + Want want; + want.SetBundle("com.example.abilityManagerServiceTest"); + sptr token = nullptr; + EventInfo eventInfo; + EventName eventName = static_cast(-1); + int retCode = abilityMs_->CheckDlpForExtension(want, token, -1, eventInfo, eventName); + EXPECT_EQ(retCode, CHECK_PERMISSION_FAILED); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest CheckDlpForExtension_002 end"); +} + +/* + * Feature: AbilityManagerService + * Name: CheckDlpForExtension_003 + * Function: CheckDlpForExtension + * SubFunction: NA + * FunctionPoints: AbilityManagerService CheckDlpForExtension + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, CheckDlpForExtension_003, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest CheckDlpForExtension_003 start"); + MyStatus::GetInstance().ipcGetCallingUid_ = -1; + MyStatus::GetInstance().permPermission_ = true; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + Want want; + want.SetBundle("com.example.abilityManagerServiceTest"); + sptr token = nullptr; + EventInfo eventInfo; + EventName eventName = static_cast(-1); + int retCode = abilityMs_->CheckDlpForExtension(want, token, 0, eventInfo, eventName); + EXPECT_EQ(retCode, ERR_OK); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest CheckDlpForExtension_003 end"); +} + +/* + * Feature: AbilityManagerService + * Name: GetFocusAbility_001 + * Function: GetFocusAbility + * SubFunction: NA + * FunctionPoints: AbilityManagerService GetFocusAbility + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, GetFocusAbility_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest GetFocusAbility_001 start"); + MyStatus::GetInstance().ipcGetCallingUid_ = AppExecFwk::Constants::FOUNDATION_UID; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + abilityMs_->wmsHandler_ = nullptr; + EXPECT_EQ(abilityMs_->GetFocusAbility(), nullptr); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest GetFocusAbility_001 end"); +} + +/* + * Feature: AbilityManagerService + * Name: GetFocusAbility_002 + * Function: GetFocusAbility + * SubFunction: NA + * FunctionPoints: AbilityManagerService GetFocusAbility + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, GetFocusAbility_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest GetFocusAbility_002 start"); + MyStatus::GetInstance().ipcGetCallingUid_ = AppExecFwk::Constants::FOUNDATION_UID; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + abilityMs_->wmsHandler_ = nullptr; + EXPECT_EQ(abilityMs_->GetFocusAbility(), nullptr); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest GetFocusAbility_002 end"); +} + +/* + * Feature: AbilityManagerService + * Name: CheckUIExtensionIsFocused_001 + * Function: CheckUIExtensionIsFocused + * SubFunction: NA + * FunctionPoints: AbilityManagerService CheckUIExtensionIsFocused + */ +HWTEST_F(AbilityManagerServiceFourteenthTest, CheckUIExtensionIsFocused_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest CheckUIExtensionIsFocused_001 start"); + MyStatus::GetInstance().permPermission_ = 0; + auto abilityMs_ = std::make_shared(); + EXPECT_NE(abilityMs_, nullptr); + sptr token = nullptr; + bool isFocused = false; + int retCode = abilityMs_->CheckUIExtensionIsFocused(0, isFocused); + EXPECT_EQ(retCode, CHECK_PERMISSION_FAILED); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceFourteenthTest CheckUIExtensionIsFocused_001 end"); +} } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/ability_manager_service_thirteenth_test/mock/include/mock_my_status.h b/test/unittest/ability_manager_service_thirteenth_test/mock/include/mock_my_status.h index 55ffdc4189b..7d665628f56 100644 --- a/test/unittest/ability_manager_service_thirteenth_test/mock/include/mock_my_status.h +++ b/test/unittest/ability_manager_service_thirteenth_test/mock/include/mock_my_status.h @@ -50,6 +50,8 @@ public: int permPermission_ = 1; bool perJudgeCallerIsAllowedToUseSystemAPI_ = true; bool paramGetBoolParameter_ = true; + std::shared_ptr acmGetUIExtensionBySessionInfo_ = nullptr; + std::shared_ptr acmGetUIExtensionBySessionFromServiceMap_ = nullptr; }; } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/ability_manager_service_thirteenth_test/mock/src/mock_ability_connect_manager.cpp b/test/unittest/ability_manager_service_thirteenth_test/mock/src/mock_ability_connect_manager.cpp new file mode 100644 index 00000000000..c206a7fe0c0 --- /dev/null +++ b/test/unittest/ability_manager_service_thirteenth_test/mock/src/mock_ability_connect_manager.cpp @@ -0,0 +1,780 @@ +/* + * Copyright (c) 2021-2025 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 "ability_connect_manager.h" +#include "mock_my_status.h" + +namespace OHOS { +namespace AAFwk { +AbilityConnectManager::AbilityConnectManager(int userId) : userId_(userId) +{ + uiExtensionAbilityRecordMgr_ = std::make_unique(userId); +} + +AbilityConnectManager::~AbilityConnectManager() +{} + +int AbilityConnectManager::StartAbility(const AbilityRequest &abilityRequest) +{ + return 0; +} + +int AbilityConnectManager::TerminateAbility(const sptr &token) +{ + return 0; +} + +int AbilityConnectManager::TerminateAbilityInner(const sptr &token) +{ + return 0; +} + +int AbilityConnectManager::StopServiceAbility(const AbilityRequest &abilityRequest) +{ + return 0; +} + +int AbilityConnectManager::StartAbilityLocked(const AbilityRequest &abilityRequest) +{ + return ERR_OK; +} + +void AbilityConnectManager::SetLastExitReason( + const AbilityRequest &abilityRequest, std::shared_ptr &targetRecord) +{ +} + +void AbilityConnectManager::DoForegroundUIExtension(std::shared_ptr abilityRecord, + const AbilityRequest &abilityRequest) +{ +} + +void AbilityConnectManager::EnqueueStartServiceReq(const AbilityRequest &abilityRequest, const std::string &serviceUri) +{ +} + +int AbilityConnectManager::TerminateAbilityLocked(const sptr &token) +{ + return ERR_OK; +} + +int AbilityConnectManager::StopServiceAbilityLocked(const AbilityRequest &abilityRequest) +{ + return ERR_OK; +} + +int32_t AbilityConnectManager::GetOrCreateExtensionRecord(const AbilityRequest &abilityRequest, bool isCreatedByConnect, + const std::string &hostBundleName, std::shared_ptr &extensionRecord, bool &isLoaded) +{ + return ERR_OK; +} + +void AbilityConnectManager::GetOrCreateServiceRecord(const AbilityRequest &abilityRequest, + const bool isCreatedByConnect, std::shared_ptr &targetService, bool &isLoadedAbility) +{ +} + +void AbilityConnectManager::RemoveServiceFromMapSafe(const std::string &serviceKey) +{ +} + + +void AbilityConnectManager::GetConnectRecordListFromMap( + const sptr &connect, std::list> &connectRecordList) +{ +} + +int32_t AbilityConnectManager::GetOrCreateTargetServiceRecord( + const AbilityRequest &abilityRequest, const sptr &connectInfo, + std::shared_ptr &targetService, bool &isLoadedAbility) +{ + return ERR_OK; +} + +int AbilityConnectManager::PreloadUIExtensionAbilityLocked(const AbilityRequest &abilityRequest, + std::string &hostBundleName, int32_t hostPid) +{ + return ERR_OK; +} + +int AbilityConnectManager::PreloadUIExtensionAbilityInner(const AbilityRequest &abilityRequest, + std::string &hostBundleName, int32_t hostPid) +{ + return ERR_OK; +} + +int AbilityConnectManager::UnloadUIExtensionAbility(const std::shared_ptr &abilityRecord, + std::string &hostBundleName) +{ + return ERR_OK; +} + +void AbilityConnectManager::ReportEventToRSS(const AppExecFwk::AbilityInfo &abilityInfo, + const std::shared_ptr abilityRecord, sptr callerToken) +{ +} + +int AbilityConnectManager::ConnectAbilityLocked(const AbilityRequest &abilityRequest, + const sptr &connect, const sptr &callerToken, sptr sessionInfo, + sptr connectInfo) +{ + return ERR_OK; +} + +void AbilityConnectManager::HandleActiveAbility(std::shared_ptr &targetService, + std::shared_ptr &connectRecord) +{ +} + +std::shared_ptr AbilityConnectManager::GetAbilityConnectedRecordFromRecordList( + const std::shared_ptr &targetService, + std::list> &connectRecordList) +{ + return nullptr; +} + +int AbilityConnectManager::DisconnectAbilityLocked(const sptr &connect) +{ + return ERR_OK; +} + +int AbilityConnectManager::DisconnectAbilityLocked(const sptr &connect, bool callerDied) +{ + return ERR_OK; +} + +int32_t AbilityConnectManager::SuspendExtensionAbilityLocked(const sptr &connect) +{ + return ERR_OK; +} + +int32_t AbilityConnectManager::ResumeExtensionAbilityLocked(const sptr &connect) +{ + return ERR_OK; +} + +void AbilityConnectManager::TerminateRecord(std::shared_ptr abilityRecord) +{ +} + +int AbilityConnectManager::DisconnectRecordNormal(ConnectListType &list, + std::shared_ptr connectRecord, bool callerDied) const +{ + return ERR_OK; +} + +void AbilityConnectManager::DisconnectRecordForce(ConnectListType &list, + std::shared_ptr connectRecord) +{ +} + +int AbilityConnectManager::AttachAbilityThreadLocked( + const sptr &scheduler, const sptr &token) +{ + return ERR_OK; +} + +void AbilityConnectManager::OnAbilityRequestDone(const sptr &token, const int32_t state) +{ +} + +void AbilityConnectManager::OnAppStateChanged(const AppInfo &info) +{ +} + +int AbilityConnectManager::AbilityTransitionDone(const sptr &token, int state) +{ + return ERR_OK; +} + +int AbilityConnectManager::AbilityWindowConfigTransactionDone(const sptr &token, + const WindowConfig &windowConfig) +{ + return ERR_OK; +} + +void AbilityConnectManager::ProcessPreload(const std::shared_ptr &record) const +{ +} + +int AbilityConnectManager::ScheduleConnectAbilityDoneLocked( + const sptr &token, const sptr &remoteObject) +{ + return ERR_OK; +} + +void AbilityConnectManager::ProcessEliminateAbilityRecord(std::shared_ptr eliminateRecord) +{ +} + +void AbilityConnectManager::TerminateOrCacheAbility(std::shared_ptr abilityRecord) +{ +} + +int AbilityConnectManager::ScheduleDisconnectAbilityDoneLocked(const sptr &token) +{ + return ERR_OK; +} + +int AbilityConnectManager::ScheduleCommandAbilityDoneLocked(const sptr &token) +{ + return ERR_OK; +} + +int AbilityConnectManager::ScheduleCommandAbilityWindowDone( + const sptr &token, + const sptr &sessionInfo, + WindowCommand winCmd, + AbilityCommand abilityCmd) +{ + return ERR_OK; +} + +void AbilityConnectManager::HandleCommandDestroy(const sptr &sessionInfo) +{ +} + +void AbilityConnectManager::CompleteCommandAbility(std::shared_ptr abilityRecord) +{ +} + +void AbilityConnectManager::CompleteStartServiceReq(const std::string &serviceUri) +{ +} + +std::shared_ptr AbilityConnectManager::GetServiceRecordByAbilityRequest( + const AbilityRequest &abilityRequest) +{ + return nullptr; +} + +std::shared_ptr AbilityConnectManager::GetServiceRecordByElementName(const std::string &element) +{ + return nullptr; +} + +std::shared_ptr AbilityConnectManager::GetExtensionByTokenFromServiceMap( + const sptr &token) +{ + return nullptr; +} + +std::shared_ptr AbilityConnectManager::GetExtensionByIdFromServiceMap( + const int64_t &abilityRecordId) +{ + return nullptr; +} + +std::shared_ptr AbilityConnectManager::GetExtensionByIdFromTerminatingMap( + const int64_t &abilityRecordId) +{ + return nullptr; +} + +std::shared_ptr AbilityConnectManager::GetUIExtensionBySessionInfo( + const sptr &sessionInfo) +{ + return MyStatus::GetInstance().acmGetUIExtensionBySessionInfo_; +} + +std::shared_ptr AbilityConnectManager::GetExtensionByTokenFromTerminatingMap( + const sptr &token) +{ + return nullptr; +} + +std::list> AbilityConnectManager::GetConnectRecordListByCallback( + sptr callback) +{ + std::list> connectList; + return connectList; +} + +void AbilityConnectManager::LoadAbility(const std::shared_ptr &abilityRecord, + std::function&)> updateRecordCallback) +{ +} + +void AbilityConnectManager::SetExtensionLoadParam(AbilityRuntime::LoadParam &loadParam, + std::shared_ptr abilityRecord) +{ +} + +bool AbilityConnectManager::IsStrictMode(std::shared_ptr abilityRecord) +{ + return true; +} + +bool AbilityConnectManager::NeedExtensionControl(std::shared_ptr abilityRecord) +{ + return true; +} + +void AbilityConnectManager::PostRestartResidentTask(const AbilityRequest &abilityRequest) +{ +} + +void AbilityConnectManager::HandleRestartResidentTask(const AbilityRequest &abilityRequest) +{ +} + +void AbilityConnectManager::PostTimeOutTask(const std::shared_ptr &abilityRecord, uint32_t messageId) +{ +} + +void AbilityConnectManager::PostTimeOutTask(const std::shared_ptr &abilityRecord, + int connectRecordId, uint32_t messageId) +{ +} + +void AbilityConnectManager::HandleStartTimeoutTask(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::HandleCommandTimeoutTask(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::HandleConnectTimeoutTask(std::shared_ptr abilityRecord) +{ +} + +void AbilityConnectManager::HandleCommandWindowTimeoutTask(const std::shared_ptr &abilityRecord, + const sptr &sessionInfo, WindowCommand winCmd) +{ +} + +void AbilityConnectManager::HandleStopTimeoutTask(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::HandleTerminateDisconnectTask(const ConnectListType& connectlist) +{ +} + +int AbilityConnectManager::DispatchInactive(const std::shared_ptr &abilityRecord, int state) +{ + return ERR_OK; +} + +int AbilityConnectManager::DispatchForeground(const std::shared_ptr &abilityRecord) +{ + return ERR_OK; +} + +int AbilityConnectManager::DispatchBackground(const std::shared_ptr &abilityRecord) +{ + return ERR_OK; +} + +int AbilityConnectManager::DispatchTerminate(const std::shared_ptr &abilityRecord) +{ + return ERR_OK; +} + +void AbilityConnectManager::ConnectAbility(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::ConnectUIServiceExtAbility(const std::shared_ptr &abilityRecord, + int connectRecordId, const Want &want) +{ +} + +void AbilityConnectManager::ResumeConnectAbility(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::CommandAbility(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::CommandAbilityWindow(const std::shared_ptr &abilityRecord, + const sptr &sessionInfo, WindowCommand winCmd) +{ +} + +void AbilityConnectManager::BackgroundAbilityWindowLocked(const std::shared_ptr &abilityRecord, + const sptr &sessionInfo) +{ +} + +void AbilityConnectManager::DoBackgroundAbilityWindow(const std::shared_ptr &abilityRecord, + const sptr &sessionInfo) +{ +} + +void AbilityConnectManager::TerminateAbilityWindowLocked(const std::shared_ptr &abilityRecord, + const sptr &sessionInfo) +{ +} + +void AbilityConnectManager::TerminateDone(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::RemoveConnectionRecordFromMap(std::shared_ptr connection) +{ +} + +void AbilityConnectManager::RemoveServiceAbility(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::AddConnectDeathRecipient(sptr connectObject) +{ +} + +void AbilityConnectManager::RemoveConnectDeathRecipient(sptr connectObject) +{ +} + +void AbilityConnectManager::OnCallBackDied(const wptr &remote) +{ +} + +void AbilityConnectManager::HandleCallBackDiedTask(const sptr &connect) +{ +} + +int32_t AbilityConnectManager::GetActiveUIExtensionList( + const int32_t pid, std::vector &extensionList) +{ + return 0; +} + +int32_t AbilityConnectManager::GetActiveUIExtensionList( + const std::string &bundleName, std::vector &extensionList) +{ + return 0; +} + +void AbilityConnectManager::OnLoadAbilityFailed(std::shared_ptr abilityRecord) +{ +} + +void AbilityConnectManager::OnAbilityDied(const std::shared_ptr &abilityRecord, int32_t currentUserId) +{ +} + +void AbilityConnectManager::OnTimeOut(uint32_t msgId, int64_t abilityRecordId, bool isHalf) +{ +} + +void AbilityConnectManager::HandleInactiveTimeout(const std::shared_ptr &ability) +{ +} + +void AbilityConnectManager::CleanActivatingTimeoutAbility(std::shared_ptr abilityRecord) +{ +} + +bool AbilityConnectManager::IsAbilityNeedKeepAlive(const std::shared_ptr &abilityRecord) +{ + return true; +} + +void AbilityConnectManager::ClearPreloadUIExtensionRecord(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::KeepAbilityAlive(const std::shared_ptr &abilityRecord, int32_t currentUserId) +{ +} + +bool AbilityConnectManager::IsNeedToRestart(const std::shared_ptr &abilityRecord, + const std::string &bundleName, const std::string &abilityName) +{ + return true; +} + +void AbilityConnectManager::DisconnectBeforeCleanup() +{ +} + +void AbilityConnectManager::HandleAbilityDiedTask( + const std::shared_ptr &abilityRecord, int32_t currentUserId) +{ +} + +static bool CheckIsNumString(const std::string &numStr) +{ + return true; +} + +void AbilityConnectManager::HandleNotifyAssertFaultDialogDied(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::CloseAssertDialog(const std::string &assertSessionId) +{ +} + +void AbilityConnectManager::HandleUIExtensionDied(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::RestartAbility(const std::shared_ptr &abilityRecord, int32_t currentUserId) +{ +} + +std::string AbilityConnectManager::GetServiceKey(const std::shared_ptr &service) +{ + return ""; +} + +void AbilityConnectManager::DumpState(std::vector &info, bool isClient, const std::string &args) +{ +} + +void AbilityConnectManager::DumpStateByUri(std::vector &info, bool isClient, const std::string &args, + std::vector ¶ms) +{ +} + +void AbilityConnectManager::GetExtensionRunningInfos(int upperLimit, std::vector &info, + const int32_t userId, bool isPerm) +{ +} + +void AbilityConnectManager::GetAbilityRunningInfos(std::vector &info, bool isPerm) +{ +} + +void AbilityConnectManager::GetExtensionRunningInfo(std::shared_ptr &abilityRecord, + const int32_t userId, std::vector &info) +{ +} + +void AbilityConnectManager::PauseExtensions() +{ +} + +void AbilityConnectManager::RemoveLauncherDeathRecipient() +{ +} + +bool AbilityConnectManager::IsLauncher(std::shared_ptr serviceExtension) const +{ + return true; +} + +void AbilityConnectManager::KillProcessesByUserId() const +{ +} + +void AbilityConnectManager::MoveToBackground(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::CompleteForeground(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::HandleForegroundTimeoutTask(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::CompleteBackground(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::PrintTimeOutLog(const std::shared_ptr &ability, uint32_t msgId, bool isHalf) +{ +} + +bool AbilityConnectManager::GetTimeoutMsgContent(uint32_t msgId, std::string &msgContent, int &typeId) +{ + return true; +} + +void AbilityConnectManager::MoveToTerminatingMap(const std::shared_ptr& abilityRecord) +{ +} + +void AbilityConnectManager::AddUIExtWindowDeathRecipient(const sptr &session) +{ +} + +void AbilityConnectManager::RemoveUIExtWindowDeathRecipient(const sptr &session) +{ +} + +void AbilityConnectManager::OnUIExtWindowDied(const wptr &remote) +{ +} + +void AbilityConnectManager::HandleUIExtWindowDiedTask(const sptr &remote) +{ +} + +bool AbilityConnectManager::IsUIExtensionFocused(uint32_t uiExtensionTokenId, const sptr& focusToken) +{ + return true; +} + +sptr AbilityConnectManager::GetUIExtensionSourceToken(const sptr &token) +{ + return nullptr; +} + +void AbilityConnectManager::GetUIExtensionCallerTokenList(const std::shared_ptr &abilityRecord, + std::list> &callerList) +{ +} + +bool AbilityConnectManager::IsWindowExtensionFocused(uint32_t extensionTokenId, const sptr& focusToken) +{ + return true; +} + +void AbilityConnectManager::HandleProcessFrozen(const std::vector &pidList, int32_t uid) +{ +} + +void AbilityConnectManager::PostExtensionDelayDisconnectTask(const std::shared_ptr &connectRecord) +{ +} + +void AbilityConnectManager::RemoveExtensionDelayDisconnectTask(const std::shared_ptr &connectRecord) +{ +} + +void AbilityConnectManager::HandleExtensionDisconnectTask(const std::shared_ptr &connectRecord) +{ +} + +bool AbilityConnectManager::IsUIExtensionAbility(const std::shared_ptr &abilityRecord) +{ + return true; +} + +bool AbilityConnectManager::IsCacheExtensionAbilityByInfo(const AppExecFwk::AbilityInfo &abilityInfo) +{ + return true; +} + +bool AbilityConnectManager::IsCacheExtensionAbility(const std::shared_ptr &abilityRecord) +{ + return true; +} + +bool AbilityConnectManager::CheckUIExtensionAbilitySessionExist( + const std::shared_ptr &abilityRecord) +{ + return true; +} + +void AbilityConnectManager::RemoveUIExtensionAbilityRecord(const std::shared_ptr &abilityRecord) +{ +} + +void AbilityConnectManager::AddUIExtensionAbilityRecordToTerminatedList( + const std::shared_ptr &abilityRecord) +{ +} + +bool AbilityConnectManager::IsCallerValid(const std::shared_ptr &abilityRecord) +{ + return true; +} + +std::shared_ptr AbilityConnectManager::GetUIExtensionRootHostInfo(const sptr token) +{ + return nullptr; +} + +int32_t AbilityConnectManager::GetUIExtensionSessionInfo(const sptr token, + UIExtensionSessionInfo &uiExtensionSessionInfo) +{ + return ERR_OK; +} + +void AbilityConnectManager::SignRestartAppFlag(int32_t uid, const std::string &instanceKey) +{ +} + +bool AbilityConnectManager::AddToServiceMap(const std::string &key, std::shared_ptr abilityRecord) +{ + return true; +} + +AbilityConnectManager::ServiceMapType AbilityConnectManager::GetServiceMap() +{ + std::lock_guard lock(serviceMapMutex_); + return serviceMap_; +} + +void AbilityConnectManager::AddConnectObjectToMap(sptr connectObject, + const ConnectListType &connectRecordList, bool updateOnly) +{ +} + +EventInfo AbilityConnectManager::BuildEventInfo(const std::shared_ptr &abilityRecord) +{ + EventInfo eventInfo; + return eventInfo; +} + +void AbilityConnectManager::UpdateUIExtensionInfo(const std::shared_ptr &abilityRecord, + int32_t hostPid) +{ +} + +std::string AbilityConnectManager::GenerateBundleName(const AbilityRequest &abilityRequest) const +{ + return ""; +} + +int32_t AbilityConnectManager::ReportXiaoYiToRSSIfNeeded(const AppExecFwk::AbilityInfo &abilityInfo) +{ + return ERR_OK; +} + +int32_t AbilityConnectManager::ReportAbilityStartInfoToRSS(const AppExecFwk::AbilityInfo &abilityInfo) +{ + return ERR_OK; +} + +void AbilityConnectManager::UninstallApp(const std::string &bundleName, int32_t uid) +{ +} + +int32_t AbilityConnectManager::UpdateKeepAliveEnableState(const std::string &bundleName, + const std::string &moduleName, const std::string &mainElement, bool updateEnable) +{ + return ERR_OK; +} + +int32_t AbilityConnectManager::QueryPreLoadUIExtensionRecordInner(const AppExecFwk::ElementName &element, + const std::string &moduleName, + const std::string &hostBundleName, + int32_t &recordNum) +{ + return ERR_OK; +} + +std::shared_ptr AbilityConnectManager::GetUIExtensionBySessionFromServiceMap( + const sptr &sessionInfo) +{ + return MyStatus::GetInstance().acmGetUIExtensionBySessionFromServiceMap_; +} + +void AbilityConnectManager::UpdateUIExtensionBindInfo( + const std::shared_ptr &abilityRecord, std::string callerBundleName, int32_t notifyProcessBind) +{ +} +} // namespace AAFwk +} // namespace OHOS -- Gitee