diff --git a/services/common/include/bundle_active_core.h b/services/common/include/bundle_active_core.h index ca02dab5e53e268d03a5422a08e8222eebbe10ca..4ad90d7c9bf3384b06ea177e70cd11ddf232dd82 100644 --- a/services/common/include/bundle_active_core.h +++ b/services/common/include/bundle_active_core.h @@ -249,6 +249,7 @@ public: bool isUninstalledApp(const int32_t uid); void OnBundleInstalled(const int32_t userId, const std::string& bundleName, const int32_t uid, const int32_t appIndex); + void DeInit(); private: void NotifOberserverGroupChanged(const AppGroupCallbackInfo& callbackInfo, AccessToken::HapTokenInfo tokenInfo); diff --git a/services/common/src/bundle_active_core.cpp b/services/common/src/bundle_active_core.cpp index 35f26779dc3cf26ce78b738267f90ec3c222c495..e3718774f82268e355d48cf44bc80a8580f184e5 100644 --- a/services/common/src/bundle_active_core.cpp +++ b/services/common/src/bundle_active_core.cpp @@ -76,6 +76,16 @@ BundleActiveCore::~BundleActiveCore() { } +void BundleActiveCore::DeInit() +{ + if (bundleGroupHandler_ != nullptr) { + bundleGroupHandler_->DeInit(); + } + if (!handler_.expired()) { + handler_.lock()->DeInit(); + } +} + void BundleActiveCommonEventSubscriber::OnReceiveEvent(const CommonEventData &data) { std::lock_guard lock(mutex_); diff --git a/services/packagegroup/include/bundle_active_group_handler.h b/services/packagegroup/include/bundle_active_group_handler.h index 64d5fbe73456acd14fe2ec2b19ae2b09ed4c42fb..6c8b18877f6e2f0642d47d37bbfdcada9450f514 100644 --- a/services/packagegroup/include/bundle_active_group_handler.h +++ b/services/packagegroup/include/bundle_active_group_handler.h @@ -56,6 +56,7 @@ public: void PostSyncTask(const std::function& fuc); void PostTask(const std::function& fuc); void Init(const std::shared_ptr& bundleActiveController); + void DeInit(); static const int32_t MSG_CHECK_DEFAULT_BUNDLE_STATE; static const int32_t MSG_ONE_TIME_CHECK_BUNDLE_STATE; static const int32_t MSG_CHECK_IDLE_STATE; diff --git a/services/packagegroup/src/bundle_active_group_handler.cpp b/services/packagegroup/src/bundle_active_group_handler.cpp index a3051b33ab6efe002f71c54f3875558cd42e0822..bbef76ddccb09fe4e8239fcc421331527ecd05d0 100644 --- a/services/packagegroup/src/bundle_active_group_handler.cpp +++ b/services/packagegroup/src/bundle_active_group_handler.cpp @@ -48,6 +48,23 @@ BundleActiveGroupHandler::BundleActiveGroupHandler(const bool debug) } } +void BundleActiveGroupHandler::DeInit() +{ + isInited_ = false; + for (auto& iter : taskHandlerMap_) { + auto& queue = iter.second; + while(!queue.empty()) { + ffrtQueue->cancel(queue.front()); + queue.pop(); + } + } + taskHandlerMap_.clear(); + for (const auto& iter: checkBundleTaskMap_) { + ffrtQueue->cancel(iter.second); + } + checkBundleTaskMap_.clear(); +} + void BundleActiveGroupHandler::Init(const std::shared_ptr& bundleActiveController) { BUNDLE_ACTIVE_LOGI("Init called"); @@ -182,6 +199,9 @@ void BundleActiveGroupHandler::PostTask(const std::function& fuc) void BundleActiveGroupHandler::ProcessEvent(const int32_t& eventId, const std::shared_ptr& handlerobj) { + if (!isInited_) { + return; + } switch (eventId) { case MSG_CHECK_DEFAULT_BUNDLE_STATE: case MSG_CHECK_NOTIFICATION_SEEN_BUNDLE_STATE: diff --git a/services/packageusage/include/bundle_active_report_handler.h b/services/packageusage/include/bundle_active_report_handler.h index 7065b42fe3dcf4790c7b4b2816df64c5ee280e3f..1388ecacf6493399104b07cc1c2a5ef91fedcdbc 100644 --- a/services/packageusage/include/bundle_active_report_handler.h +++ b/services/packageusage/include/bundle_active_report_handler.h @@ -41,6 +41,7 @@ public: void RemoveEvent(const int32_t& eventId); bool HasEvent(const int32_t& eventId); void Init(const std::shared_ptr& bundleActiveCore); + void DeInit(); static const int32_t MSG_REPORT_EVENT; static const int32_t MSG_FLUSH_TO_DISK; static const int32_t MSG_REMOVE_USER; diff --git a/services/packageusage/src/bundle_active_report_handler.cpp b/services/packageusage/src/bundle_active_report_handler.cpp index c30c4224435fbbe488e5aacf9a288f8886f5e744..0453defddd07dd424b8a9aeb8b03656496986d44 100644 --- a/services/packageusage/src/bundle_active_report_handler.cpp +++ b/services/packageusage/src/bundle_active_report_handler.cpp @@ -40,6 +40,19 @@ void BundleActiveReportHandler::Init(const std::shared_ptr& bu isInited_ = true; } +void BundleActiveReportHandler::DeInit() +{ + isInited_ = false; + for (auto& iter : taskHandlerMap_) { + auto& queue = iter.second; + while(!queue.empty()) { + ffrtQueue->cancel(queue.front()); + queue.pop(); + } + } + taskHandlerMap_.clear(); +} + void BundleActiveReportHandler::SendEvent(const int32_t& eventId, const std::shared_ptr& handlerobj, const int64_t& delayTime) { @@ -99,6 +112,10 @@ bool BundleActiveReportHandler::HasEvent(const int32_t& eventId) void BundleActiveReportHandler::ProcessEvent(const int32_t& eventId, const std::shared_ptr& handlerobj) { + if (!isInited_) { + BUNDLE_ACTIVE_LOGE("init failed"); + return; + } if (handlerobj == nullptr) { BUNDLE_ACTIVE_LOGE("handlerobj is null, exit ProcessEvent"); return; diff --git a/test/unittest/device_usage_statistics_service_test.cpp b/test/unittest/device_usage_statistics_service_test.cpp index 6a2c2a0247ff77e7c1006fd7e839445396020e02..004c6b7481464cd5c138f1c02cf11e34e1341022 100644 --- a/test/unittest/device_usage_statistics_service_test.cpp +++ b/test/unittest/device_usage_statistics_service_test.cpp @@ -44,11 +44,10 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - static std::shared_ptr bundleActiveCore_; + void TestBundleActiveCoreInit(std::shared_ptr& bundleCtiveCore); + void TestBUndleActiveCoreDeInit(std::shared_ptr& bundleCtiveCore); }; -std::shared_ptr DeviceUsageStatisticsServiceTest::bundleActiveCore_ = nullptr; - void DeviceUsageStatisticsServiceTest::SetUpTestCase(void) { static const char *perms[] = { @@ -68,14 +67,10 @@ void DeviceUsageStatisticsServiceTest::SetUpTestCase(void) tokenId = GetAccessTokenId(&infoInstance); SetSelfTokenID(tokenId); AccessTokenKit::ReloadNativeTokenInfo(); - bundleActiveCore_ = std::make_shared(); - bundleActiveCore_->Init(); - bundleActiveCore_->InitBundleGroupController(); } void DeviceUsageStatisticsServiceTest::TearDownTestCase(void) { - bundleActiveCore_->bundleGroupHandler_->ffrtQueue_.reset(); int64_t sleepTime = 10; std::this_thread::sleep_for(std::chrono::seconds(sleepTime)); } @@ -90,6 +85,21 @@ void DeviceUsageStatisticsServiceTest::TearDown(void) std::this_thread::sleep_for(std::chrono::milliseconds(sleepTime)); } +void DeviceUsageStatisticsServiceTest::TestBundleActiveCoreInit(std::shared_ptr& bundleCtiveCore) +{ + bundleCtiveCore->Init(); + bundleCtiveCore->InitBundleGroupController(); +} + +void DeviceUsageStatisticsServiceTest::TestBUndleActiveCoreDeInit(std::shared_ptr& bundleCtiveCore) +{ + int64_t sleepTime = 10; + std::this_thread::sleep_for(std::chrono::seconds(sleepTime)); + bundleCtiveCore->DeInit(); + auto handle = bundleCtiveCore->bundleGroupHandler_->ffrtQueue_->submit_h([]() {}); + bundleCtiveCore->bundleGroupHandler_->ffrtQueue_->wait(handle); +} + class TestServiceAppGroupChangeCallback : public AppGroupCallbackStub { public: ErrCode OnAppGroupChanged(const AppGroupCallbackInfo &appGroupCallbackInfo) override; @@ -192,6 +202,7 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_dump args.clear(); args = {to_utf16("-D")}; bundleActiveService->Dump(-1, args); + bundleActiveService->bundleActiveCore_->DeInit(); } /* @@ -243,6 +254,7 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_AppG wptr remote = nullptr; bundleActiveService->bundleActiveCore_->OnObserverDied(remote); bundleActiveService->bundleActiveCore_->OnObserverDiedInner(remote); + bundleActiveService->bundleActiveCore_->DeInit(); } /* @@ -254,16 +266,19 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_AppG HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_AppGroupCallback_002, Function | MediumTest | Level0) { + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); sptr observer = new (std::nothrow) TestServiceAppGroupChangeCallback(); Security::AccessToken::AccessTokenID tokenId {}; - bundleActiveCore_->groupChangeObservers_[tokenId] = observer; + bundleActiveCore->groupChangeObservers_[tokenId] = observer; int32_t userId = 100; int32_t newGroup = 10; int32_t oldGroup = 60; int32_t reasonInGroup = 0; AppGroupCallbackInfo appGroupCallbackInfo(userId, newGroup, oldGroup, reasonInGroup, "test"); - bundleActiveCore_->OnAppGroupChanged(appGroupCallbackInfo); - SUCCEED(); + bundleActiveCore->OnAppGroupChanged(appGroupCallbackInfo); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -276,17 +291,19 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_OnUs Function | MediumTest | Level0) { int userId = 100; - auto coreObject = bundleActiveCore_; - coreObject->RestoreToDatabase(userId); - auto userService = std::make_shared(userId, *(coreObject.get()), false); - coreObject->userStatServices_[userId] = userService; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); + bundleActiveCore->RestoreToDatabase(userId); + auto userService = std::make_shared(userId, *(bundleActiveCore.get()), false); + bundleActiveCore->userStatServices_[userId] = userService; BundleActiveEvent event; - coreObject->ReportEventToAllUserId(event); - coreObject->currentUsedUser_ = userId; - coreObject->OnUserRemoved(userId); - coreObject->OnUserSwitched(userId); - EXPECT_NE(coreObject, nullptr); + bundleActiveCore->ReportEventToAllUserId(event); + bundleActiveCore->currentUsedUser_ = userId; + bundleActiveCore->OnUserRemoved(userId); + bundleActiveCore->OnUserSwitched(userId); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -298,19 +315,21 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_OnUs HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RestoreAllData_001, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int userId = 100; - auto userService = std::make_shared(userId, *(coreObject.get()), false); + auto userService = std::make_shared(userId, *(bundleActiveCore.get()), false); int64_t timeStamp = 20000000000000; userService->Init(timeStamp); - coreObject->userStatServices_[userId] = userService; + bundleActiveCore->userStatServices_[userId] = userService; userId = 101; - coreObject->userStatServices_[userId] = nullptr; - coreObject->RestoreAllData(); + bundleActiveCore->userStatServices_[userId] = nullptr; + bundleActiveCore->RestoreAllData(); BundleActiveEvent event; - coreObject->ReportEventToAllUserId(event); - EXPECT_NE(coreObject, nullptr); + bundleActiveCore->ReportEventToAllUserId(event); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -322,20 +341,22 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_Rest HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ObtainSystemEventName_001, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); BundleActiveEvent event; event.eventId_ = BundleActiveEvent::SYSTEM_LOCK; - coreObject->ObtainSystemEventName(event); + bundleActiveCore->ObtainSystemEventName(event); event.eventId_ = BundleActiveEvent::SYSTEM_UNLOCK; - coreObject->ObtainSystemEventName(event); + bundleActiveCore->ObtainSystemEventName(event); event.eventId_ = BundleActiveEvent::SYSTEM_SLEEP; - coreObject->ObtainSystemEventName(event); + bundleActiveCore->ObtainSystemEventName(event); event.eventId_ = BundleActiveEvent::SYSTEM_WAKEUP; - coreObject->ObtainSystemEventName(event); - EXPECT_NE(coreObject, nullptr); + bundleActiveCore->ObtainSystemEventName(event); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -704,36 +725,23 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetS HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ReportEvent_001, Function | MediumTest | Level0) { - bundleActiveCore_ = std::make_shared(); - bundleActiveCore_->Init(); - bundleActiveCore_->InitBundleGroupController(); + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); BundleActiveEvent event; int32_t userId = 0; - EXPECT_NE(bundleActiveCore_->ReportEvent(event, userId), ERR_OK); + EXPECT_NE(bundleActiveCore->ReportEvent(event, userId), ERR_OK); userId = 101; event.bundleName_ = "com.ohos.launcher"; - EXPECT_EQ(bundleActiveCore_->ReportEvent(event, userId), ERR_OK); + EXPECT_EQ(bundleActiveCore->ReportEvent(event, userId), ERR_OK); event.bundleName_ = "com.ohos.settings"; event.eventId_ = 15; - EXPECT_EQ(bundleActiveCore_->ReportEvent(event, userId), ERR_OK); + EXPECT_EQ(bundleActiveCore->ReportEvent(event, userId), ERR_OK); event.eventId_ = 16; - EXPECT_EQ(bundleActiveCore_->ReportEvent(event, userId), ERR_OK); -} - -/* - * @tc.name: DeviceUsageStatisticsServiceTest_InitBundleGroupController_001 - * @tc.desc: InitBundleGroupController - * @tc.type: FUNC - * @tc.require: issuesI5SOZY - */ -HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_InitBundleGroupController_001, - Function | MediumTest | Level0) -{ - auto coreObject = bundleActiveCore_; - coreObject->InitBundleGroupController(); + EXPECT_EQ(bundleActiveCore->ReportEvent(event, userId), ERR_OK); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -745,19 +753,21 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_Init HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ReportEventToAllUserId_001, Function | MediumTest | Level0) { - auto coreObject = std::make_shared(); + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int userId = 100; - auto userService = std::make_shared(userId, *(coreObject.get()), false); - coreObject->userStatServices_[userId] = userService; + auto userService = std::make_shared(userId, *(bundleActiveCore.get()), false); + bundleActiveCore->userStatServices_[userId] = userService; userId = 101; - coreObject->userStatServices_[userId] = nullptr; + bundleActiveCore->userStatServices_[userId] = nullptr; BundleActiveEvent event; - coreObject->ReportEventToAllUserId(event); + bundleActiveCore->ReportEventToAllUserId(event); - coreObject->Init(); - coreObject->InitBundleGroupController(); - coreObject->ReportEventToAllUserId(event); - EXPECT_NE(coreObject, nullptr); + bundleActiveCore->Init(); + bundleActiveCore->InitBundleGroupController(); + bundleActiveCore->ReportEventToAllUserId(event); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -769,17 +779,19 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_Repo HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RestoreToDatabase_001, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int userId = 100; - auto userService = std::make_shared(userId, *(coreObject.get()), false); + auto userService = std::make_shared(userId, *(bundleActiveCore.get()), false); int64_t timeStamp = 20000000000000; userService->Init(timeStamp); - coreObject->userStatServices_[userId] = userService; - coreObject->RestoreToDatabase(userId); + bundleActiveCore->userStatServices_[userId] = userService; + bundleActiveCore->RestoreToDatabase(userId); userId = 101; - coreObject->RestoreToDatabase(userId); - EXPECT_NE(coreObject, nullptr); + bundleActiveCore->RestoreToDatabase(userId); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -791,14 +803,16 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_Rest HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_001, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int userId = 100; - auto userService = std::make_shared(userId, *(coreObject.get()), false); + auto userService = std::make_shared(userId, *(bundleActiveCore.get()), false); int64_t timeStamp = 20000000000000; userService->Init(timeStamp); - coreObject->userStatServices_[userId] = userService; - coreObject->OnUserRemoved(userId); - SUCCEED(); + bundleActiveCore->userStatServices_[userId] = userService; + bundleActiveCore->OnUserRemoved(userId); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -810,14 +824,16 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_001, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_002, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int userId = 100; - auto userService = std::make_shared(userId, *(coreObject.get()), false); + auto userService = std::make_shared(userId, *(bundleActiveCore.get()), false); int64_t timeStamp = 20000000000000; userService->Init(timeStamp); - coreObject->userStatServices_[userId] = userService; - coreObject->bundleGroupController_->OnUserSwitched(userId, userId); - SUCCEED(); + bundleActiveCore->userStatServices_[userId] = userService; + bundleActiveCore->bundleGroupController_->OnUserSwitched(userId, userId); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -829,13 +845,15 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_002, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_003, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int userId = 100; - auto userService = std::make_shared(userId, *(coreObject.get()), false); + auto userService = std::make_shared(userId, *(bundleActiveCore.get()), false); int64_t timeStamp = 20000000000000; userService->Init(timeStamp); - coreObject->userStatServices_[userId] = userService; - EXPECT_EQ(coreObject->bundleGroupController_->GetNewGroup("test", userId, timeStamp, 0), -1); + bundleActiveCore->userStatServices_[userId] = userService; + EXPECT_EQ(bundleActiveCore->bundleGroupController_->GetNewGroup("test", userId, timeStamp, 0), -1); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -847,20 +865,22 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_003, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_004, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int userId = 100; BundleActiveEvent event; int64_t timeStamp = 20000000000000; - coreObject->bundleGroupController_->ReportEvent(event, timeStamp, userId); - SUCCEED(); - coreObject->bundleGroupController_->ReportEvent(event, timeStamp, 19); - SUCCEED(); - coreObject->bundleGroupController_->ReportEvent(event, timeStamp, 7); - SUCCEED(); - coreObject->bundleGroupController_->bundleGroupEnable_ = false; - SUCCEED(); - coreObject->bundleGroupController_->ReportEvent(event, timeStamp, userId); - SUCCEED(); + bundleActiveCore->bundleGroupController_->ReportEvent(event, timeStamp, userId); + EXPECT_NE(bundleActiveCore, nullptr); + bundleActiveCore->bundleGroupController_->ReportEvent(event, timeStamp, 19); + EXPECT_NE(bundleActiveCore, nullptr); + bundleActiveCore->bundleGroupController_->ReportEvent(event, timeStamp, 7); + EXPECT_NE(bundleActiveCore, nullptr); + bundleActiveCore->bundleGroupController_->bundleGroupEnable_ = false; + EXPECT_NE(bundleActiveCore, nullptr); + bundleActiveCore->bundleGroupController_->ReportEvent(event, timeStamp, userId); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -872,11 +892,13 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_004, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_005, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int userId = 100; int64_t timeStamp = 20000000000000; - coreObject->bundleGroupController_->CheckAndUpdateGroup("test", userId, 0, timeStamp); - SUCCEED(); + bundleActiveCore->bundleGroupController_->CheckAndUpdateGroup("test", userId, 0, timeStamp); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -888,11 +910,13 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_005, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_006, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int userId = 100; int64_t time = 20000000000000; - EXPECT_EQ(coreObject->bundleGroupController_->SetAppGroup("test", userId, 0, 0, time, true), + EXPECT_EQ(bundleActiveCore->bundleGroupController_->SetAppGroup("test", userId, 0, 0, time, true), ERR_NO_APP_GROUP_INFO_IN_DATABASE); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -904,9 +928,11 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_006, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_007, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int userId = 100; - EXPECT_EQ(coreObject->bundleGroupController_->IsBundleIdle("test", userId), -1); + EXPECT_EQ(bundleActiveCore->bundleGroupController_->IsBundleIdle("test", userId), -1); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -918,13 +944,14 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_007, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_009, Function | MediumTest | Level0) { - auto coreObject = std::make_shared(); - coreObject->bundleGroupController_ = std::make_shared(true); - coreObject->InitBundleGroupController(); + auto bundleActiveCore = std::make_shared(); + bundleActiveCore->bundleGroupController_ = std::make_shared(true); + bundleActiveCore->InitBundleGroupController(); int userId = 100; - EXPECT_EQ(coreObject->bundleGroupController_->IsBundleInstalled("test", userId), false); - coreObject->bundleGroupController_->sptrBundleMgr_ = nullptr; - EXPECT_EQ(coreObject->bundleGroupController_->IsBundleInstalled("test", userId), false); + EXPECT_EQ(bundleActiveCore->bundleGroupController_->IsBundleInstalled("test", userId), false); + bundleActiveCore->bundleGroupController_->sptrBundleMgr_ = nullptr; + EXPECT_EQ(bundleActiveCore->bundleGroupController_->IsBundleInstalled("test", userId), false); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -936,11 +963,13 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_009, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_010, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int userId = 100; int64_t timeStamp = 20000000000000; - coreObject->bundleGroupController_->ShutDown(timeStamp, userId); - SUCCEED(); + bundleActiveCore->bundleGroupController_->ShutDown(timeStamp, userId); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -952,10 +981,13 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_010, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_011, Function | MediumTest | Level0) { + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); bool isScreenOn = true; int64_t timeStamp = 0; - bundleActiveCore_->bundleGroupController_->OnScreenChanged(isScreenOn, timeStamp); - SUCCEED(); + bundleActiveCore->bundleGroupController_->OnScreenChanged(isScreenOn, timeStamp); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -967,8 +999,12 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_011, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_012, Function | MediumTest | Level0) { - bundleActiveCore_->bundleGroupController_->ShutDown(1, 10); - EXPECT_NE(bundleActiveCore_->bundleGroupController_->bundleUserHistory_, nullptr); + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); + bundleActiveCore->bundleGroupController_->ShutDown(1, 10); + EXPECT_NE(bundleActiveCore->bundleGroupController_->bundleUserHistory_, nullptr); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -980,8 +1016,11 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_011, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_013, Function | MediumTest | Level0) { - bundleActiveCore_->bundleGroupController_->OnUserRemoved(10); - EXPECT_NE(bundleActiveCore_->bundleGroupController_->bundleUserHistory_, nullptr); + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); + bundleActiveCore->bundleGroupController_->OnUserRemoved(10); + EXPECT_NE(bundleActiveCore->bundleGroupController_->bundleUserHistory_, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -993,8 +1032,11 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_011, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_014, Function | MediumTest | Level0) { - bundleActiveCore_->bundleGroupController_->OnUserSwitched(1, 10); - EXPECT_NE(bundleActiveCore_->bundleGroupController_->bundleUserHistory_, nullptr); + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); + bundleActiveCore->bundleGroupController_->OnUserSwitched(1, 10); + EXPECT_NE(bundleActiveCore->bundleGroupController_->bundleUserHistory_, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -1006,11 +1048,15 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_011, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_001, Function | MediumTest | Level0) { + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int64_t bootBasedTimeStamp = 2000; std::vector screenTimeLevel; std::vector bootFromTimeLevel; - auto bundleUserHistory_ = std::make_shared(bootBasedTimeStamp, bundleActiveCore_); - bundleUserHistory_->GetLevelIndex("test", 0, 20000, screenTimeLevel, bootFromTimeLevel, 0); + auto bundleUserHistory = std::make_shared(bootBasedTimeStamp, bundleActiveCore); + bundleUserHistory->GetLevelIndex("test", 0, 20000, screenTimeLevel, bootFromTimeLevel, 0); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -1022,11 +1068,14 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_001, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_002, Function | MediumTest | Level0) { + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int64_t bootBasedTimeStamp = 2000; - auto bundleUserHistory_ = std::make_shared(bootBasedTimeStamp, bundleActiveCore_); - bundleUserHistory_->WriteDeviceDuration(); - bundleUserHistory_->OnBundleUninstalled(0, "test", 0, 0); - SUCCEED(); + auto bundleUserHistory = std::make_shared(bootBasedTimeStamp, bundleActiveCore); + bundleUserHistory->WriteDeviceDuration(); + bundleUserHistory->OnBundleUninstalled(0, "test", 0, 0); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -1038,19 +1087,22 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_002, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_003, Function | MediumTest | Level0) { + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int64_t bootBasedTimeStamp = 2000; auto oneBundleUsageHistory = std::make_shared(); - auto bundleUserHistory_ = std::make_shared(bootBasedTimeStamp, bundleActiveCore_); - bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 0, 0, 1000, 2000, 100, 0); - SUCCEED(); - bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 0, 0, 2000, 1000, 100, 0); - SUCCEED(); - bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 10, 0, 1000, 2000, 100, 0); - SUCCEED(); - bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 20, 0, 1000, 2000, 100, 0); - SUCCEED(); - bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 20, 0, 0, 2000, 100, 0); - SUCCEED(); + auto bundleUserHistory = std::make_shared(bootBasedTimeStamp, bundleActiveCore); + bundleUserHistory->ReportUsage(oneBundleUsageHistory, "test", 0, 0, 1000, 2000, 100, 0); + EXPECT_NE(bundleUserHistory, nullptr); + bundleUserHistory->ReportUsage(oneBundleUsageHistory, "test", 0, 0, 2000, 1000, 100, 0); + EXPECT_NE(bundleUserHistory, nullptr); + bundleUserHistory->ReportUsage(oneBundleUsageHistory, "test", 10, 0, 1000, 2000, 100, 0); + EXPECT_NE(bundleUserHistory, nullptr); + bundleUserHistory->ReportUsage(oneBundleUsageHistory, "test", 20, 0, 1000, 2000, 100, 0); + EXPECT_NE(bundleUserHistory, nullptr); + bundleUserHistory->ReportUsage(oneBundleUsageHistory, "test", 20, 0, 0, 2000, 100, 0); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -1062,16 +1114,19 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_003, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_004, Function | MediumTest | Level0) { + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int32_t userId = 100; int64_t bootBasedTimeStamp = 2000; int32_t newgroup = 0; uint32_t groupReason = 0; int32_t uid = 0; - auto bundleUserHistory_ = std::make_shared(bootBasedTimeStamp, bundleActiveCore_); - bundleUserHistory_->SetAppGroup("test", userId, uid, bootBasedTimeStamp, newgroup, groupReason, true); - SUCCEED(); - bundleUserHistory_->SetAppGroup("test", userId, uid, bootBasedTimeStamp, newgroup, groupReason, false); - SUCCEED(); + auto bundleUserHistory = std::make_shared(bootBasedTimeStamp, bundleActiveCore); + bundleUserHistory->SetAppGroup("test", userId, uid, bootBasedTimeStamp, newgroup, groupReason, true); + EXPECT_NE(bundleUserHistory, nullptr); + bundleUserHistory->SetAppGroup("test", userId, uid, bootBasedTimeStamp, newgroup, groupReason, false); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -1083,10 +1138,13 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_004, HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_005, Function | MediumTest | Level0) { + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int64_t bootBasedTimeStamp = 2000; - auto bundleUserHistory_ = std::make_shared(bootBasedTimeStamp, bundleActiveCore_); + auto bundleUserHistory_ = std::make_shared(bootBasedTimeStamp, bundleActiveCore); bundleUserHistory_->PrintData(0); - SUCCEED(); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -1098,9 +1156,11 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_005, HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ShutDown_001, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; - coreObject->ShutDown(); - EXPECT_NE(coreObject, nullptr); + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); + bundleActiveCore->ShutDown(); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -1112,15 +1172,17 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_Shut HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CheckTimeChangeAndGetWallTime_001, Function | MediumTest | Level0) { + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int userId = 100; - auto coreObject = bundleActiveCore_; - coreObject->OnUserRemoved(100); - auto userService = std::make_shared(userId, *(coreObject.get()), false); - coreObject->userStatServices_[userId] = userService; + bundleActiveCore->OnUserRemoved(100); + auto userService = std::make_shared(userId, *(bundleActiveCore.get()), false); + bundleActiveCore->userStatServices_[userId] = userService; - coreObject->CheckTimeChangeAndGetWallTime(userId); - coreObject->OnUserSwitched(userId); - EXPECT_NE(coreObject, nullptr); + bundleActiveCore->CheckTimeChangeAndGetWallTime(userId); + bundleActiveCore->OnUserSwitched(userId); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -1132,7 +1194,9 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_Chec HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryAppGroup_001, Function | MediumTest | Level0) { - auto groupController = bundleActiveCore_->bundleGroupController_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); + auto groupController = bundleActiveCore->bundleGroupController_; int32_t appGroup = 10; std::string bundleName = ""; int32_t userId = 100; @@ -1141,6 +1205,8 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_Quer groupController->sptrBundleMgr_ = nullptr; bundleName = "defaultBundleName"; EXPECT_NE(groupController->QueryAppGroup(appGroup, bundleName, userId), ERR_OK); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -1152,24 +1218,26 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_Quer HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ControllerReportEvent_001, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int64_t bootBasedTimeStamp = 20000000000000; BundleActiveEvent event; int32_t userId = 100; - coreObject->bundleGroupController_->bundleGroupEnable_ = false; - coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId); + bundleActiveCore->bundleGroupController_->bundleGroupEnable_ = false; + bundleActiveCore->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId); - coreObject->bundleGroupController_->bundleGroupEnable_ = true; + bundleActiveCore->bundleGroupController_->bundleGroupEnable_ = true; event.bundleName_ = "com.ohos.camera"; - coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId); + bundleActiveCore->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId); event.eventId_ = BundleActiveEvent::NOTIFICATION_SEEN; - coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId); + bundleActiveCore->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId); event.eventId_ = BundleActiveEvent::SYSTEM_INTERACTIVE; - coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId); - EXPECT_NE(coreObject, nullptr); + bundleActiveCore->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -1181,7 +1249,8 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_Cont HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CheckAndUpdateGroup_001, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); std::string bundleName = "com.ohos.camera"; int32_t userId = 100; @@ -1191,16 +1260,17 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_Chec bool isFlush = false; int32_t appGroup = 0; - coreObject->bundleGroupController_->QueryAppGroup(appGroup, bundleName, userId); + bundleActiveCore->bundleGroupController_->QueryAppGroup(appGroup, bundleName, userId); - coreObject->bundleGroupController_->SetAppGroup(bundleName, userId, newGroup, reason, bootBasedTimeStamp, isFlush); - coreObject->bundleGroupController_->CheckAndUpdateGroup(bundleName, 0, userId, bootBasedTimeStamp); + bundleActiveCore->bundleGroupController_->SetAppGroup(bundleName, userId, newGroup, reason, bootBasedTimeStamp, isFlush); + bundleActiveCore->bundleGroupController_->CheckAndUpdateGroup(bundleName, 0, userId, bootBasedTimeStamp); newGroup = 20; reason = GROUP_CONTROL_REASON_CALCULATED; - coreObject->bundleGroupController_->SetAppGroup(bundleName, userId, newGroup, reason, bootBasedTimeStamp, isFlush); - coreObject->bundleGroupController_->CheckAndUpdateGroup(bundleName, 0, userId, bootBasedTimeStamp); - EXPECT_NE(coreObject, nullptr); + bundleActiveCore->bundleGroupController_->SetAppGroup(bundleName, userId, newGroup, reason, bootBasedTimeStamp, isFlush); + bundleActiveCore->bundleGroupController_->CheckAndUpdateGroup(bundleName, 0, userId, bootBasedTimeStamp); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -1212,11 +1282,12 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_Chec HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_PreservePowerStateInfo_001, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; - + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND; - coreObject->PreservePowerStateInfo(eventId); - EXPECT_NE(coreObject, nullptr); + bundleActiveCore->PreservePowerStateInfo(eventId); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /* @@ -1467,9 +1538,10 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_Upda HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_DeleteUninstalledBundleStats_001, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int userId = 100; - auto userService = std::make_shared(userId, *(coreObject.get()), false); + auto userService = std::make_shared(userId, *(bundleActiveCore.get()), false); int appIndex = 1; std::vector> curStats; std::shared_ptr stats = std::make_shared(); @@ -1494,9 +1566,10 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_Dele HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_DeleteUninstalledBundleStats_002, Function | MediumTest | Level0) { - auto coreObject = bundleActiveCore_; + auto bundleActiveCore = std::make_shared(); + TestBundleActiveCoreInit(bundleActiveCore); int userId = 100; - auto userService = std::make_shared(userId, *(coreObject.get()), false); + auto userService = std::make_shared(userId, *(bundleActiveCore.get()), false); int appIndex = 1; std::vector> curStats; std::shared_ptr stats = std::make_shared(); @@ -1520,6 +1593,8 @@ HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_Dele userService->DeleteUninstalledBundleStats("test", 100, appIndex); appIndex = 0; userService->DeleteUninstalledBundleStats("test", 100, appIndex); + EXPECT_NE(bundleActiveCore, nullptr); + TestBundleActiveCoreDeInit(bundleActiveCore); } /*