From 5a757860b96e03ff121aaa32cb39d7f2718f7f22 Mon Sep 17 00:00:00 2001 From: chengwang Date: Fri, 22 Aug 2025 19:55:14 +0800 Subject: [PATCH 1/2] cellular data power improvement Signed-off-by: chengwang --- 0822.patch | 787 ++++++++++++++++++ BUILD.gn | 24 + bundle.json | 3 +- .../js/napi/src/cellular_data_handler.cpp | 12 + services/include/cellular_data_handler.h | 6 +- .../cellular_data_power_improvement_manager.h | 74 ++ ...ellular_data_power_improvement_manager.cpp | 189 +++++ test/BUILD.gn | 1 + test/cellular_data_handler_test.cpp | 25 + ...ar_data_power_improvement_manager_test.cpp | 277 ++++++ 10 files changed, 1396 insertions(+), 2 deletions(-) create mode 100644 0822.patch create mode 100644 services/include/cellular_data_power_improvement_manager.h create mode 100644 services/src/cellular_data_power_improvement_manager.cpp create mode 100644 test/cellular_data_power_improvement_manager_test.cpp diff --git a/0822.patch b/0822.patch new file mode 100644 index 00000000..5ef9cdd8 --- /dev/null +++ b/0822.patch @@ -0,0 +1,787 @@ +From 55b8fdcf2e58e9b9e0733bbedab9d1bcc768f3ec Mon Sep 17 00:00:00 2001 +From: wangcheng 00845532 +Date: Thu, 21 Aug 2025 18:31:50 +0800 +Subject: [PATCH] TicketNo:AR20250209607755 Description:test str mode + Team:SP_XA_PTL Feature or Bugfix:Feature Binary Source:No + PrivateCode(Yes/No):No + +Change-Id: I2077a86c01535bf3b63411822cb4e0bdbe571dac +--- + BUILD.gn | 24 ++ + bundle.json | 3 +- + .../js/napi/src/cellular_data_handler.cpp | 16 + + services/include/cellular_data_handler.h | 6 +- + .../cellular_data_power_improvement_manager.h | 74 +++++ + ...ellular_data_power_improvement_manager.cpp | 189 ++++++++++++ + test/BUILD.gn | 1 + + test/cellular_data_handler_test.cpp | 25 ++ + ...ar_data_power_improvement_manager_test.cpp | 277 ++++++++++++++++++ + 9 files changed, 613 insertions(+), 2 deletions(-) + create mode 100644 services/include/cellular_data_power_improvement_manager.h + create mode 100644 services/src/cellular_data_power_improvement_manager.cpp + create mode 100644 test/cellular_data_power_improvement_manager_test.cpp + +diff --git a/BUILD.gn b/BUILD.gn +index 6b38160e..7ce3099c 100644 +--- a/BUILD.gn ++++ b/BUILD.gn +@@ -16,6 +16,10 @@ import("../core_service/telephony_core_service.gni") + TELEPHONY_EXT_WRAPPER_ROOT = "services/telephony_ext_wrapper" + DATA_SERVICE_EXT_WRAPPER_ROOT = "services/data_service_ext_wrapper" + ++declare_args() { ++ cellular_data_feature_base_power_improvement = false ++} ++ + ohos_shared_library("tel_cellular_data") { + sanitize = { + cfi = true +@@ -65,6 +69,12 @@ ohos_shared_library("tel_cellular_data") { + "services/src/utils/network_search_callback.cpp", + ] + ++ if (cellular_data_feature_base_power_improvement ) { ++ sources += [ ++ "services/src/cellular_data_power_improvement_manager.cpp", ++ ] ++ } ++ + include_dirs = [ + "$TELEPHONY_EXT_WRAPPER_ROOT/include", + "$DATA_SERVICE_EXT_WRAPPER_ROOT/include", +@@ -126,6 +136,10 @@ ohos_shared_library("tel_cellular_data") { + defines += [ "HICOLLIE_ENABLE" ] + } + ++ if (cellular_data_feature_base_power_improvement ) { ++ defines += [ "BASE_POWER_IMPROVEMENT" ] ++ } ++ + if (defined(global_parts_info) && + defined(global_parts_info.communication_netmanager_enhanced)) { + defines += [ "OHOS_BUILD_ENABLE_DATA_SERVICE_EXT" ] +@@ -185,6 +199,12 @@ ohos_static_library("tel_cellular_data_static") { + "services/src/utils/network_search_callback.cpp", + ] + ++ if (cellular_data_feature_base_power_improvement ) { ++ sources += [ ++ "services/src/cellular_data_power_improvement_manager.cpp", ++ ] ++ } ++ + include_dirs = [ + "$TELEPHONY_EXT_WRAPPER_ROOT/include", + "$DATA_SERVICE_EXT_WRAPPER_ROOT/include", +@@ -246,6 +266,10 @@ ohos_static_library("tel_cellular_data_static") { + defines += [ "HICOLLIE_ENABLE" ] + } + ++ if (cellular_data_feature_base_power_improvement ) { ++ defines += [ "BASE_POWER_IMPROVEMENT" ] ++ } ++ + if (defined(global_parts_info) && + defined(global_parts_info.communication_netmanager_enhanced)) { + defines += [ "OHOS_BUILD_ENABLE_DATA_SERVICE_EXT" ] +diff --git a/bundle.json b/bundle.json +index 1bed29ca..42944a6f 100644 +--- a/bundle.json ++++ b/bundle.json +@@ -23,7 +23,8 @@ + "SystemCapability.Telephony.CellularData" + ], + "features": [ +- "cellular_data_dynamic_start" ++ "cellular_data_dynamic_start", ++ "cellular_data_feature_base_power_improvement" + ], + "adapted_system_type": [ + "standard" +diff --git a/frameworks/js/napi/src/cellular_data_handler.cpp b/frameworks/js/napi/src/cellular_data_handler.cpp +index 3c1af7c1..d53a9630 100644 +--- a/frameworks/js/napi/src/cellular_data_handler.cpp ++++ b/frameworks/js/napi/src/cellular_data_handler.cpp +@@ -37,6 +37,10 @@ + #include "telephony_permission.h" + #include "ipc_skeleton.h" + #include "connection_retry_policy.h" ++#include "pdp_profile_data.h" ++#ifdef BASE_POWER_IMPROVEMENT ++#include "cellular_data_power_improvement_manager.h" ++#endif + namespace OHOS { + namespace Telephony { + using namespace AppExecFwk; +@@ -75,6 +79,12 @@ void CellularDataHandler::Init() + dataSwitchSettings_->LoadSwitchValue(); + GetConfigurationFor5G(); + SetRilLinkBandwidths(); ++#ifdef BASE_POWER_IMPROVEMENT ++ dataConnectionPowerImprovementManager_ = std::make_shared(*this); ++ bool isDefinedTelePower = system::GetBoolParameter("const.vendor.ril.power.feature_tele_power", false); ++ bool ret = dataConnectionPowerImprovementManager_->StartEventSubscriber(isDefinedTelePower); ++ TELEPHONY_LOGI("Subscribe ordered broadcast succ ret = %{public}d", ret); ++#endif + } + + CellularDataHandler::~CellularDataHandler() {} +@@ -1017,6 +1027,12 @@ void CellularDataHandler::HandleDisconnectDataCompleteForMmsType(sptr + SetDataPermittedForMms(false); + RemoveEvent(CellularDataEventCode::MSG_RESUME_DATA_PERMITTED_TIMEOUT); + } ++#ifdef BASE_POWER_IMPROVEMENT ++ if (dataConnectionPowerImprovementManager_ != nullptr && DataConnectionPowerImprovementManager::powerSaveFlag_) { ++ dataConnectionPowerImprovementManager_->FinishPowerStrEnterEvent(); ++ DataConnectionPowerImprovementManager::powerSaveFlag_ = false; ++ } ++#endif + } + + void CellularDataHandler::RetryOrClearConnection(const sptr &apnHolder, DisConnectionReason reason, +diff --git a/services/include/cellular_data_handler.h b/services/include/cellular_data_handler.h +index 3a763d19..07890f63 100644 +--- a/services/include/cellular_data_handler.h ++++ b/services/include/cellular_data_handler.h +@@ -38,9 +38,11 @@ + #include "tel_profile_util.h" + #include "tel_ril_data_parcel.h" + #include "telephony_types.h" ++ + namespace OHOS { + namespace Telephony { + const uint32_t KEEP_APN_ACTIVATE_PERIOD = 30 * 1000; ++class DataConnectionPowerImprovementManager; + class CellularDataHandler : public TelEventHandler, public EventFwk::CommonEventSubscriber { + public: + explicit CellularDataHandler(const EventFwk::CommonEventSubscribeInfo &sp, int32_t slotId); +@@ -222,7 +224,9 @@ private: + uint64_t defaultApnActTime_ = 0; + uint64_t internalApnActTime_ = 0; + int32_t retryCreateApnTimes_ = 0; +- ++#ifdef BASE_POWER_IMPROVEMENT ++ std::shared_ptr dataConnectionPowerImprovementManager_ = nullptr; ++#endif + using Fun = std::function; + std::map eventIdMap_ { + { RadioEvent::RADIO_PS_CONNECTION_ATTACHED, +diff --git a/services/include/cellular_data_power_improvement_manager.h b/services/include/cellular_data_power_improvement_manager.h +new file mode 100644 +index 00000000..4167b825 +--- /dev/null ++++ b/services/include/cellular_data_power_improvement_manager.h +@@ -0,0 +1,74 @@ ++/* ++ * Copyright (C) 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. ++ */ ++ ++#ifndef DATA_CONNECTION_POWER_STR_MANAGER_H ++#define DATA_CONNECTION_POWER_STR_MANAGER_H ++ ++#include "common_event_subscriber.h" ++#include "system_ability_status_change_stub.h" ++ ++namespace OHOS { ++namespace Telephony { ++class CellularDataHandler; ++class DataConnectionPowerSaveModeSubscriber : public EventFwk::CommonEventSubscriber { ++public: ++ explicit DataConnectionPowerSaveModeSubscriber( ++ const EventFwk::CommonEventSubscribeInfo &info, CellularDataHandler &handler) ++ : CommonEventSubscriber(info), powerSaveModeCellularDataHandler_(handler) {} ++ ~DataConnectionPowerSaveModeSubscriber() = default; ++ void OnReceiveEvent(const EventFwk::CommonEventData &data) override; ++ std::shared_ptr strAsyncCommonEvent_ = nullptr; ++private: ++ void HandleEnterStrEvent(std::string &action); ++ void HandleExitStrEvent(std::string &action); ++ CellularDataHandler &powerSaveModeCellularDataHandler_; ++}; ++ ++class DataConnectionPowerImprovementManager { ++public: ++ DataConnectionPowerImprovementManager(CellularDataHandler &handler) : strCellularDataHandler_(handler) {} ++ ~DataConnectionPowerImprovementManager() = default; ++ bool StartEventSubscriber(bool isDefinedTelePower); ++ void StopEventSubscriber(); ++ static bool GetSavedCellularDataStatus(); ++ static void SetSavedCellularDataStatus(bool value); ++ void FinishPowerStrEnterEvent(); ++ std::shared_ptr strEnterSubscriber_ = nullptr; ++ std::shared_ptr strExitSubscriber_ = nullptr; ++ static inline bool powerSaveFlag_ = false; ++private: ++ std::shared_ptr CreateCommonSubscriber(const std::string &event, ++ int32_t priority); ++private: ++ class SystemAbilityStatusChangeListener : public SystemAbilityStatusChangeStub { ++ public: ++ SystemAbilityStatusChangeListener(std::shared_ptr subStrEnter, ++ std::shared_ptr subStrExit) ++ : strEnterSub_(subStrEnter), strExitSub_(subStrExit) {} ++ ~SystemAbilityStatusChangeListener() = default; ++ void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; ++ void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; ++ private: ++ std::shared_ptr strEnterSub_ = nullptr; ++ std::shared_ptr strExitSub_ = nullptr; ++ }; ++private: ++ static inline bool g_savedCellularDataStatus = true; ++ sptr statusChangeListener_ = nullptr; ++ CellularDataHandler &strCellularDataHandler_; ++}; ++} // namespace Telephony ++} // namespace OHOS ++#endif +\ No newline at end of file +diff --git a/services/src/cellular_data_power_improvement_manager.cpp b/services/src/cellular_data_power_improvement_manager.cpp +new file mode 100644 +index 00000000..7c47e720 +--- /dev/null ++++ b/services/src/cellular_data_power_improvement_manager.cpp +@@ -0,0 +1,189 @@ ++/* ++ * Copyright (C) 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 "cellular_data_power_improvement_manager.h" ++ ++#include "telephony_types.h" ++#include "telephony_log_wrapper.h" ++#include "cellular_data_handler.h" ++ ++namespace OHOS { ++namespace Telephony { ++constexpr const char *PERMISSION_STARTUP_COMPLETED = "ohos.permission.RECEIVER_STARTUP_COMPLETED"; ++std::string lastMsg = ""; ++bool DataConnectionPowerImprovementManager::StartEventSubscriber(bool isDefinedTelePower) ++{ ++ if (!isDefinedTelePower) { ++ TELEPHONY_LOGI("feature_tele_power not define"); ++ return false; ++ } ++ strEnterSubscriber_ = CreateCommonSubscriber(ENTER_STR_TELEPHONY_NOTIFY, CommonEventPriority::FIRST_PRIORITY); ++ strExitSubscriber_ = CreateCommonSubscriber(EXIT_STR_TELEPHONY_NOTIFY, CommonEventPriority::THIRD_PRIORITY); ++ statusChangeListener_ = sptr::MakeSptr(strEnterSubscriber_, strExitSubscriber_); ++ auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); ++ if (samgrProxy == nullptr) { ++ TELEPHONY_LOGE("StartEventSubscriber samgrProxy is nullptr"); ++ return false; ++ } ++ if (samgrProxy->SubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, statusChangeListener_) != TELEPHONY_ERR_SUCCESS) { ++ TELEPHONY_LOGE("SubscribeSystemAbility execute failed"); ++ return false; ++ } ++ return true; ++} ++ ++std::shared_ptr DataConnectionPowerImprovementManager::CreateCommonSubscriber( ++ const std::string &event, int32_t priority) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(event); ++ EventFwk::CommonEventSubscribeInfo subscribeInfo(matchingSkills); ++ subscribeInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON); ++ subscribeInfo.SetPriority(priority); ++ subscribeInfo.SetPermission(PERMISSION_STARTUP_COMPLETED); ++ return std::make_shared(subscribeInfo, strCellularDataHandler_); ++} ++ ++void DataConnectionPowerImprovementManager::StopEventSubscriber() ++{ ++ auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); ++ if (samgrProxy != nullptr) { ++ int32_t ret = samgrProxy->UnSubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, statusChangeListener_); ++ TELEPHONY_LOGI("StopSystemAbilitySubscriber result = %{public}d", ret); ++ statusChangeListener_ = nullptr; ++ } ++ if (strEnterSubscriber_ != nullptr) { ++ bool subscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(strEnterSubscriber_); ++ TELEPHONY_LOGI("StopEventSubscriber result = %{public}d", subscribeResult); ++ strEnterSubscriber_ = nullptr; ++ } ++ if (strExitSubscriber_ != nullptr) { ++ bool subscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(strExitSubscriber_); ++ TELEPHONY_LOGI("StopEventSubscriber result = %{public}d", subscribeResult); ++ strExitSubscriber_ = nullptr; ++ } ++} ++ ++void DataConnectionPowerImprovementManager::SystemAbilityStatusChangeListener::OnAddSystemAbility( ++ int32_t systemAbilityId, const std::string &deviceId) ++{ ++ if (systemAbilityId != COMMON_EVENT_SERVICE_ID) { ++ TELEPHONY_LOGI("systemAbilityId is %{public}d", systemAbilityId); ++ return; ++ } ++ if (strEnterSub_ != nullptr) { ++ bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(strEnterSub_); ++ TELEPHONY_LOGI("strEnterSubscribeResult = %{public}d", subscribeResult); ++ } ++ if (strExitSub_ != nullptr) { ++ bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(strExitSub_); ++ TELEPHONY_LOGI("strExitSubscribeResult = %{public}d", subscribeResult); ++ } ++} ++ ++void DataConnectionPowerImprovementManager::SystemAbilityStatusChangeListener::OnRemoveSystemAbility( ++ int32_t systemAbilityId, const std::string &deviceId) ++{ ++ if (systemAbilityId != COMMON_EVENT_SERVICE_ID) { ++ return; ++ } ++ if (strEnterSub_ != nullptr) { ++ bool subscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(strEnterSub_); ++ TELEPHONY_LOGI("strEnterUnSubscribeResult = %{public}d", subscribeResult); ++ strEnterSub_ = nullptr; ++ } ++ if (strExitSub_ != nullptr) { ++ bool subscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(strExitSub_); ++ TELEPHONY_LOGI("strExitUnSubscribeResult = %{public}d", subscribeResult); ++ strExitSub_ = nullptr; ++ } ++} ++ ++void DataConnectionPowerImprovementManager::FinishPowerStrEnterEvent() ++{ ++ if (strEnterSubscriber_ != nullptr && strEnterSubscriber_->strAsyncCommonEvent_ != nullptr) { ++ bool ret = strEnterSubscriber_->strAsyncCommonEvent_->FinishCommonEvent(); ++ TELEPHONY_LOGI("StrEnter FinishPowerStrEnterEvent result = %{public}d", ret); ++ } ++} ++ ++bool DataConnectionPowerImprovementManager::GetSavedCellularDataStatus() ++{ ++ TELEPHONY_LOGI("Resume cellular status %{public}d", g_savedCellularDataStatus); ++ return g_savedCellularDataStatus; ++} ++ ++void DataConnectionPowerImprovementManager::SetSavedCellularDataStatus(bool value) ++{ ++ g_savedCellularDataStatus = value; ++ TELEPHONY_LOGI("Backup cellular status %{public}d", g_savedCellularDataStatus); ++} ++ ++void DataConnectionPowerSaveModeSubscriber::OnReceiveEvent(const EventFwk::CommonEventData &data) ++{ ++ std::string action = data.GetWant().GetAction(); ++ if (action == ENTER_STR_TELEPHONY_NOTIFY) { ++ TELEPHONY_LOGI("Enter str mode"); ++ HandleEnterStrEvent(action); ++ } else if (action == EXIT_STR_TELEPHONY_NOTIFY) { ++ TELEPHONY_LOGI("Exit str mode"); ++ HandleExitStrEvent(action); ++ } else { ++ TELEPHONY_LOGE("TelPowerSubscriber: action=%{public}s code=%{public}d", action.c_str(), data.GetCode()); ++ } ++} ++ ++void DataConnectionPowerSaveModeSubscriber::HandleEnterStrEvent(std::string &action) ++{ ++ strAsyncCommonEvent_ = this->GoAsyncCommonEvent(); ++ // except same msg ++ if (action != lastMsg) { ++ bool cellularDataStatus = true; ++ int32_t getCellularStatusRet = powerSaveModeCellularDataHandler_.IsCellularDataEnabled(cellularDataStatus); ++ TELEPHONY_LOGI("Get cellular status ret = %{public}d", getCellularStatusRet); ++ DataConnectionPowerImprovementManager::SetSavedCellularDataStatus(cellularDataStatus); ++ // set false in HandleDisconnectDataCompleteForMmsType ++ DataConnectionPowerImprovementManager::powerSaveFlag_ = true; ++ int32_t setCellularDataEnableRet = powerSaveModeCellularDataHandler_.SetCellularDataEnable(false); ++ TELEPHONY_LOGI("Enter str SetCellularDataEnable ret = %{public}d", setCellularDataEnableRet); ++ } else if (strAsyncCommonEvent_ != nullptr) { ++ TELEPHONY_LOGI("Recv same msg in succession lastMsg:%{public}s", lastMsg.c_str()); ++ bool ret = strAsyncCommonEvent_->FinishCommonEvent(); ++ TELEPHONY_LOGI("StrEnter FinishPowerStrEnterEvent ret = %{public}d", ret); ++ } ++ lastMsg = ENTER_STR_TELEPHONY_NOTIFY; ++} ++ ++void DataConnectionPowerSaveModeSubscriber::HandleExitStrEvent(std::string &action) ++{ ++ strAsyncCommonEvent_ = this->GoAsyncCommonEvent(); ++ if (action != lastMsg) { ++ // reply common event firt due to activate cellular too slow ++ if (strAsyncCommonEvent_ != nullptr) { ++ bool result = strAsyncCommonEvent_->FinishCommonEvent(); ++ TELEPHONY_LOGI("StrExit FinishPowerStrExitEvent result = %{public}d", result); ++ } ++ bool savedCellularDataStatus = DataConnectionPowerImprovementManager::GetSavedCellularDataStatus(); ++ int32_t ret = powerSaveModeCellularDataHandler_.SetCellularDataEnable(savedCellularDataStatus); ++ TELEPHONY_LOGI("Exit str SetCellularDataEnable ret = %{public}d", ret); ++ } else if (strAsyncCommonEvent_ != nullptr) { ++ TELEPHONY_LOGI("Recv same msg in succession lastMsg:%{public}s", lastMsg.c_str()); ++ bool ret = strAsyncCommonEvent_->FinishCommonEvent(); ++ TELEPHONY_LOGI("StrExit FinishPowerStrExitEvent ret = %{public}d", ret); ++ } ++ lastMsg = EXIT_STR_TELEPHONY_NOTIFY; ++} ++} // namespace Telephony ++} // namespace OHOS +\ No newline at end of file +diff --git a/test/BUILD.gn b/test/BUILD.gn +index b569d076..b5805aa6 100644 +--- a/test/BUILD.gn ++++ b/test/BUILD.gn +@@ -27,6 +27,7 @@ ohos_unittest("tel_cellular_data_test") { + "$SOURCE_DIR/test/data_access_token.cpp", + "$SOURCE_DIR/test/zero_branch_test.cpp", + "$SOURCE_DIR/test/net_manager_call_back_test.cpp", ++ "$SOURCE_DIR/test/cellular_data_power_improvement_manager_test.cpp", + ] + + include_dirs = [ +diff --git a/test/cellular_data_handler_test.cpp b/test/cellular_data_handler_test.cpp +index 1971ee0f..5ef3d1a8 100644 +--- a/test/cellular_data_handler_test.cpp ++++ b/test/cellular_data_handler_test.cpp +@@ -22,6 +22,9 @@ + #include "cellular_data_constant.h" + #include "cellular_data_handler.h" + #include "cellular_data_controller.h" ++#ifdef BASE_POWER_IMPROVEMENT ++#include "cellular_data_power_improvement_manager.h" ++#endif + + namespace OHOS { + namespace Telephony { +@@ -631,5 +634,27 @@ HWTEST_F(CellularDataHandlerTest, IsCellularDataEnabledTest001, Function | Mediu + cellularDataHandler->dataSwitchSettings_->lastQryRet_ = TELEPHONY_ERR_SUCCESS; + EXPECT_EQ(cellularDataHandler->IsCellularDataEnabled(isDataEnabled), TELEPHONY_ERR_SUCCESS); + } ++ ++/** ++@tc.number Telephony_HandleDisconnectDataCompleteForMmsType ++@tc.name HandleDisconnectDataCompleteForMmsType ++@tc.desc Function test ++*/ ++#ifdef BASE_POWER_IMPROVEMENT ++HWTEST_F(CellularDataHandlerTest, HandleDisconnectDataCompleteForMmsTypeTest001, Function | MediumTest | Level1) ++{ ++ int32_t slotId = 0; ++ EventFwk::MatchingSkills matchingSkills; ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = std::make_shared(subscriberInfo, slotId); ++ cellularDataHandler->Init(); ++ EXPECT_NE(cellularDataHandler->dataConnectionPowerImprovementManager_, nullptr); ++ DataConnectionPowerImprovementManager::powerSaveFlag_ = true; ++ std::string apnType = DATA_CONTEXT_ROLE_MMS; ++ sptr apnHolder = new ApnHolder(apnType, slotId); ++ cellularDataHandler->HandleDisconnectDataCompleteForMmsType(apnHolder); ++ EXPECT_EQ(DataConnectionPowerImprovementManager::powerSaveFlag_, false); ++} ++#endif + } // namespace Telephony + } // namespace OHOS +\ No newline at end of file +diff --git a/test/cellular_data_power_improvement_manager_test.cpp b/test/cellular_data_power_improvement_manager_test.cpp +new file mode 100644 +index 00000000..30094755 +--- /dev/null ++++ b/test/cellular_data_power_improvement_manager_test.cpp +@@ -0,0 +1,277 @@ ++/* ++ * Copyright (C) 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. ++ */ ++#define private public ++#define protected public ++ ++#include "cellular_data_power_improvement_manager.h" ++ ++#include "gtest/gtest.h" ++#include "common_event_support.h" ++#include "cellular_data_handler.h" ++ ++namespace OHOS { ++namespace Telephony { ++using namespace testing::ext; ++class DataConnectionPowerImprovementManagerTest : public testing::Test { ++public: ++ static void SetUpTestCase() {} ++ static void TearDownTestCase() {} ++ void SetUp() {} ++ void TearDown() {} ++}; ++ ++HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_01, ++ Function | MediumTest | Level1) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); ++ auto dataConnectionPowerImprovementManager = ++ std::make_shared(cellularDataHandler); ++ bool isDefinedTelePower = true; ++ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); ++ EXPECT_NE(dataConnectionPowerImprovementManager->strEnterSubscriber_, nullptr); ++ EXPECT_NE(dataConnectionPowerImprovementManager->strExitSubscriber_, nullptr); ++ dataConnectionPowerImprovementManager->StopEventSubscriber(); ++ EXPECT_EQ(dataConnectionPowerImprovementManager->strEnterSubscriber_, nullptr); ++ EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_, nullptr); ++} ++HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_02, ++ Function | MediumTest | Level1) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); ++ auto dataConnectionPowerImprovementManager = ++ std::make_shared(cellularDataHandler); ++ bool isDefinedTelePower = true; ++ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); ++ auto want = EventFwk::Want(); ++ want.SetAction(ENTER_STR_TELEPHONY_NOTIFY); ++ auto event = EventFwk::CommonEventData(want); ++ dataConnectionPowerImprovementManager->strEnterSubscriber_->OnReceiveEvent(event); ++ EXPECT_EQ(dataConnectionPowerImprovementManager->strEnterSubscriber_->strAsyncCommonEvent_, nullptr); ++} ++ ++HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_03, ++ Function | MediumTest | Level1) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); ++ auto dataConnectionPowerImprovementManager = ++ std::make_shared(cellularDataHandler); ++ bool isDefinedTelePower = true; ++ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); ++ auto want = EventFwk::Want(); ++ want.SetAction(EXIT_STR_TELEPHONY_NOTIFY); ++ auto event = EventFwk::CommonEventData(want); ++ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); ++ EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); ++} ++ ++HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_04, ++ Function | MediumTest | Level1) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); ++ auto dataConnectionPowerImprovementManager = ++ std::make_shared(cellularDataHandler); ++ bool isDefinedTelePower = true; ++ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); ++ auto want = EventFwk::Want(); ++ want.SetAction(ENTER_STR_TELEPHONY_NOTIFY); ++ auto event = EventFwk::CommonEventData(want); ++ DataConnectionPowerImprovementManager::SetSavedCellularDataStatus(false); ++ dataConnectionPowerImprovementManager->strEnterSubscriber_->OnReceiveEvent(event); ++ EXPECT_EQ(dataConnectionPowerImprovementManager->strEnterSubscriber_->strAsyncCommonEvent_, nullptr); ++} ++ ++HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_05, ++ Function | MediumTest | Level1) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); ++ auto dataConnectionPowerImprovementManager = ++ std::make_shared(cellularDataHandler); ++ bool isDefinedTelePower = true; ++ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); ++ auto want = EventFwk::Want(); ++ want.SetAction(EXIT_STR_TELEPHONY_NOTIFY); ++ auto event = EventFwk::CommonEventData(want); ++ dataConnectionPowerImprovementManager->strEnterSubscriber_->OnReceiveEvent(event); ++ EXPECT_EQ(dataConnectionPowerImprovementManager->strEnterSubscriber_->strAsyncCommonEvent_, nullptr); ++} ++ ++HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_06, ++ Function | MediumTest | Level1) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); ++ auto dataConnectionPowerImprovementManager = ++ std::make_shared(cellularDataHandler); ++ bool isDefinedTelePower = true; ++ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); ++ auto want = EventFwk::Want(); ++ want.SetAction(EXIT_STR_TELEPHONY_NOTIFY); ++ auto event = EventFwk::CommonEventData(want); ++ DataConnectionPowerImprovementManager::SetSavedCellularDataStatus(false); ++ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); ++ EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); ++} ++ ++HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_07, ++ Function | MediumTest | Level1) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); ++ auto dataConnectionPowerImprovementManager = ++ std::make_shared(cellularDataHandler); ++ bool isDefinedTelePower = true; ++ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); ++ auto want = EventFwk::Want(); ++ want.SetAction(ENTER_STR_TELEPHONY_NOTIFY); ++ auto event = EventFwk::CommonEventData(want); ++ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); ++ EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); ++} ++ ++HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_08, ++ Function | MediumTest | Level1) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); ++ auto dataConnectionPowerImprovementManager = ++ std::make_shared(cellularDataHandler); ++ dataConnectionPowerImprovementManager->statusChangeListener_ = ++ new (std::nothrow) DataConnectionPowerImprovementManager::SystemAbilityStatusChangeListener(nullptr, nullptr); ++ dataConnectionPowerImprovementManager->statusChangeListener_->OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, ++ "test_device"); ++} ++ ++HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_09, ++ Function | MediumTest | Level1) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); ++ auto dataConnectionPowerImprovementManager = ++ std::make_shared(cellularDataHandler); ++ bool isDefinedTelePower = true; ++ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); ++ dataConnectionPowerImprovementManager->statusChangeListener_->OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, ++ "test_device"); ++} ++ ++HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_10, ++ Function | MediumTest | Level1) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); ++ auto dataConnectionPowerImprovementManager = ++ std::make_shared(cellularDataHandler); ++ bool isDefinedTelePower = true; ++ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); ++ dataConnectionPowerImprovementManager->statusChangeListener_->OnRemoveSystemAbility(SCREENLOCK_SERVICE_ID, ++ "test_device"); ++} ++ ++HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_11, ++ Function | MediumTest | Level1) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); ++ auto dataConnectionPowerImprovementManager = ++ std::make_shared(cellularDataHandler); ++ dataConnectionPowerImprovementManager->SetSavedCellularDataStatus(false); ++ bool ret = dataConnectionPowerImprovementManager->GetSavedCellularDataStatus(); ++ EXPECT_EQ(ret, false); ++} ++HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_12, ++ Function | MediumTest | Level1) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); ++ auto dataConnectionPowerImprovementManager = ++ std::make_shared(cellularDataHandler); ++ bool isDefinedTelePower = true; ++ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); ++ auto want = EventFwk::Want(); ++ want.SetAction(ENTER_STR_TELEPHONY_NOTIFY); ++ auto event = EventFwk::CommonEventData(want); ++ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); ++ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); ++ EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); ++} ++ ++HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_13, ++ Function | MediumTest | Level1) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); ++ auto dataConnectionPowerImprovementManager = ++ std::make_shared(cellularDataHandler); ++ bool isDefinedTelePower = true; ++ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); ++ auto want = EventFwk::Want(); ++ want.SetAction(EXIT_STR_TELEPHONY_NOTIFY); ++ auto event = EventFwk::CommonEventData(want); ++ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); ++ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); ++ EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); ++} ++ ++HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_14, ++ Function | MediumTest | Level1) ++{ ++ EventFwk::MatchingSkills matchingSkills; ++ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); ++ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); ++ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); ++ auto dataConnectionPowerImprovementManager = ++ std::make_shared(cellularDataHandler); ++ bool isDefinedTelePower = true; ++ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); ++ auto want = EventFwk::Want(); ++ want.SetAction(TEL_EMC_RESCUE_MODE_STATUS); ++ auto event = EventFwk::CommonEventData(want); ++ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); ++ EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); ++} ++} ++} ++// #endif +\ No newline at end of file +-- +2.45.2.huawei.10 + diff --git a/BUILD.gn b/BUILD.gn index cdc8fae7..8e114ab2 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -32,6 +32,10 @@ if (defined(global_parts_info) && TELEPHONY_EXT_WRAPPER_ROOT = "services/telephony_ext_wrapper" DATA_SERVICE_EXT_WRAPPER_ROOT = "services/data_service_ext_wrapper" +declare_args() { + cellular_data_feature_base_power_improvement = false +} + ohos_shared_library("tel_cellular_data") { sanitize = { cfi = true @@ -81,6 +85,12 @@ ohos_shared_library("tel_cellular_data") { "services/src/utils/network_search_callback.cpp", ] + if (cellular_data_feature_base_power_improvement ) { + sources += [ + "services/src/cellular_data_power_improvement_manager.cpp", + ] + } + include_dirs = [ "$TELEPHONY_EXT_WRAPPER_ROOT/include", "$DATA_SERVICE_EXT_WRAPPER_ROOT/include", @@ -142,6 +152,10 @@ ohos_shared_library("tel_cellular_data") { defines += [ "HICOLLIE_ENABLE" ] } + if (cellular_data_feature_base_power_improvement ) { + defines += [ "BASE_POWER_IMPROVEMENT" ] + } + if (defined(global_parts_info) && defined(global_parts_info.communication_netmanager_enhanced)) { defines += [ "OHOS_BUILD_ENABLE_DATA_SERVICE_EXT" ] @@ -201,6 +215,12 @@ ohos_static_library("tel_cellular_data_static") { "services/src/utils/network_search_callback.cpp", ] + if (cellular_data_feature_base_power_improvement ) { + sources += [ + "services/src/cellular_data_power_improvement_manager.cpp", + ] + } + include_dirs = [ "$TELEPHONY_EXT_WRAPPER_ROOT/include", "$DATA_SERVICE_EXT_WRAPPER_ROOT/include", @@ -262,6 +282,10 @@ ohos_static_library("tel_cellular_data_static") { defines += [ "HICOLLIE_ENABLE" ] } + if (cellular_data_feature_base_power_improvement ) { + defines += [ "BASE_POWER_IMPROVEMENT" ] + } + if (defined(global_parts_info) && defined(global_parts_info.communication_netmanager_enhanced)) { defines += [ "OHOS_BUILD_ENABLE_DATA_SERVICE_EXT" ] diff --git a/bundle.json b/bundle.json index cad08daa..9c01c939 100644 --- a/bundle.json +++ b/bundle.json @@ -23,7 +23,8 @@ "SystemCapability.Telephony.CellularData" ], "features": [ - "cellular_data_dynamic_start" + "cellular_data_dynamic_start", + "cellular_data_feature_base_power_improvement" ], "adapted_system_type": [ "standard" diff --git a/frameworks/js/napi/src/cellular_data_handler.cpp b/frameworks/js/napi/src/cellular_data_handler.cpp index e736a4da..5faba673 100644 --- a/frameworks/js/napi/src/cellular_data_handler.cpp +++ b/frameworks/js/napi/src/cellular_data_handler.cpp @@ -76,6 +76,12 @@ void CellularDataHandler::Init() dataSwitchSettings_->LoadSwitchValue(); GetConfigurationFor5G(); SetRilLinkBandwidths(); +#ifdef BASE_POWER_IMPROVEMENT + dataConnectionPowerImprovementManager_ = std::make_shared(*this); + bool isDefinedTelePower = system::GetBoolParameter("const.vendor.ril.power.feature_tele_power", false); + bool ret = dataConnectionPowerImprovementManager_->StartEventSubscriber(isDefinedTelePower); + TELEPHONY_LOGI("Subscribe ordered broadcast succ ret = %{public}d", ret); +#endif } CellularDataHandler::~CellularDataHandler() {} @@ -1058,6 +1064,12 @@ void CellularDataHandler::HandleDisconnectDataCompleteForMmsType(sptr SetDataPermittedForMms(false); RemoveEvent(CellularDataEventCode::MSG_RESUME_DATA_PERMITTED_TIMEOUT); } +#ifdef BASE_POWER_IMPROVEMENT + if (dataConnectionPowerImprovementManager_ != nullptr && DataConnectionPowerImprovementManager::powerSaveFlag_) { + dataConnectionPowerImprovementManager_->FinishPowerStrEnterEvent(); + DataConnectionPowerImprovementManager::powerSaveFlag_ = false; + } +#endif } void CellularDataHandler::RetryOrClearConnection(const sptr &apnHolder, DisConnectionReason reason, diff --git a/services/include/cellular_data_handler.h b/services/include/cellular_data_handler.h index 277fbdc9..ef77d772 100644 --- a/services/include/cellular_data_handler.h +++ b/services/include/cellular_data_handler.h @@ -38,9 +38,11 @@ #include "tel_profile_util.h" #include "tel_ril_data_parcel.h" #include "telephony_types.h" + namespace OHOS { namespace Telephony { const uint32_t KEEP_APN_ACTIVATE_PERIOD = 30 * 1000; +class DataConnectionPowerImprovementManager; class CellularDataHandler : public TelEventHandler, public EventFwk::CommonEventSubscriber { public: explicit CellularDataHandler(const EventFwk::CommonEventSubscribeInfo &sp, int32_t slotId); @@ -224,7 +226,9 @@ private: uint64_t defaultApnActTime_ = 0; uint64_t internalApnActTime_ = 0; int32_t retryCreateApnTimes_ = 0; - +#ifdef BASE_POWER_IMPROVEMENT + std::shared_ptr dataConnectionPowerImprovementManager_ = nullptr; +#endif using Fun = std::function; std::map eventIdMap_ { { RadioEvent::RADIO_PS_CONNECTION_ATTACHED, diff --git a/services/include/cellular_data_power_improvement_manager.h b/services/include/cellular_data_power_improvement_manager.h new file mode 100644 index 00000000..de1a3d97 --- /dev/null +++ b/services/include/cellular_data_power_improvement_manager.h @@ -0,0 +1,74 @@ +/* + * Copyright (C) 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. + */ + +#ifndef DATA_CONNECTION_POWER_STR_MANAGER_H +#define DATA_CONNECTION_POWER_STR_MANAGER_H + +#include "common_event_subscriber.h" +#include "system_ability_status_change_stub.h" + +namespace OHOS { +namespace Telephony { +class CellularDataHandler; +class DataConnectionPowerSaveModeSubscriber : public EventFwk::CommonEventSubscriber { +public: + explicit DataConnectionPowerSaveModeSubscriber( + const EventFwk::CommonEventSubscribeInfo &info, CellularDataHandler &handler) + : CommonEventSubscriber(info), powerSaveModeCellularDataHandler_(handler) {} + ~DataConnectionPowerSaveModeSubscriber() = default; + void OnReceiveEvent(const EventFwk::CommonEventData &data) override; + std::shared_ptr strAsyncCommonEvent_ = nullptr; +private: + void HandleEnterStrEvent(std::string &action); + void HandleExitStrEvent(std::string &action); + CellularDataHandler &powerSaveModeCellularDataHandler_; +}; + +class DataConnectionPowerImprovementManager { +public: + DataConnectionPowerImprovementManager(CellularDataHandler &handler) : strCellularDataHandler_(handler) {} + ~DataConnectionPowerImprovementManager() = default; + bool StartEventSubscriber(bool isDefinedTelePower); + void StopEventSubscriber(); + static bool GetSavedCellularDataStatus(); + static void SetSavedCellularDataStatus(bool value); + void FinishPowerStrEnterEvent(); + std::shared_ptr strEnterSubscriber_ = nullptr; + std::shared_ptr strExitSubscriber_ = nullptr; + static inline bool powerSaveFlag_ = false; +private: + std::shared_ptr CreateCommonSubscriber(const std::string &event, + int32_t priority); +private: + class SystemAbilityStatusChangeListener : public SystemAbilityStatusChangeStub { + public: + SystemAbilityStatusChangeListener(std::shared_ptr subStrEnter, + std::shared_ptr subStrExit) + : strEnterSub_(subStrEnter), strExitSub_(subStrExit) {} + ~SystemAbilityStatusChangeListener() = default; + void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; + void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; + private: + std::shared_ptr strEnterSub_ = nullptr; + std::shared_ptr strExitSub_ = nullptr; + }; +private: + static inline bool g_savedCellularDataStatus = true; + sptr statusChangeListener_ = nullptr; + CellularDataHandler &strCellularDataHandler_; +}; +} // namespace Telephony +} // namespace OHOS +#endif \ No newline at end of file diff --git a/services/src/cellular_data_power_improvement_manager.cpp b/services/src/cellular_data_power_improvement_manager.cpp new file mode 100644 index 00000000..ae3358f1 --- /dev/null +++ b/services/src/cellular_data_power_improvement_manager.cpp @@ -0,0 +1,189 @@ +/* + * Copyright (C) 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 "cellular_data_power_improvement_manager.h" + +#include "telephony_types.h" +#include "telephony_log_wrapper.h" +#include "cellular_data_handler.h" + +namespace OHOS { +namespace Telephony { +constexpr const char *PERMISSION_STARTUP_COMPLETED = "ohos.permission.RECEIVER_STARTUP_COMPLETED"; +std::string lastMsg = ""; +bool DataConnectionPowerImprovementManager::StartEventSubscriber(bool isDefinedTelePower) +{ + if (!isDefinedTelePower) { + TELEPHONY_LOGI("feature_tele_power not define"); + return false; + } + strEnterSubscriber_ = CreateCommonSubscriber(ENTER_STR_TELEPHONY_NOTIFY, CommonEventPriority::FIRST_PRIORITY); + strExitSubscriber_ = CreateCommonSubscriber(EXIT_STR_TELEPHONY_NOTIFY, CommonEventPriority::THIRD_PRIORITY); + statusChangeListener_ = sptr::MakeSptr(strEnterSubscriber_, strExitSubscriber_); + auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (samgrProxy == nullptr) { + TELEPHONY_LOGE("StartEventSubscriber samgrProxy is nullptr"); + return false; + } + if (samgrProxy->SubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, statusChangeListener_) != TELEPHONY_ERR_SUCCESS) { + TELEPHONY_LOGE("SubscribeSystemAbility execute failed"); + return false; + } + return true; +} + +std::shared_ptr DataConnectionPowerImprovementManager::CreateCommonSubscriber( + const std::string &event, int32_t priority) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(event); + EventFwk::CommonEventSubscribeInfo subscribeInfo(matchingSkills); + subscribeInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON); + subscribeInfo.SetPriority(priority); + subscribeInfo.SetPermission(PERMISSION_STARTUP_COMPLETED); + return std::make_shared(subscribeInfo, strCellularDataHandler_); +} + +void DataConnectionPowerImprovementManager::StopEventSubscriber() +{ + auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (samgrProxy != nullptr) { + int32_t ret = samgrProxy->UnSubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, statusChangeListener_); + TELEPHONY_LOGI("StopSystemAbilitySubscriber result = %{public}d", ret); + statusChangeListener_ = nullptr; + } + if (strEnterSubscriber_ != nullptr) { + bool subscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(strEnterSubscriber_); + TELEPHONY_LOGI("StopEventSubscriber result = %{public}d", subscribeResult); + strEnterSubscriber_ = nullptr; + } + if (strExitSubscriber_ != nullptr) { + bool subscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(strExitSubscriber_); + TELEPHONY_LOGI("StopEventSubscriber result = %{public}d", subscribeResult); + strExitSubscriber_ = nullptr; + } +} + +void DataConnectionPowerImprovementManager::SystemAbilityStatusChangeListener::OnAddSystemAbility( + int32_t systemAbilityId, const std::string &deviceId) +{ + if (systemAbilityId != COMMON_EVENT_SERVICE_ID) { + TELEPHONY_LOGI("systemAbilityId is %{public}d", systemAbilityId); + return; + } + if (strEnterSub_ != nullptr) { + bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(strEnterSub_); + TELEPHONY_LOGI("strEnterSubscribeResult = %{public}d", subscribeResult); + } + if (strExitSub_ != nullptr) { + bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(strExitSub_); + TELEPHONY_LOGI("strExitSubscribeResult = %{public}d", subscribeResult); + } +} + +void DataConnectionPowerImprovementManager::SystemAbilityStatusChangeListener::OnRemoveSystemAbility( + int32_t systemAbilityId, const std::string &deviceId) +{ + if (systemAbilityId != COMMON_EVENT_SERVICE_ID) { + return; + } + if (strEnterSub_ != nullptr) { + bool subscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(strEnterSub_); + TELEPHONY_LOGI("strEnterUnSubscribeResult = %{public}d", subscribeResult); + strEnterSub_ = nullptr; + } + if (strExitSub_ != nullptr) { + bool subscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(strExitSub_); + TELEPHONY_LOGI("strExitUnSubscribeResult = %{public}d", subscribeResult); + strExitSub_ = nullptr; + } +} + +void DataConnectionPowerImprovementManager::FinishPowerStrEnterEvent() +{ + if (strEnterSubscriber_ != nullptr && strEnterSubscriber_->strAsyncCommonEvent_ != nullptr) { + bool ret = strEnterSubscriber_->strAsyncCommonEvent_->FinishCommonEvent(); + TELEPHONY_LOGI("StrEnter FinishPowerStrEnterEvent result = %{public}d", ret); + } +} + +bool DataConnectionPowerImprovementManager::GetSavedCellularDataStatus() +{ + TELEPHONY_LOGI("Resume cellular status %{public}d", g_savedCellularDataStatus); + return g_savedCellularDataStatus; +} + +void DataConnectionPowerImprovementManager::SetSavedCellularDataStatus(bool value) +{ + g_savedCellularDataStatus = value; + TELEPHONY_LOGI("Backup cellular status %{public}d", g_savedCellularDataStatus); +} + +void DataConnectionPowerSaveModeSubscriber::OnReceiveEvent(const EventFwk::CommonEventData &data) +{ + std::string action = data.GetWant().GetAction(); + if (action == ENTER_STR_TELEPHONY_NOTIFY) { + TELEPHONY_LOGI("Enter str mode"); + HandleEnterStrEvent(action); + } else if (action == EXIT_STR_TELEPHONY_NOTIFY) { + TELEPHONY_LOGI("Exit str mode"); + HandleExitStrEvent(action); + } else { + TELEPHONY_LOGE("TelPowerSubscriber: action=%{public}s code=%{public}d", action.c_str(), data.GetCode()); + } +} + +void DataConnectionPowerSaveModeSubscriber::HandleEnterStrEvent(std::string &action) +{ + strAsyncCommonEvent_ = this->GoAsyncCommonEvent(); + // except same msg + if (action != lastMsg) { + bool cellularDataStatus = true; + int32_t getCellularStatusRet = powerSaveModeCellularDataHandler_.IsCellularDataEnabled(cellularDataStatus); + TELEPHONY_LOGI("Get cellular status ret = %{public}d", getCellularStatusRet); + DataConnectionPowerImprovementManager::SetSavedCellularDataStatus(cellularDataStatus); + // set false in HandleDisconnectDataCompleteForMmsType + DataConnectionPowerImprovementManager::powerSaveFlag_ = true; + int32_t setCellularDataEnableRet = powerSaveModeCellularDataHandler_.SetCellularDataEnable(false); + TELEPHONY_LOGI("Enter str SetCellularDataEnable ret = %{public}d", setCellularDataEnableRet); + } else if (strAsyncCommonEvent_ != nullptr) { + TELEPHONY_LOGI("Recv same msg in succession lastMsg:%{public}s", lastMsg.c_str()); + bool ret = strAsyncCommonEvent_->FinishCommonEvent(); + TELEPHONY_LOGI("StrEnter FinishPowerStrEnterEvent ret = %{public}d", ret); + } + lastMsg = ENTER_STR_TELEPHONY_NOTIFY; +} + +void DataConnectionPowerSaveModeSubscriber::HandleExitStrEvent(std::string &action) +{ + strAsyncCommonEvent_ = this->GoAsyncCommonEvent(); + if (action != lastMsg) { + // reply common event firt due to activate cellular too slow + if (strAsyncCommonEvent_ != nullptr) { + bool result = strAsyncCommonEvent_->FinishCommonEvent(); + TELEPHONY_LOGI("StrExit FinishPowerStrExitEvent result = %{public}d", result); + } + bool savedCellularDataStatus = DataConnectionPowerImprovementManager::GetSavedCellularDataStatus(); + int32_t ret = powerSaveModeCellularDataHandler_.SetCellularDataEnable(savedCellularDataStatus); + TELEPHONY_LOGI("Exit str SetCellularDataEnable ret = %{public}d", ret); + } else if (strAsyncCommonEvent_ != nullptr) { + TELEPHONY_LOGI("Recv same msg in succession lastMsg:%{public}s", lastMsg.c_str()); + bool ret = strAsyncCommonEvent_->FinishCommonEvent(); + TELEPHONY_LOGI("StrExit FinishPowerStrExitEvent ret = %{public}d", ret); + } + lastMsg = EXIT_STR_TELEPHONY_NOTIFY; +} +} // namespace Telephony +} // namespace OHOS \ No newline at end of file diff --git a/test/BUILD.gn b/test/BUILD.gn index d8c4f997..631fe52e 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -27,6 +27,7 @@ ohos_unittest("tel_cellular_data_test") { "$SOURCE_DIR/test/data_access_token.cpp", "$SOURCE_DIR/test/zero_branch_test.cpp", "$SOURCE_DIR/test/net_manager_call_back_test.cpp", + "$SOURCE_DIR/test/cellular_data_power_improvement_manager_test.cpp", ] include_dirs = [ diff --git a/test/cellular_data_handler_test.cpp b/test/cellular_data_handler_test.cpp index 0294f240..738ca0f2 100644 --- a/test/cellular_data_handler_test.cpp +++ b/test/cellular_data_handler_test.cpp @@ -20,6 +20,9 @@ #include "common_event_support.h" #include "cellular_data_handler.h" #include "cellular_data_controller.h" +#ifdef BASE_POWER_IMPROVEMENT +#include "cellular_data_power_improvement_manager.h" +#endif namespace OHOS { namespace Telephony { @@ -1159,5 +1162,27 @@ HWTEST_F(CellularDataHandlerTest, IsCellularDataEnabledTest001, Function | Mediu cellularDataHandler->dataSwitchSettings_->lastQryRet_ = TELEPHONY_ERR_SUCCESS; EXPECT_EQ(cellularDataHandler->IsCellularDataEnabled(isDataEnabled), TELEPHONY_ERR_SUCCESS); } + +/** +@tc.number Telephony_HandleDisconnectDataCompleteForMmsType +@tc.name HandleDisconnectDataCompleteForMmsType +@tc.desc Function test +*/ +#ifdef BASE_POWER_IMPROVEMENT +HWTEST_F(CellularDataHandlerTest, HandleDisconnectDataCompleteForMmsTypeTest001, Function | MediumTest | Level1) +{ + int32_t slotId = 0; + EventFwk::MatchingSkills matchingSkills; + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = std::make_shared(subscriberInfo, slotId); + cellularDataHandler->Init(); + EXPECT_NE(cellularDataHandler->dataConnectionPowerImprovementManager_, nullptr); + DataConnectionPowerImprovementManager::powerSaveFlag_ = true; + std::string apnType = DATA_CONTEXT_ROLE_MMS; + sptr apnHolder = new ApnHolder(apnType, slotId); + cellularDataHandler->HandleDisconnectDataCompleteForMmsType(apnHolder); + EXPECT_EQ(DataConnectionPowerImprovementManager::powerSaveFlag_, false); +} +#endif } // namespace Telephony } // namespace OHOS \ No newline at end of file diff --git a/test/cellular_data_power_improvement_manager_test.cpp b/test/cellular_data_power_improvement_manager_test.cpp new file mode 100644 index 00000000..6d6cf207 --- /dev/null +++ b/test/cellular_data_power_improvement_manager_test.cpp @@ -0,0 +1,277 @@ +/* + * Copyright (C) 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. + */ +#define private public +#define protected public + +#include "cellular_data_power_improvement_manager.h" + +#include "gtest/gtest.h" +#include "common_event_support.h" +#include "cellular_data_handler.h" + +namespace OHOS { +namespace Telephony { +using namespace testing::ext; +class DataConnectionPowerImprovementManagerTest : public testing::Test { +public: + static void SetUpTestCase() {} + static void TearDownTestCase() {} + void SetUp() {} + void TearDown() {} +}; + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_01, + Function | MediumTest | Level1) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); + auto dataConnectionPowerImprovementManager = + std::make_shared(cellularDataHandler); + bool isDefinedTelePower = true; + dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); + EXPECT_NE(dataConnectionPowerImprovementManager->strEnterSubscriber_, nullptr); + EXPECT_NE(dataConnectionPowerImprovementManager->strExitSubscriber_, nullptr); + dataConnectionPowerImprovementManager->StopEventSubscriber(); + EXPECT_EQ(dataConnectionPowerImprovementManager->strEnterSubscriber_, nullptr); + EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_, nullptr); +} +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_02, + Function | MediumTest | Level1) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); + auto dataConnectionPowerImprovementManager = + std::make_shared(cellularDataHandler); + bool isDefinedTelePower = true; + dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); + auto want = EventFwk::Want(); + want.SetAction(ENTER_STR_TELEPHONY_NOTIFY); + auto event = EventFwk::CommonEventData(want); + dataConnectionPowerImprovementManager->strEnterSubscriber_->OnReceiveEvent(event); + EXPECT_EQ(dataConnectionPowerImprovementManager->strEnterSubscriber_->strAsyncCommonEvent_, nullptr); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_03, + Function | MediumTest | Level1) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); + auto dataConnectionPowerImprovementManager = + std::make_shared(cellularDataHandler); + bool isDefinedTelePower = true; + dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); + auto want = EventFwk::Want(); + want.SetAction(EXIT_STR_TELEPHONY_NOTIFY); + auto event = EventFwk::CommonEventData(want); + dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); + EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_04, + Function | MediumTest | Level1) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); + auto dataConnectionPowerImprovementManager = + std::make_shared(cellularDataHandler); + bool isDefinedTelePower = true; + dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); + auto want = EventFwk::Want(); + want.SetAction(ENTER_STR_TELEPHONY_NOTIFY); + auto event = EventFwk::CommonEventData(want); + DataConnectionPowerImprovementManager::SetSavedCellularDataStatus(false); + dataConnectionPowerImprovementManager->strEnterSubscriber_->OnReceiveEvent(event); + EXPECT_EQ(dataConnectionPowerImprovementManager->strEnterSubscriber_->strAsyncCommonEvent_, nullptr); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_05, + Function | MediumTest | Level1) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); + auto dataConnectionPowerImprovementManager = + std::make_shared(cellularDataHandler); + bool isDefinedTelePower = true; + dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); + auto want = EventFwk::Want(); + want.SetAction(EXIT_STR_TELEPHONY_NOTIFY); + auto event = EventFwk::CommonEventData(want); + dataConnectionPowerImprovementManager->strEnterSubscriber_->OnReceiveEvent(event); + EXPECT_EQ(dataConnectionPowerImprovementManager->strEnterSubscriber_->strAsyncCommonEvent_, nullptr); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_06, + Function | MediumTest | Level1) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); + auto dataConnectionPowerImprovementManager = + std::make_shared(cellularDataHandler); + bool isDefinedTelePower = true; + dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); + auto want = EventFwk::Want(); + want.SetAction(EXIT_STR_TELEPHONY_NOTIFY); + auto event = EventFwk::CommonEventData(want); + DataConnectionPowerImprovementManager::SetSavedCellularDataStatus(false); + dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); + EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_07, + Function | MediumTest | Level1) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); + auto dataConnectionPowerImprovementManager = + std::make_shared(cellularDataHandler); + bool isDefinedTelePower = true; + dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); + auto want = EventFwk::Want(); + want.SetAction(ENTER_STR_TELEPHONY_NOTIFY); + auto event = EventFwk::CommonEventData(want); + dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); + EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_08, + Function | MediumTest | Level1) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); + auto dataConnectionPowerImprovementManager = + std::make_shared(cellularDataHandler); + dataConnectionPowerImprovementManager->statusChangeListener_ = + new (std::nothrow) DataConnectionPowerImprovementManager::SystemAbilityStatusChangeListener(nullptr, nullptr); + dataConnectionPowerImprovementManager->statusChangeListener_->OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, + "test_device"); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_09, + Function | MediumTest | Level1) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); + auto dataConnectionPowerImprovementManager = + std::make_shared(cellularDataHandler); + bool isDefinedTelePower = true; + dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); + dataConnectionPowerImprovementManager->statusChangeListener_->OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, + "test_device"); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_10, + Function | MediumTest | Level1) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); + auto dataConnectionPowerImprovementManager = + std::make_shared(cellularDataHandler); + bool isDefinedTelePower = true; + dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); + dataConnectionPowerImprovementManager->statusChangeListener_->OnRemoveSystemAbility(SCREENLOCK_SERVICE_ID, + "test_device"); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_11, + Function | MediumTest | Level1) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); + auto dataConnectionPowerImprovementManager = + std::make_shared(cellularDataHandler); + dataConnectionPowerImprovementManager->SetSavedCellularDataStatus(false); + bool ret = dataConnectionPowerImprovementManager->GetSavedCellularDataStatus(); + EXPECT_EQ(ret, false); +} +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_12, + Function | MediumTest | Level1) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); + auto dataConnectionPowerImprovementManager = + std::make_shared(cellularDataHandler); + bool isDefinedTelePower = true; + dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); + auto want = EventFwk::Want(); + want.SetAction(ENTER_STR_TELEPHONY_NOTIFY); + auto event = EventFwk::CommonEventData(want); + dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); + dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); + EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_13, + Function | MediumTest | Level1) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); + auto dataConnectionPowerImprovementManager = + std::make_shared(cellularDataHandler); + bool isDefinedTelePower = true; + dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); + auto want = EventFwk::Want(); + want.SetAction(EXIT_STR_TELEPHONY_NOTIFY); + auto event = EventFwk::CommonEventData(want); + dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); + dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); + EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_14, + Function | MediumTest | Level1) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); + auto dataConnectionPowerImprovementManager = + std::make_shared(cellularDataHandler); + bool isDefinedTelePower = true; + dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); + auto want = EventFwk::Want(); + want.SetAction(TEL_EMC_RESCUE_MODE_STATUS); + auto event = EventFwk::CommonEventData(want); + dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); + EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); +} +} +} +// #endif \ No newline at end of file -- Gitee From 618200f28750dd14b9f611f13bd526aab201a324 Mon Sep 17 00:00:00 2001 From: chengwang Date: Fri, 22 Aug 2025 11:57:03 +0000 Subject: [PATCH 2/2] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=96=87=E4=BB=B6=200822?= =?UTF-8?q?.patch?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 0822.patch | 787 ----------------------------------------------------- 1 file changed, 787 deletions(-) delete mode 100644 0822.patch diff --git a/0822.patch b/0822.patch deleted file mode 100644 index 5ef9cdd8..00000000 --- a/0822.patch +++ /dev/null @@ -1,787 +0,0 @@ -From 55b8fdcf2e58e9b9e0733bbedab9d1bcc768f3ec Mon Sep 17 00:00:00 2001 -From: wangcheng 00845532 -Date: Thu, 21 Aug 2025 18:31:50 +0800 -Subject: [PATCH] TicketNo:AR20250209607755 Description:test str mode - Team:SP_XA_PTL Feature or Bugfix:Feature Binary Source:No - PrivateCode(Yes/No):No - -Change-Id: I2077a86c01535bf3b63411822cb4e0bdbe571dac ---- - BUILD.gn | 24 ++ - bundle.json | 3 +- - .../js/napi/src/cellular_data_handler.cpp | 16 + - services/include/cellular_data_handler.h | 6 +- - .../cellular_data_power_improvement_manager.h | 74 +++++ - ...ellular_data_power_improvement_manager.cpp | 189 ++++++++++++ - test/BUILD.gn | 1 + - test/cellular_data_handler_test.cpp | 25 ++ - ...ar_data_power_improvement_manager_test.cpp | 277 ++++++++++++++++++ - 9 files changed, 613 insertions(+), 2 deletions(-) - create mode 100644 services/include/cellular_data_power_improvement_manager.h - create mode 100644 services/src/cellular_data_power_improvement_manager.cpp - create mode 100644 test/cellular_data_power_improvement_manager_test.cpp - -diff --git a/BUILD.gn b/BUILD.gn -index 6b38160e..7ce3099c 100644 ---- a/BUILD.gn -+++ b/BUILD.gn -@@ -16,6 +16,10 @@ import("../core_service/telephony_core_service.gni") - TELEPHONY_EXT_WRAPPER_ROOT = "services/telephony_ext_wrapper" - DATA_SERVICE_EXT_WRAPPER_ROOT = "services/data_service_ext_wrapper" - -+declare_args() { -+ cellular_data_feature_base_power_improvement = false -+} -+ - ohos_shared_library("tel_cellular_data") { - sanitize = { - cfi = true -@@ -65,6 +69,12 @@ ohos_shared_library("tel_cellular_data") { - "services/src/utils/network_search_callback.cpp", - ] - -+ if (cellular_data_feature_base_power_improvement ) { -+ sources += [ -+ "services/src/cellular_data_power_improvement_manager.cpp", -+ ] -+ } -+ - include_dirs = [ - "$TELEPHONY_EXT_WRAPPER_ROOT/include", - "$DATA_SERVICE_EXT_WRAPPER_ROOT/include", -@@ -126,6 +136,10 @@ ohos_shared_library("tel_cellular_data") { - defines += [ "HICOLLIE_ENABLE" ] - } - -+ if (cellular_data_feature_base_power_improvement ) { -+ defines += [ "BASE_POWER_IMPROVEMENT" ] -+ } -+ - if (defined(global_parts_info) && - defined(global_parts_info.communication_netmanager_enhanced)) { - defines += [ "OHOS_BUILD_ENABLE_DATA_SERVICE_EXT" ] -@@ -185,6 +199,12 @@ ohos_static_library("tel_cellular_data_static") { - "services/src/utils/network_search_callback.cpp", - ] - -+ if (cellular_data_feature_base_power_improvement ) { -+ sources += [ -+ "services/src/cellular_data_power_improvement_manager.cpp", -+ ] -+ } -+ - include_dirs = [ - "$TELEPHONY_EXT_WRAPPER_ROOT/include", - "$DATA_SERVICE_EXT_WRAPPER_ROOT/include", -@@ -246,6 +266,10 @@ ohos_static_library("tel_cellular_data_static") { - defines += [ "HICOLLIE_ENABLE" ] - } - -+ if (cellular_data_feature_base_power_improvement ) { -+ defines += [ "BASE_POWER_IMPROVEMENT" ] -+ } -+ - if (defined(global_parts_info) && - defined(global_parts_info.communication_netmanager_enhanced)) { - defines += [ "OHOS_BUILD_ENABLE_DATA_SERVICE_EXT" ] -diff --git a/bundle.json b/bundle.json -index 1bed29ca..42944a6f 100644 ---- a/bundle.json -+++ b/bundle.json -@@ -23,7 +23,8 @@ - "SystemCapability.Telephony.CellularData" - ], - "features": [ -- "cellular_data_dynamic_start" -+ "cellular_data_dynamic_start", -+ "cellular_data_feature_base_power_improvement" - ], - "adapted_system_type": [ - "standard" -diff --git a/frameworks/js/napi/src/cellular_data_handler.cpp b/frameworks/js/napi/src/cellular_data_handler.cpp -index 3c1af7c1..d53a9630 100644 ---- a/frameworks/js/napi/src/cellular_data_handler.cpp -+++ b/frameworks/js/napi/src/cellular_data_handler.cpp -@@ -37,6 +37,10 @@ - #include "telephony_permission.h" - #include "ipc_skeleton.h" - #include "connection_retry_policy.h" -+#include "pdp_profile_data.h" -+#ifdef BASE_POWER_IMPROVEMENT -+#include "cellular_data_power_improvement_manager.h" -+#endif - namespace OHOS { - namespace Telephony { - using namespace AppExecFwk; -@@ -75,6 +79,12 @@ void CellularDataHandler::Init() - dataSwitchSettings_->LoadSwitchValue(); - GetConfigurationFor5G(); - SetRilLinkBandwidths(); -+#ifdef BASE_POWER_IMPROVEMENT -+ dataConnectionPowerImprovementManager_ = std::make_shared(*this); -+ bool isDefinedTelePower = system::GetBoolParameter("const.vendor.ril.power.feature_tele_power", false); -+ bool ret = dataConnectionPowerImprovementManager_->StartEventSubscriber(isDefinedTelePower); -+ TELEPHONY_LOGI("Subscribe ordered broadcast succ ret = %{public}d", ret); -+#endif - } - - CellularDataHandler::~CellularDataHandler() {} -@@ -1017,6 +1027,12 @@ void CellularDataHandler::HandleDisconnectDataCompleteForMmsType(sptr - SetDataPermittedForMms(false); - RemoveEvent(CellularDataEventCode::MSG_RESUME_DATA_PERMITTED_TIMEOUT); - } -+#ifdef BASE_POWER_IMPROVEMENT -+ if (dataConnectionPowerImprovementManager_ != nullptr && DataConnectionPowerImprovementManager::powerSaveFlag_) { -+ dataConnectionPowerImprovementManager_->FinishPowerStrEnterEvent(); -+ DataConnectionPowerImprovementManager::powerSaveFlag_ = false; -+ } -+#endif - } - - void CellularDataHandler::RetryOrClearConnection(const sptr &apnHolder, DisConnectionReason reason, -diff --git a/services/include/cellular_data_handler.h b/services/include/cellular_data_handler.h -index 3a763d19..07890f63 100644 ---- a/services/include/cellular_data_handler.h -+++ b/services/include/cellular_data_handler.h -@@ -38,9 +38,11 @@ - #include "tel_profile_util.h" - #include "tel_ril_data_parcel.h" - #include "telephony_types.h" -+ - namespace OHOS { - namespace Telephony { - const uint32_t KEEP_APN_ACTIVATE_PERIOD = 30 * 1000; -+class DataConnectionPowerImprovementManager; - class CellularDataHandler : public TelEventHandler, public EventFwk::CommonEventSubscriber { - public: - explicit CellularDataHandler(const EventFwk::CommonEventSubscribeInfo &sp, int32_t slotId); -@@ -222,7 +224,9 @@ private: - uint64_t defaultApnActTime_ = 0; - uint64_t internalApnActTime_ = 0; - int32_t retryCreateApnTimes_ = 0; -- -+#ifdef BASE_POWER_IMPROVEMENT -+ std::shared_ptr dataConnectionPowerImprovementManager_ = nullptr; -+#endif - using Fun = std::function; - std::map eventIdMap_ { - { RadioEvent::RADIO_PS_CONNECTION_ATTACHED, -diff --git a/services/include/cellular_data_power_improvement_manager.h b/services/include/cellular_data_power_improvement_manager.h -new file mode 100644 -index 00000000..4167b825 ---- /dev/null -+++ b/services/include/cellular_data_power_improvement_manager.h -@@ -0,0 +1,74 @@ -+/* -+ * Copyright (C) 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. -+ */ -+ -+#ifndef DATA_CONNECTION_POWER_STR_MANAGER_H -+#define DATA_CONNECTION_POWER_STR_MANAGER_H -+ -+#include "common_event_subscriber.h" -+#include "system_ability_status_change_stub.h" -+ -+namespace OHOS { -+namespace Telephony { -+class CellularDataHandler; -+class DataConnectionPowerSaveModeSubscriber : public EventFwk::CommonEventSubscriber { -+public: -+ explicit DataConnectionPowerSaveModeSubscriber( -+ const EventFwk::CommonEventSubscribeInfo &info, CellularDataHandler &handler) -+ : CommonEventSubscriber(info), powerSaveModeCellularDataHandler_(handler) {} -+ ~DataConnectionPowerSaveModeSubscriber() = default; -+ void OnReceiveEvent(const EventFwk::CommonEventData &data) override; -+ std::shared_ptr strAsyncCommonEvent_ = nullptr; -+private: -+ void HandleEnterStrEvent(std::string &action); -+ void HandleExitStrEvent(std::string &action); -+ CellularDataHandler &powerSaveModeCellularDataHandler_; -+}; -+ -+class DataConnectionPowerImprovementManager { -+public: -+ DataConnectionPowerImprovementManager(CellularDataHandler &handler) : strCellularDataHandler_(handler) {} -+ ~DataConnectionPowerImprovementManager() = default; -+ bool StartEventSubscriber(bool isDefinedTelePower); -+ void StopEventSubscriber(); -+ static bool GetSavedCellularDataStatus(); -+ static void SetSavedCellularDataStatus(bool value); -+ void FinishPowerStrEnterEvent(); -+ std::shared_ptr strEnterSubscriber_ = nullptr; -+ std::shared_ptr strExitSubscriber_ = nullptr; -+ static inline bool powerSaveFlag_ = false; -+private: -+ std::shared_ptr CreateCommonSubscriber(const std::string &event, -+ int32_t priority); -+private: -+ class SystemAbilityStatusChangeListener : public SystemAbilityStatusChangeStub { -+ public: -+ SystemAbilityStatusChangeListener(std::shared_ptr subStrEnter, -+ std::shared_ptr subStrExit) -+ : strEnterSub_(subStrEnter), strExitSub_(subStrExit) {} -+ ~SystemAbilityStatusChangeListener() = default; -+ void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; -+ void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; -+ private: -+ std::shared_ptr strEnterSub_ = nullptr; -+ std::shared_ptr strExitSub_ = nullptr; -+ }; -+private: -+ static inline bool g_savedCellularDataStatus = true; -+ sptr statusChangeListener_ = nullptr; -+ CellularDataHandler &strCellularDataHandler_; -+}; -+} // namespace Telephony -+} // namespace OHOS -+#endif -\ No newline at end of file -diff --git a/services/src/cellular_data_power_improvement_manager.cpp b/services/src/cellular_data_power_improvement_manager.cpp -new file mode 100644 -index 00000000..7c47e720 ---- /dev/null -+++ b/services/src/cellular_data_power_improvement_manager.cpp -@@ -0,0 +1,189 @@ -+/* -+ * Copyright (C) 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 "cellular_data_power_improvement_manager.h" -+ -+#include "telephony_types.h" -+#include "telephony_log_wrapper.h" -+#include "cellular_data_handler.h" -+ -+namespace OHOS { -+namespace Telephony { -+constexpr const char *PERMISSION_STARTUP_COMPLETED = "ohos.permission.RECEIVER_STARTUP_COMPLETED"; -+std::string lastMsg = ""; -+bool DataConnectionPowerImprovementManager::StartEventSubscriber(bool isDefinedTelePower) -+{ -+ if (!isDefinedTelePower) { -+ TELEPHONY_LOGI("feature_tele_power not define"); -+ return false; -+ } -+ strEnterSubscriber_ = CreateCommonSubscriber(ENTER_STR_TELEPHONY_NOTIFY, CommonEventPriority::FIRST_PRIORITY); -+ strExitSubscriber_ = CreateCommonSubscriber(EXIT_STR_TELEPHONY_NOTIFY, CommonEventPriority::THIRD_PRIORITY); -+ statusChangeListener_ = sptr::MakeSptr(strEnterSubscriber_, strExitSubscriber_); -+ auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); -+ if (samgrProxy == nullptr) { -+ TELEPHONY_LOGE("StartEventSubscriber samgrProxy is nullptr"); -+ return false; -+ } -+ if (samgrProxy->SubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, statusChangeListener_) != TELEPHONY_ERR_SUCCESS) { -+ TELEPHONY_LOGE("SubscribeSystemAbility execute failed"); -+ return false; -+ } -+ return true; -+} -+ -+std::shared_ptr DataConnectionPowerImprovementManager::CreateCommonSubscriber( -+ const std::string &event, int32_t priority) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(event); -+ EventFwk::CommonEventSubscribeInfo subscribeInfo(matchingSkills); -+ subscribeInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON); -+ subscribeInfo.SetPriority(priority); -+ subscribeInfo.SetPermission(PERMISSION_STARTUP_COMPLETED); -+ return std::make_shared(subscribeInfo, strCellularDataHandler_); -+} -+ -+void DataConnectionPowerImprovementManager::StopEventSubscriber() -+{ -+ auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); -+ if (samgrProxy != nullptr) { -+ int32_t ret = samgrProxy->UnSubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, statusChangeListener_); -+ TELEPHONY_LOGI("StopSystemAbilitySubscriber result = %{public}d", ret); -+ statusChangeListener_ = nullptr; -+ } -+ if (strEnterSubscriber_ != nullptr) { -+ bool subscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(strEnterSubscriber_); -+ TELEPHONY_LOGI("StopEventSubscriber result = %{public}d", subscribeResult); -+ strEnterSubscriber_ = nullptr; -+ } -+ if (strExitSubscriber_ != nullptr) { -+ bool subscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(strExitSubscriber_); -+ TELEPHONY_LOGI("StopEventSubscriber result = %{public}d", subscribeResult); -+ strExitSubscriber_ = nullptr; -+ } -+} -+ -+void DataConnectionPowerImprovementManager::SystemAbilityStatusChangeListener::OnAddSystemAbility( -+ int32_t systemAbilityId, const std::string &deviceId) -+{ -+ if (systemAbilityId != COMMON_EVENT_SERVICE_ID) { -+ TELEPHONY_LOGI("systemAbilityId is %{public}d", systemAbilityId); -+ return; -+ } -+ if (strEnterSub_ != nullptr) { -+ bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(strEnterSub_); -+ TELEPHONY_LOGI("strEnterSubscribeResult = %{public}d", subscribeResult); -+ } -+ if (strExitSub_ != nullptr) { -+ bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(strExitSub_); -+ TELEPHONY_LOGI("strExitSubscribeResult = %{public}d", subscribeResult); -+ } -+} -+ -+void DataConnectionPowerImprovementManager::SystemAbilityStatusChangeListener::OnRemoveSystemAbility( -+ int32_t systemAbilityId, const std::string &deviceId) -+{ -+ if (systemAbilityId != COMMON_EVENT_SERVICE_ID) { -+ return; -+ } -+ if (strEnterSub_ != nullptr) { -+ bool subscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(strEnterSub_); -+ TELEPHONY_LOGI("strEnterUnSubscribeResult = %{public}d", subscribeResult); -+ strEnterSub_ = nullptr; -+ } -+ if (strExitSub_ != nullptr) { -+ bool subscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(strExitSub_); -+ TELEPHONY_LOGI("strExitUnSubscribeResult = %{public}d", subscribeResult); -+ strExitSub_ = nullptr; -+ } -+} -+ -+void DataConnectionPowerImprovementManager::FinishPowerStrEnterEvent() -+{ -+ if (strEnterSubscriber_ != nullptr && strEnterSubscriber_->strAsyncCommonEvent_ != nullptr) { -+ bool ret = strEnterSubscriber_->strAsyncCommonEvent_->FinishCommonEvent(); -+ TELEPHONY_LOGI("StrEnter FinishPowerStrEnterEvent result = %{public}d", ret); -+ } -+} -+ -+bool DataConnectionPowerImprovementManager::GetSavedCellularDataStatus() -+{ -+ TELEPHONY_LOGI("Resume cellular status %{public}d", g_savedCellularDataStatus); -+ return g_savedCellularDataStatus; -+} -+ -+void DataConnectionPowerImprovementManager::SetSavedCellularDataStatus(bool value) -+{ -+ g_savedCellularDataStatus = value; -+ TELEPHONY_LOGI("Backup cellular status %{public}d", g_savedCellularDataStatus); -+} -+ -+void DataConnectionPowerSaveModeSubscriber::OnReceiveEvent(const EventFwk::CommonEventData &data) -+{ -+ std::string action = data.GetWant().GetAction(); -+ if (action == ENTER_STR_TELEPHONY_NOTIFY) { -+ TELEPHONY_LOGI("Enter str mode"); -+ HandleEnterStrEvent(action); -+ } else if (action == EXIT_STR_TELEPHONY_NOTIFY) { -+ TELEPHONY_LOGI("Exit str mode"); -+ HandleExitStrEvent(action); -+ } else { -+ TELEPHONY_LOGE("TelPowerSubscriber: action=%{public}s code=%{public}d", action.c_str(), data.GetCode()); -+ } -+} -+ -+void DataConnectionPowerSaveModeSubscriber::HandleEnterStrEvent(std::string &action) -+{ -+ strAsyncCommonEvent_ = this->GoAsyncCommonEvent(); -+ // except same msg -+ if (action != lastMsg) { -+ bool cellularDataStatus = true; -+ int32_t getCellularStatusRet = powerSaveModeCellularDataHandler_.IsCellularDataEnabled(cellularDataStatus); -+ TELEPHONY_LOGI("Get cellular status ret = %{public}d", getCellularStatusRet); -+ DataConnectionPowerImprovementManager::SetSavedCellularDataStatus(cellularDataStatus); -+ // set false in HandleDisconnectDataCompleteForMmsType -+ DataConnectionPowerImprovementManager::powerSaveFlag_ = true; -+ int32_t setCellularDataEnableRet = powerSaveModeCellularDataHandler_.SetCellularDataEnable(false); -+ TELEPHONY_LOGI("Enter str SetCellularDataEnable ret = %{public}d", setCellularDataEnableRet); -+ } else if (strAsyncCommonEvent_ != nullptr) { -+ TELEPHONY_LOGI("Recv same msg in succession lastMsg:%{public}s", lastMsg.c_str()); -+ bool ret = strAsyncCommonEvent_->FinishCommonEvent(); -+ TELEPHONY_LOGI("StrEnter FinishPowerStrEnterEvent ret = %{public}d", ret); -+ } -+ lastMsg = ENTER_STR_TELEPHONY_NOTIFY; -+} -+ -+void DataConnectionPowerSaveModeSubscriber::HandleExitStrEvent(std::string &action) -+{ -+ strAsyncCommonEvent_ = this->GoAsyncCommonEvent(); -+ if (action != lastMsg) { -+ // reply common event firt due to activate cellular too slow -+ if (strAsyncCommonEvent_ != nullptr) { -+ bool result = strAsyncCommonEvent_->FinishCommonEvent(); -+ TELEPHONY_LOGI("StrExit FinishPowerStrExitEvent result = %{public}d", result); -+ } -+ bool savedCellularDataStatus = DataConnectionPowerImprovementManager::GetSavedCellularDataStatus(); -+ int32_t ret = powerSaveModeCellularDataHandler_.SetCellularDataEnable(savedCellularDataStatus); -+ TELEPHONY_LOGI("Exit str SetCellularDataEnable ret = %{public}d", ret); -+ } else if (strAsyncCommonEvent_ != nullptr) { -+ TELEPHONY_LOGI("Recv same msg in succession lastMsg:%{public}s", lastMsg.c_str()); -+ bool ret = strAsyncCommonEvent_->FinishCommonEvent(); -+ TELEPHONY_LOGI("StrExit FinishPowerStrExitEvent ret = %{public}d", ret); -+ } -+ lastMsg = EXIT_STR_TELEPHONY_NOTIFY; -+} -+} // namespace Telephony -+} // namespace OHOS -\ No newline at end of file -diff --git a/test/BUILD.gn b/test/BUILD.gn -index b569d076..b5805aa6 100644 ---- a/test/BUILD.gn -+++ b/test/BUILD.gn -@@ -27,6 +27,7 @@ ohos_unittest("tel_cellular_data_test") { - "$SOURCE_DIR/test/data_access_token.cpp", - "$SOURCE_DIR/test/zero_branch_test.cpp", - "$SOURCE_DIR/test/net_manager_call_back_test.cpp", -+ "$SOURCE_DIR/test/cellular_data_power_improvement_manager_test.cpp", - ] - - include_dirs = [ -diff --git a/test/cellular_data_handler_test.cpp b/test/cellular_data_handler_test.cpp -index 1971ee0f..5ef3d1a8 100644 ---- a/test/cellular_data_handler_test.cpp -+++ b/test/cellular_data_handler_test.cpp -@@ -22,6 +22,9 @@ - #include "cellular_data_constant.h" - #include "cellular_data_handler.h" - #include "cellular_data_controller.h" -+#ifdef BASE_POWER_IMPROVEMENT -+#include "cellular_data_power_improvement_manager.h" -+#endif - - namespace OHOS { - namespace Telephony { -@@ -631,5 +634,27 @@ HWTEST_F(CellularDataHandlerTest, IsCellularDataEnabledTest001, Function | Mediu - cellularDataHandler->dataSwitchSettings_->lastQryRet_ = TELEPHONY_ERR_SUCCESS; - EXPECT_EQ(cellularDataHandler->IsCellularDataEnabled(isDataEnabled), TELEPHONY_ERR_SUCCESS); - } -+ -+/** -+@tc.number Telephony_HandleDisconnectDataCompleteForMmsType -+@tc.name HandleDisconnectDataCompleteForMmsType -+@tc.desc Function test -+*/ -+#ifdef BASE_POWER_IMPROVEMENT -+HWTEST_F(CellularDataHandlerTest, HandleDisconnectDataCompleteForMmsTypeTest001, Function | MediumTest | Level1) -+{ -+ int32_t slotId = 0; -+ EventFwk::MatchingSkills matchingSkills; -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = std::make_shared(subscriberInfo, slotId); -+ cellularDataHandler->Init(); -+ EXPECT_NE(cellularDataHandler->dataConnectionPowerImprovementManager_, nullptr); -+ DataConnectionPowerImprovementManager::powerSaveFlag_ = true; -+ std::string apnType = DATA_CONTEXT_ROLE_MMS; -+ sptr apnHolder = new ApnHolder(apnType, slotId); -+ cellularDataHandler->HandleDisconnectDataCompleteForMmsType(apnHolder); -+ EXPECT_EQ(DataConnectionPowerImprovementManager::powerSaveFlag_, false); -+} -+#endif - } // namespace Telephony - } // namespace OHOS -\ No newline at end of file -diff --git a/test/cellular_data_power_improvement_manager_test.cpp b/test/cellular_data_power_improvement_manager_test.cpp -new file mode 100644 -index 00000000..30094755 ---- /dev/null -+++ b/test/cellular_data_power_improvement_manager_test.cpp -@@ -0,0 +1,277 @@ -+/* -+ * Copyright (C) 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. -+ */ -+#define private public -+#define protected public -+ -+#include "cellular_data_power_improvement_manager.h" -+ -+#include "gtest/gtest.h" -+#include "common_event_support.h" -+#include "cellular_data_handler.h" -+ -+namespace OHOS { -+namespace Telephony { -+using namespace testing::ext; -+class DataConnectionPowerImprovementManagerTest : public testing::Test { -+public: -+ static void SetUpTestCase() {} -+ static void TearDownTestCase() {} -+ void SetUp() {} -+ void TearDown() {} -+}; -+ -+HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_01, -+ Function | MediumTest | Level1) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); -+ auto dataConnectionPowerImprovementManager = -+ std::make_shared(cellularDataHandler); -+ bool isDefinedTelePower = true; -+ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); -+ EXPECT_NE(dataConnectionPowerImprovementManager->strEnterSubscriber_, nullptr); -+ EXPECT_NE(dataConnectionPowerImprovementManager->strExitSubscriber_, nullptr); -+ dataConnectionPowerImprovementManager->StopEventSubscriber(); -+ EXPECT_EQ(dataConnectionPowerImprovementManager->strEnterSubscriber_, nullptr); -+ EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_, nullptr); -+} -+HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_02, -+ Function | MediumTest | Level1) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); -+ auto dataConnectionPowerImprovementManager = -+ std::make_shared(cellularDataHandler); -+ bool isDefinedTelePower = true; -+ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); -+ auto want = EventFwk::Want(); -+ want.SetAction(ENTER_STR_TELEPHONY_NOTIFY); -+ auto event = EventFwk::CommonEventData(want); -+ dataConnectionPowerImprovementManager->strEnterSubscriber_->OnReceiveEvent(event); -+ EXPECT_EQ(dataConnectionPowerImprovementManager->strEnterSubscriber_->strAsyncCommonEvent_, nullptr); -+} -+ -+HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_03, -+ Function | MediumTest | Level1) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); -+ auto dataConnectionPowerImprovementManager = -+ std::make_shared(cellularDataHandler); -+ bool isDefinedTelePower = true; -+ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); -+ auto want = EventFwk::Want(); -+ want.SetAction(EXIT_STR_TELEPHONY_NOTIFY); -+ auto event = EventFwk::CommonEventData(want); -+ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); -+ EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); -+} -+ -+HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_04, -+ Function | MediumTest | Level1) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); -+ auto dataConnectionPowerImprovementManager = -+ std::make_shared(cellularDataHandler); -+ bool isDefinedTelePower = true; -+ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); -+ auto want = EventFwk::Want(); -+ want.SetAction(ENTER_STR_TELEPHONY_NOTIFY); -+ auto event = EventFwk::CommonEventData(want); -+ DataConnectionPowerImprovementManager::SetSavedCellularDataStatus(false); -+ dataConnectionPowerImprovementManager->strEnterSubscriber_->OnReceiveEvent(event); -+ EXPECT_EQ(dataConnectionPowerImprovementManager->strEnterSubscriber_->strAsyncCommonEvent_, nullptr); -+} -+ -+HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_05, -+ Function | MediumTest | Level1) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); -+ auto dataConnectionPowerImprovementManager = -+ std::make_shared(cellularDataHandler); -+ bool isDefinedTelePower = true; -+ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); -+ auto want = EventFwk::Want(); -+ want.SetAction(EXIT_STR_TELEPHONY_NOTIFY); -+ auto event = EventFwk::CommonEventData(want); -+ dataConnectionPowerImprovementManager->strEnterSubscriber_->OnReceiveEvent(event); -+ EXPECT_EQ(dataConnectionPowerImprovementManager->strEnterSubscriber_->strAsyncCommonEvent_, nullptr); -+} -+ -+HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_06, -+ Function | MediumTest | Level1) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); -+ auto dataConnectionPowerImprovementManager = -+ std::make_shared(cellularDataHandler); -+ bool isDefinedTelePower = true; -+ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); -+ auto want = EventFwk::Want(); -+ want.SetAction(EXIT_STR_TELEPHONY_NOTIFY); -+ auto event = EventFwk::CommonEventData(want); -+ DataConnectionPowerImprovementManager::SetSavedCellularDataStatus(false); -+ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); -+ EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); -+} -+ -+HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_07, -+ Function | MediumTest | Level1) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); -+ auto dataConnectionPowerImprovementManager = -+ std::make_shared(cellularDataHandler); -+ bool isDefinedTelePower = true; -+ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); -+ auto want = EventFwk::Want(); -+ want.SetAction(ENTER_STR_TELEPHONY_NOTIFY); -+ auto event = EventFwk::CommonEventData(want); -+ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); -+ EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); -+} -+ -+HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_08, -+ Function | MediumTest | Level1) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); -+ auto dataConnectionPowerImprovementManager = -+ std::make_shared(cellularDataHandler); -+ dataConnectionPowerImprovementManager->statusChangeListener_ = -+ new (std::nothrow) DataConnectionPowerImprovementManager::SystemAbilityStatusChangeListener(nullptr, nullptr); -+ dataConnectionPowerImprovementManager->statusChangeListener_->OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, -+ "test_device"); -+} -+ -+HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_09, -+ Function | MediumTest | Level1) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); -+ auto dataConnectionPowerImprovementManager = -+ std::make_shared(cellularDataHandler); -+ bool isDefinedTelePower = true; -+ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); -+ dataConnectionPowerImprovementManager->statusChangeListener_->OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, -+ "test_device"); -+} -+ -+HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_10, -+ Function | MediumTest | Level1) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); -+ auto dataConnectionPowerImprovementManager = -+ std::make_shared(cellularDataHandler); -+ bool isDefinedTelePower = true; -+ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); -+ dataConnectionPowerImprovementManager->statusChangeListener_->OnRemoveSystemAbility(SCREENLOCK_SERVICE_ID, -+ "test_device"); -+} -+ -+HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_11, -+ Function | MediumTest | Level1) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); -+ auto dataConnectionPowerImprovementManager = -+ std::make_shared(cellularDataHandler); -+ dataConnectionPowerImprovementManager->SetSavedCellularDataStatus(false); -+ bool ret = dataConnectionPowerImprovementManager->GetSavedCellularDataStatus(); -+ EXPECT_EQ(ret, false); -+} -+HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_12, -+ Function | MediumTest | Level1) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); -+ auto dataConnectionPowerImprovementManager = -+ std::make_shared(cellularDataHandler); -+ bool isDefinedTelePower = true; -+ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); -+ auto want = EventFwk::Want(); -+ want.SetAction(ENTER_STR_TELEPHONY_NOTIFY); -+ auto event = EventFwk::CommonEventData(want); -+ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); -+ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); -+ EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); -+} -+ -+HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_13, -+ Function | MediumTest | Level1) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); -+ auto dataConnectionPowerImprovementManager = -+ std::make_shared(cellularDataHandler); -+ bool isDefinedTelePower = true; -+ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); -+ auto want = EventFwk::Want(); -+ want.SetAction(EXIT_STR_TELEPHONY_NOTIFY); -+ auto event = EventFwk::CommonEventData(want); -+ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); -+ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); -+ EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); -+} -+ -+HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_14, -+ Function | MediumTest | Level1) -+{ -+ EventFwk::MatchingSkills matchingSkills; -+ matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); -+ EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); -+ auto cellularDataHandler = CellularDataHandler(subscriberInfo, 0); -+ auto dataConnectionPowerImprovementManager = -+ std::make_shared(cellularDataHandler); -+ bool isDefinedTelePower = true; -+ dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); -+ auto want = EventFwk::Want(); -+ want.SetAction(TEL_EMC_RESCUE_MODE_STATUS); -+ auto event = EventFwk::CommonEventData(want); -+ dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); -+ EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); -+} -+} -+} -+// #endif -\ No newline at end of file --- -2.45.2.huawei.10 - -- Gitee