diff --git a/BUILD.gn b/BUILD.gn index cdc8fae70a4492002ee9b76a2e7d8aecb165c060..8e114ab2f767ab9632d81321302a10e7364cd817 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 cad08daa6e40e90105646c603feaa81f15d5b945..9c01c939d6df9233d6d2c356c7948d1d1a9607dc 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 e736a4daed64f56813121bc087046818fbebd5d8..a03f99023817281df042c5c1951dd3e0ebb9a1ff 100644 --- a/frameworks/js/napi/src/cellular_data_handler.cpp +++ b/frameworks/js/napi/src/cellular_data_handler.cpp @@ -38,6 +38,9 @@ #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; @@ -76,6 +79,11 @@ 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); + dataConnectionPowerImprovementManager_->StartEventSubscriber(isDefinedTelePower); +#endif } CellularDataHandler::~CellularDataHandler() {} @@ -1058,6 +1066,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 277fbdc978484807990e1bcaab1257db4aee58e8..ef77d772e6a5dba357dd0b6f821891d390cfcdc8 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 0000000000000000000000000000000000000000..b9552dde4ae037572736aa7a053d7e218ed4def3 --- /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; + void 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 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 0000000000000000000000000000000000000000..8f86550da7ff380be95d6dc48a417438a3de935c --- /dev/null +++ b/services/src/cellular_data_power_improvement_manager.cpp @@ -0,0 +1,183 @@ +/* + * 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 = ""; +void DataConnectionPowerImprovementManager::StartEventSubscriber(bool isDefinedTelePower) +{ + if (!isDefinedTelePower) { + TELEPHONY_LOGI("feature_tele_power not define"); + return; + } + 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) { + int32_t ret = samgrProxy->SubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, statusChangeListener_); + TELEPHONY_LOGI("SubscribeSystemAbility execute ret = %{public}d", ret); + } +} + +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(); + strAsyncCommonEvent_ = this->GoAsyncCommonEvent(); + 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) +{ + // 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) +{ + 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 diff --git a/test/BUILD.gn b/test/BUILD.gn index d8c4f99798aa74ac8f7f8429ae1947b3077770fb..631fe52e083356fc8e64af44bdaf2aa37702cefc 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 0294f240a44378af542ea16626a0153fe43bb097..738ca0f25dff7396dbb2a4699d06747b72c0ef59 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 0000000000000000000000000000000000000000..e42e367e7a0c9bc057a02bc014014b3207cd6c86 --- /dev/null +++ b/test/cellular_data_power_improvement_manager_test.cpp @@ -0,0 +1,427 @@ +/* + * 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. + */ + +#ifdef BASE_POWER_IMPROVEMENT +#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); + std::shared_ptr subStrEnter = nullptr; + std::shared_ptr subStrExit = nullptr; + dataConnectionPowerImprovementManager->statusChangeListener_ = new (std::nothrow) + DataConnectionPowerImprovementManager::SystemAbilityStatusChangeListener(subStrEnter, subStrExit); + 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(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + auto event = EventFwk::CommonEventData(want); + dataConnectionPowerImprovementManager->strExitSubscriber_->OnReceiveEvent(event); + EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_, nullptr); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_15, + 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); + std::shared_ptr subStrEnter = nullptr; + std::shared_ptr subStrExit = nullptr; + dataConnectionPowerImprovementManager->statusChangeListener_ = new (std::nothrow) + DataConnectionPowerImprovementManager::SystemAbilityStatusChangeListener(subStrEnter, subStrExit); + dataConnectionPowerImprovementManager->statusChangeListener_->OnAddSystemAbility(EVENT_MANAGER_SERVICE_ID, + "test_device"); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_16, + 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 = false; + dataConnectionPowerImprovementManager->StartEventSubscriber(isDefinedTelePower); + dataConnectionPowerImprovementManager->strEnterSubscriber_ = + std::make_shared(subscriberInfo, cellularDataHandler); + int32_t resultCode = 1; + std::string resultData = "aa"; + bool ordered = false; + bool sticky = true; + sptr token = nullptr; + dataConnectionPowerImprovementManager->strEnterSubscriber_->strAsyncCommonEvent_ = + std::make_shared(resultCode, resultData, ordered, sticky, token); + dataConnectionPowerImprovementManager->FinishPowerStrEnterEvent(); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_17, + 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->strEnterSubscriber_ = + std::make_shared(subscriberInfo, cellularDataHandler); + int32_t resultCode = 1; + std::string resultData = "aa"; + bool ordered = false; + bool sticky = true; + sptr token = nullptr; + dataConnectionPowerImprovementManager->strEnterSubscriber_->strAsyncCommonEvent_ = + std::make_shared(resultCode, resultData, ordered, sticky, token); + std::string action = ENTER_STR_TELEPHONY_NOTIFY; + dataConnectionPowerImprovementManager->strEnterSubscriber_->HandleEnterStrEvent(action); + dataConnectionPowerImprovementManager->strEnterSubscriber_->HandleEnterStrEvent(action); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_18, + 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->strExitSubscriber_ = + std::make_shared(subscriberInfo, cellularDataHandler); + int32_t resultCode = 1; + std::string resultData = "aa"; + bool ordered = false; + bool sticky = true; + sptr token = nullptr; + dataConnectionPowerImprovementManager->strExitSubscriber_->strAsyncCommonEvent_ = + std::make_shared(resultCode, resultData, ordered, sticky, token); + std::string action = EXIT_STR_TELEPHONY_NOTIFY; + dataConnectionPowerImprovementManager->strExitSubscriber_->HandleExitStrEvent(action); + dataConnectionPowerImprovementManager->strExitSubscriber_->HandleExitStrEvent(action); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_19, + 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->strEnterSubscriber_ = nullptr; + dataConnectionPowerImprovementManager->strExitSubscriber_ = nullptr; + dataConnectionPowerImprovementManager->StopEventSubscriber(); + EXPECT_EQ(dataConnectionPowerImprovementManager->strEnterSubscriber_, nullptr); + EXPECT_EQ(dataConnectionPowerImprovementManager->strExitSubscriber_, nullptr); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_20, + 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); + std::shared_ptr subStrEnter = nullptr; + std::shared_ptr subStrExit = nullptr; + dataConnectionPowerImprovementManager->statusChangeListener_ = new (std::nothrow) + DataConnectionPowerImprovementManager::SystemAbilityStatusChangeListener(subStrEnter, subStrExit); + dataConnectionPowerImprovementManager->statusChangeListener_->OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, + "test_device"); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_21, + 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->FinishPowerStrEnterEvent(); +} + +HWTEST_F(DataConnectionPowerImprovementManagerTest, DataConnectionPowerImprovementManager_22, + 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->strEnterSubscriber_ = + std::make_shared(subscriberInfo, cellularDataHandler); + dataConnectionPowerImprovementManager->strEnterSubscriber_->strAsyncCommonEvent_ = nullptr; + dataConnectionPowerImprovementManager->FinishPowerStrEnterEvent(); +} +} +} +#endif