From cdca33e0bd33db5116837646946d163842081dd7 Mon Sep 17 00:00:00 2001 From: wangyantian Date: Fri, 23 Aug 2024 14:21:44 +0800 Subject: [PATCH 1/2] feat: Add OnAsyncPowerStateChanged interface Signed-off-by: wangyantian --- frameworks/native/power_mgr_client.cpp | 4 +- .../inner_api/native/include/ipower_mgr.h | 2 +- .../native/include/ipower_state_callback.h | 1 + .../native/include/power_mgr_client.h | 2 +- .../power_state_callback_ipc_interface_code.h | 1 + services/native/include/power_mgr_service.h | 2 +- services/native/include/power_state_machine.h | 5 +- services/native/src/power_mgr_service.cpp | 4 +- services/native/src/power_state_machine.cpp | 53 +++++++++++++------ services/zidl/include/power_mgr_proxy.h | 2 +- .../zidl/include/power_state_callback_proxy.h | 1 + .../zidl/include/power_state_callback_stub.h | 2 + services/zidl/src/power_mgr_proxy.cpp | 3 +- services/zidl/src/power_mgr_stub.cpp | 4 +- .../zidl/src/power_state_callback_proxy.cpp | 24 +++++++++ .../zidl/src/power_state_callback_stub.cpp | 10 ++++ .../servicetest/powermgr_service_test_proxy.h | 2 +- .../powermgr_service_test_proxy.cpp | 3 +- 18 files changed, 96 insertions(+), 29 deletions(-) diff --git a/frameworks/native/power_mgr_client.cpp b/frameworks/native/power_mgr_client.cpp index b18cfec6..ac673345 100644 --- a/frameworks/native/power_mgr_client.cpp +++ b/frameworks/native/power_mgr_client.cpp @@ -315,10 +315,10 @@ bool PowerMgrClient::ResetRunningLocks() return proxy_->ResetRunningLocks(); } -bool PowerMgrClient::RegisterPowerStateCallback(const sptr& callback) +bool PowerMgrClient::RegisterPowerStateCallback(const sptr& callback, bool isSync) { RETURN_IF_WITH_RET((callback == nullptr) || (Connect() != ERR_OK), false); - bool ret = proxy_->RegisterPowerStateCallback(callback); + bool ret = proxy_->RegisterPowerStateCallback(callback, isSync); return ret; } diff --git a/interfaces/inner_api/native/include/ipower_mgr.h b/interfaces/inner_api/native/include/ipower_mgr.h index 7db1e848..52b55f74 100644 --- a/interfaces/inner_api/native/include/ipower_mgr.h +++ b/interfaces/inner_api/native/include/ipower_mgr.h @@ -66,7 +66,7 @@ public: virtual bool IsScreenOn(bool needPrintLog = true) = 0; virtual bool IsFoldScreenOn() = 0; virtual PowerErrors ForceSuspendDevice(int64_t callTimeMs) = 0; - virtual bool RegisterPowerStateCallback(const sptr& callback) = 0; + virtual bool RegisterPowerStateCallback(const sptr& callback, bool isSync = true) = 0; virtual bool UnRegisterPowerStateCallback(const sptr& callback) = 0; virtual bool RegisterSyncSleepCallback(const sptr& callback, diff --git a/interfaces/inner_api/native/include/ipower_state_callback.h b/interfaces/inner_api/native/include/ipower_state_callback.h index d1cf4737..b544f15c 100644 --- a/interfaces/inner_api/native/include/ipower_state_callback.h +++ b/interfaces/inner_api/native/include/ipower_state_callback.h @@ -26,6 +26,7 @@ namespace PowerMgr { class IPowerStateCallback : public IRemoteBroker { public: virtual void OnPowerStateChanged(PowerState state) = 0; + virtual void OnAsyncPowerStateChanged(PowerState state) = 0; DECLARE_INTERFACE_DESCRIPTOR(u"ohos.powermgr.IPowerStateCallback"); }; diff --git a/interfaces/inner_api/native/include/power_mgr_client.h b/interfaces/inner_api/native/include/power_mgr_client.h index b4c4a1da..c21ded9b 100644 --- a/interfaces/inner_api/native/include/power_mgr_client.h +++ b/interfaces/inner_api/native/include/power_mgr_client.h @@ -162,7 +162,7 @@ public: bool ProxyRunningLock(bool isProxied, pid_t pid, pid_t uid); bool ProxyRunningLocks(bool isProxied, const std::vector>& processInfos); bool ResetRunningLocks(); - bool RegisterPowerStateCallback(const sptr& callback); + bool RegisterPowerStateCallback(const sptr& callback, bool isSync = true); bool UnRegisterPowerStateCallback(const sptr& callback); bool RegisterSyncHibernateCallback(const sptr& callback); bool UnRegisterSyncHibernateCallback(const sptr& callback); diff --git a/interfaces/inner_api/native/include/power_state_callback_ipc_interface_code.h b/interfaces/inner_api/native/include/power_state_callback_ipc_interface_code.h index 75b31b27..83eddf14 100644 --- a/interfaces/inner_api/native/include/power_state_callback_ipc_interface_code.h +++ b/interfaces/inner_api/native/include/power_state_callback_ipc_interface_code.h @@ -21,6 +21,7 @@ namespace OHOS { namespace PowerMgr { enum class PowerStateCallbackInterfaceCode { POWER_STATE_CHANGED = 0, + ASYNC_POWER_STATE_CHANGED = 1, }; } // space PowerMgr } // namespace OHOS diff --git a/services/native/include/power_mgr_service.h b/services/native/include/power_mgr_service.h index b5022d4d..feb27c2f 100644 --- a/services/native/include/power_mgr_service.h +++ b/services/native/include/power_mgr_service.h @@ -83,7 +83,7 @@ public: virtual bool ProxyRunningLocks(bool isProxied, const std::vector>& processInfos) override; virtual bool ResetRunningLocks() override; - virtual bool RegisterPowerStateCallback(const sptr& callback) override; + virtual bool RegisterPowerStateCallback(const sptr& callback, bool isSync = true) override; virtual bool UnRegisterPowerStateCallback(const sptr& callback) override; virtual bool RegisterSyncSleepCallback(const sptr& callback, SleepPriority priority) override; diff --git a/services/native/include/power_state_machine.h b/services/native/include/power_state_machine.h index f3a8aac3..015a9f41 100644 --- a/services/native/include/power_state_machine.h +++ b/services/native/include/power_state_machine.h @@ -112,7 +112,7 @@ public: #ifdef POWER_MANAGER_POWER_ENABLE_S4 bool HibernateInner(bool clearMemory); #endif - void RegisterPowerStateCallback(const sptr& callback); + void RegisterPowerStateCallback(const sptr& callback, bool isSync = true); void UnRegisterPowerStateCallback(const sptr& callback); void SetDelayTimer(int64_t delayTime, int32_t event); void CancelDelayTimer(int32_t event); @@ -322,7 +322,8 @@ private: std::mutex stateMutex_; DevicePowerState mDeviceState_; sptr powerStateCBDeathRecipient_; - std::set, classcomp> powerStateListeners_; + std::set, classcomp> syncPowerStateListeners_; + std::set, classcomp> asyncPowerStateListeners_; std::shared_ptr stateAction_; std::atomic displayOffTime_ {DEFAULT_DISPLAY_OFF_TIME}; diff --git a/services/native/src/power_mgr_service.cpp b/services/native/src/power_mgr_service.cpp index 3f9d404e..a83a45c9 100644 --- a/services/native/src/power_mgr_service.cpp +++ b/services/native/src/power_mgr_service.cpp @@ -1088,7 +1088,7 @@ bool PowerMgrService::ResetRunningLocks() return true; } -bool PowerMgrService::RegisterPowerStateCallback(const sptr& callback) +bool PowerMgrService::RegisterPowerStateCallback(const sptr& callback, bool isSync) { std::lock_guard lock(stateMutex_); pid_t pid = IPCSkeleton::GetCallingPid(); @@ -1097,7 +1097,7 @@ bool PowerMgrService::RegisterPowerStateCallback(const sptr return false; } POWER_HILOGI(FEATURE_POWER_STATE, "%{public}s: pid: %{public}d, uid: %{public}d", __func__, pid, uid); - powerStateMachine_->RegisterPowerStateCallback(callback); + powerStateMachine_->RegisterPowerStateCallback(callback, isSync); return true; } diff --git a/services/native/src/power_state_machine.cpp b/services/native/src/power_state_machine.cpp index 4c332209..1deb3db3 100644 --- a/services/native/src/power_state_machine.cpp +++ b/services/native/src/power_state_machine.cpp @@ -774,18 +774,28 @@ void PowerStateMachine::ReceiveScreenEvent(bool isScreenOn) } } -void PowerStateMachine::RegisterPowerStateCallback(const sptr& callback) +void PowerStateMachine::RegisterPowerStateCallback(const sptr& callback, bool isSync) { std::lock_guard lock(mutex_); RETURN_IF(callback == nullptr); auto object = callback->AsObject(); RETURN_IF(object == nullptr); - auto retIt = powerStateListeners_.insert(callback); - if (retIt.second) { + + bool result = false; + if (isSync) { + auto retIt = syncPowerStateListeners_.insert(callback); + result = retIt.second; + POWER_HILOGD(FEATURE_POWER_STATE, "sync listeners.size = %{public}d, insertOk = %{public}d", + static_cast(syncPowerStateListeners_.size()), retIt.second); + } else { + auto retIt = asyncPowerStateListeners_.insert(callback); + result = retIt.second; + POWER_HILOGD(FEATURE_POWER_STATE, "async listeners.size = %{public}d, insertOk = %{public}d", + static_cast(asyncPowerStateListeners_.size()), retIt.second); + } + if (result) { object->AddDeathRecipient(powerStateCBDeathRecipient_); } - POWER_HILOGD(FEATURE_POWER_STATE, "listeners.size = %{public}d, insertOk = %{public}d", - static_cast(powerStateListeners_.size()), retIt.second); } void PowerStateMachine::UnRegisterPowerStateCallback(const sptr& callback) @@ -794,12 +804,22 @@ void PowerStateMachine::UnRegisterPowerStateCallback(const sptrAsObject(); RETURN_IF(object == nullptr); - size_t eraseNum = powerStateListeners_.erase(callback); - if (eraseNum != 0) { - object->RemoveDeathRecipient(powerStateCBDeathRecipient_); + size_t eraseNum = 0; + if (syncPowerStateListeners_.find(callback) != syncPowerStateListeners_.end()) { + eraseNum = syncPowerStateListeners_.erase(callback); + if (eraseNum != 0) { + object->RemoveDeathRecipient(powerStateCBDeathRecipient_); + } + POWER_HILOGD(FEATURE_POWER_STATE, "sync listeners.size = %{public}d, eraseNum = %{public}zu", + static_cast(syncPowerStateListeners_.size()), eraseNum); + } else { + eraseNum = asyncPowerStateListeners_.erase(callback); + if (eraseNum != 0) { + object->RemoveDeathRecipient(powerStateCBDeathRecipient_); + } + POWER_HILOGD(FEATURE_POWER_STATE, "async listeners.size = %{public}d, eraseNum = %{public}zu", + static_cast(asyncPowerStateListeners_.size()), eraseNum); } - POWER_HILOGD(FEATURE_POWER_STATE, "listeners.size = %{public}d, eraseNum = %{public}zu", - static_cast(powerStateListeners_.size()), eraseNum); } void PowerStateMachine::EnableMock(IDeviceStateAction* mockAction) @@ -823,18 +843,21 @@ void PowerStateMachine::NotifyPowerStateChanged(PowerState state) return; } POWER_HILOGD( - FEATURE_POWER_STATE, "state=%{public}u, listeners.size=%{public}zu", state, powerStateListeners_.size()); - HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::POWER, "STATE", HiviewDFX::HiSysEvent::EventType::STATISTIC, - "STATE", static_cast(state)); + FEATURE_POWER_STATE, "state=%{public}u, listeners.size=%{public}zu", state, syncPowerStateListeners_.size()); + HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::POWER, "STATE", HiviewDFX::HiSysEvent::EventType::STATISTIC, "STATE", + static_cast(state)); std::lock_guard lock(mutex_); int64_t now = GetTickCount(); // Send Notification event SendEventToPowerMgrNotify(state, now); // Call back all native function - for (auto& listener : powerStateListeners_) { + for (auto& listener : syncPowerStateListeners_) { listener->OnPowerStateChanged(state); } + for (auto& listener : asyncPowerStateListeners_) { + listener->OnAsyncPowerStateChanged(state); + } } void PowerStateMachine::SendEventToPowerMgrNotify(PowerState state, int64_t callTime) @@ -1425,7 +1448,7 @@ void PowerStateMachine::HandleProximityScreenOffTimer(PowerState state, StateCha if ((reason == StateChangeReason::STATE_CHANGE_REASON_DOUBLE_CLICK || reason == StateChangeReason::STATE_CHANGE_REASON_PICKUP) && IsProximityClose() && state == PowerState::AWAKE) { - POWER_HILOGI(FEATURE_POWER_STATE, "Double-click or pickup is allowed to cancel proximity-screen-off timer"); + POWER_HILOGI(FEATURE_POWER_STATE, "Double-click or pickup is not allowed to cancel proximity-screen-off timer"); return; } if (reason != StateChangeReason::STATE_CHANGE_REASON_PROXIMITY) { diff --git a/services/zidl/include/power_mgr_proxy.h b/services/zidl/include/power_mgr_proxy.h index 44f34b9b..d1344c58 100644 --- a/services/zidl/include/power_mgr_proxy.h +++ b/services/zidl/include/power_mgr_proxy.h @@ -72,7 +72,7 @@ public: virtual PowerErrors RebootDeviceForDeprecated(const std::string& reason) override; virtual PowerErrors ShutDownDevice(const std::string& reason) override; virtual PowerErrors SetSuspendTag(const std::string& tag) override; - virtual bool RegisterPowerStateCallback(const sptr& callback) override; + virtual bool RegisterPowerStateCallback(const sptr& callback, bool isSync = true) override; virtual bool UnRegisterPowerStateCallback(const sptr& callback) override; virtual bool RegisterPowerModeCallback(const sptr& callback) override; virtual bool UnRegisterPowerModeCallback(const sptr& callback) override; diff --git a/services/zidl/include/power_state_callback_proxy.h b/services/zidl/include/power_state_callback_proxy.h index f54452ed..8dbab06e 100644 --- a/services/zidl/include/power_state_callback_proxy.h +++ b/services/zidl/include/power_state_callback_proxy.h @@ -35,6 +35,7 @@ public: ~PowerStateCallbackProxy() = default; DISALLOW_COPY_AND_MOVE(PowerStateCallbackProxy); virtual void OnPowerStateChanged(PowerState state) override; + virtual void OnAsyncPowerStateChanged(PowerState state) override; private: static inline BrokerDelegator delegator_; diff --git a/services/zidl/include/power_state_callback_stub.h b/services/zidl/include/power_state_callback_stub.h index 5e633cbe..9eb2739e 100644 --- a/services/zidl/include/power_state_callback_stub.h +++ b/services/zidl/include/power_state_callback_stub.h @@ -30,9 +30,11 @@ public: virtual ~PowerStateCallbackStub() = default; int OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override; void OnPowerStateChanged(PowerState __attribute__((unused))state) override {} + void OnAsyncPowerStateChanged(PowerState __attribute__((unused))state) override {} private: int32_t OnPowerStateChangedStub(MessageParcel& data); + int32_t OnAsyncPowerStateChangedStub(MessageParcel& data); }; } // namespace PowerMgr } // namespace OHOS diff --git a/services/zidl/src/power_mgr_proxy.cpp b/services/zidl/src/power_mgr_proxy.cpp index 8d1369dd..d8cb9a15 100644 --- a/services/zidl/src/power_mgr_proxy.cpp +++ b/services/zidl/src/power_mgr_proxy.cpp @@ -724,7 +724,7 @@ bool PowerMgrProxy::IsFoldScreenOn() return result; } -bool PowerMgrProxy::RegisterPowerStateCallback(const sptr& callback) +bool PowerMgrProxy::RegisterPowerStateCallback(const sptr& callback, bool isSync) { sptr remote = Remote(); RETURN_IF_WITH_RET((remote == nullptr) || (callback == nullptr), false); @@ -739,6 +739,7 @@ bool PowerMgrProxy::RegisterPowerStateCallback(const sptr& } RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, RemoteObject, callback->AsObject(), false); + RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Bool, isSync, false); int ret = remote->SendRequest( static_cast(PowerMgr::PowerMgrInterfaceCode::REG_POWER_STATE_CALLBACK), diff --git a/services/zidl/src/power_mgr_stub.cpp b/services/zidl/src/power_mgr_stub.cpp index 6dea73e1..b0760f12 100644 --- a/services/zidl/src/power_mgr_stub.cpp +++ b/services/zidl/src/power_mgr_stub.cpp @@ -496,10 +496,12 @@ int32_t PowerMgrStub::IsScreenOnStub(MessageParcel& data, MessageParcel& reply) int32_t PowerMgrStub::RegisterPowerStateCallbackStub(MessageParcel& data) { sptr obj = data.ReadRemoteObject(); + bool isSync = true; + RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Bool, isSync, E_READ_PARCEL_ERROR); RETURN_IF_WITH_RET((obj == nullptr), E_READ_PARCEL_ERROR); sptr callback = iface_cast(obj); RETURN_IF_WITH_RET((callback == nullptr), E_READ_PARCEL_ERROR); - RegisterPowerStateCallback(callback); + RegisterPowerStateCallback(callback, isSync); return ERR_OK; } diff --git a/services/zidl/src/power_state_callback_proxy.cpp b/services/zidl/src/power_state_callback_proxy.cpp index 040c524e..f6e26b77 100644 --- a/services/zidl/src/power_state_callback_proxy.cpp +++ b/services/zidl/src/power_state_callback_proxy.cpp @@ -47,5 +47,29 @@ void PowerStateCallbackProxy::OnPowerStateChanged(PowerState state) POWER_HILOGE(FEATURE_POWER_STATE, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret); } } + +void PowerStateCallbackProxy::OnAsyncPowerStateChanged(PowerState state) +{ + sptr remote = Remote(); + RETURN_IF(remote == nullptr); + + MessageParcel data; + MessageParcel reply; + MessageOption option = { MessageOption::TF_ASYNC }; + + if (!data.WriteInterfaceToken(PowerStateCallbackProxy::GetDescriptor())) { + POWER_HILOGE(FEATURE_POWER_STATE, "Write descriptor failed"); + return; + } + + RETURN_IF_WRITE_PARCEL_FAILED_NO_RET(data, Uint32, static_cast(state)); + + int ret = remote->SendRequest( + static_cast(PowerMgr::PowerStateCallbackInterfaceCode::ASYNC_POWER_STATE_CHANGED), + data, reply, option); + if (ret != ERR_OK) { + POWER_HILOGE(FEATURE_POWER_STATE, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret); + } +} } // namespace PowerMgr } // namespace OHOS diff --git a/services/zidl/src/power_state_callback_stub.cpp b/services/zidl/src/power_state_callback_stub.cpp index ac251eb9..3ebac02a 100644 --- a/services/zidl/src/power_state_callback_stub.cpp +++ b/services/zidl/src/power_state_callback_stub.cpp @@ -42,6 +42,8 @@ int PowerStateCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel &data, int ret = ERR_OK; if (code == static_cast(PowerMgr::PowerStateCallbackInterfaceCode::POWER_STATE_CHANGED)) { ret = OnPowerStateChangedStub(data); + } else if (code == static_cast(PowerMgr::PowerStateCallbackInterfaceCode::ASYNC_POWER_STATE_CHANGED)) { + ret = OnAsyncPowerStateChangedStub(data); } else { ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option); } @@ -56,5 +58,13 @@ int32_t PowerStateCallbackStub::OnPowerStateChangedStub(MessageParcel& data) OnPowerStateChanged(static_cast(type)); return ERR_OK; } + +int32_t PowerStateCallbackStub::OnAsyncPowerStateChangedStub(MessageParcel& data) +{ + uint32_t type; + RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, Uint32, type, E_READ_PARCEL_ERROR); + OnAsyncPowerStateChanged(static_cast(type)); + return ERR_OK; +} } // namespace PowerMgr } // namespace OHOS diff --git a/test/unittest/include/servicetest/powermgr_service_test_proxy.h b/test/unittest/include/servicetest/powermgr_service_test_proxy.h index 00a62240..17641b3b 100644 --- a/test/unittest/include/servicetest/powermgr_service_test_proxy.h +++ b/test/unittest/include/servicetest/powermgr_service_test_proxy.h @@ -65,7 +65,7 @@ public: PowerErrors RebootDevice(const std::string& reason); PowerErrors RebootDeviceForDeprecated(const std::string& reason); PowerErrors ShutDownDevice(const std::string& reason); - bool RegisterPowerStateCallback(const sptr& callback); + bool RegisterPowerStateCallback(const sptr& callback, bool isSync = true); bool UnRegisterPowerStateCallback(const sptr& callback); bool RegisterPowerModeCallback(const sptr& callback); bool UnRegisterPowerModeCallback(const sptr& callback); diff --git a/test/unittest/src/servicetest/powermgr_service_test_proxy.cpp b/test/unittest/src/servicetest/powermgr_service_test_proxy.cpp index 0d84140f..8164f790 100644 --- a/test/unittest/src/servicetest/powermgr_service_test_proxy.cpp +++ b/test/unittest/src/servicetest/powermgr_service_test_proxy.cpp @@ -555,7 +555,7 @@ bool PowerMgrServiceTestProxy::IsScreenOn(bool needPrintLog) return result; } -bool PowerMgrServiceTestProxy::RegisterPowerStateCallback(const sptr& callback) +bool PowerMgrServiceTestProxy::RegisterPowerStateCallback(const sptr& callback, bool isSync) { RETURN_IF_WITH_RET((stub_ == nullptr) || (callback == nullptr), false); @@ -569,6 +569,7 @@ bool PowerMgrServiceTestProxy::RegisterPowerStateCallback(const sptrAsObject()); + data.WriteBool(isSync); int ret = stub_->OnRemoteRequest( static_cast(PowerMgr::PowerMgrInterfaceCode::REG_POWER_STATE_CALLBACK), -- Gitee From df7e80d9071e66239f5e9427517815990a7fe8a9 Mon Sep 17 00:00:00 2001 From: wangyantian Date: Fri, 23 Aug 2024 20:40:34 +0800 Subject: [PATCH 2/2] feat: Add ut of OnAsyncPowerStateChanged interface Signed-off-by: wangyantian --- services/native/src/power_mgr_service.cpp | 3 +- services/native/src/power_state_machine.cpp | 6 +-- .../src/runninglock/running_lock_mgr.cpp | 9 ----- .../systemtest/src/power_mgr_st_mock_test.cpp | 3 ++ .../interface_test/power_state_machine_test.h | 2 + .../include/native_power_state_machine_test.h | 2 + .../power_state_machine_test.cpp | 40 ++++++++++++++++++- .../src/native_power_state_machine_test.cpp | 32 ++++++++++++++- .../src/power_mgr_client_native_test.cpp | 4 +- .../src/power_mgr_service_native_test.cpp | 3 +- 10 files changed, 84 insertions(+), 20 deletions(-) diff --git a/services/native/src/power_mgr_service.cpp b/services/native/src/power_mgr_service.cpp index a83a45c9..15fbc5bb 100644 --- a/services/native/src/power_mgr_service.cpp +++ b/services/native/src/power_mgr_service.cpp @@ -1096,7 +1096,8 @@ bool PowerMgrService::RegisterPowerStateCallback(const sptr if (!Permission::IsPermissionGranted("ohos.permission.POWER_MANAGER")) { return false; } - POWER_HILOGI(FEATURE_POWER_STATE, "%{public}s: pid: %{public}d, uid: %{public}d", __func__, pid, uid); + POWER_HILOGI(FEATURE_POWER_STATE, "%{public}s: pid: %{public}d, uid: %{public}d, isSync: %{public}u", __func__, pid, + uid, static_cast(isSync)); powerStateMachine_->RegisterPowerStateCallback(callback, isSync); return true; } diff --git a/services/native/src/power_state_machine.cpp b/services/native/src/power_state_machine.cpp index 1deb3db3..136419ef 100644 --- a/services/native/src/power_state_machine.cpp +++ b/services/native/src/power_state_machine.cpp @@ -852,12 +852,12 @@ void PowerStateMachine::NotifyPowerStateChanged(PowerState state) SendEventToPowerMgrNotify(state, now); // Call back all native function - for (auto& listener : syncPowerStateListeners_) { - listener->OnPowerStateChanged(state); - } for (auto& listener : asyncPowerStateListeners_) { listener->OnAsyncPowerStateChanged(state); } + for (auto& listener : syncPowerStateListeners_) { + listener->OnPowerStateChanged(state); + } } void PowerStateMachine::SendEventToPowerMgrNotify(PowerState state, int64_t callTime) diff --git a/services/native/src/runninglock/running_lock_mgr.cpp b/services/native/src/runninglock/running_lock_mgr.cpp index 0d6de8a3..f5720b7a 100644 --- a/services/native/src/runninglock/running_lock_mgr.cpp +++ b/services/native/src/runninglock/running_lock_mgr.cpp @@ -174,15 +174,6 @@ void RunningLockMgr::InitLocksTypeProximity() std::make_shared(RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL, [this](bool active, [[maybe_unused]] RunningLockParam runningLockParam) -> int32_t { POWER_HILOGD(FEATURE_RUNNING_LOCK, "RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL action start"); - auto pms = DelayedSpSingleton::GetInstance(); - if (pms == nullptr) { - return RUNNINGLOCK_FAILURE; - } - auto stateMachine = pms->GetPowerStateMachine(); - auto suspendController = pms->GetSuspendController(); - if (stateMachine == nullptr || suspendController == nullptr) { - return RUNNINGLOCK_FAILURE; - } if (active) { POWER_HILOGI(FEATURE_RUNNING_LOCK, "[UL_POWER] RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL active"); proximityController_.Enable(); diff --git a/test/systemtest/src/power_mgr_st_mock_test.cpp b/test/systemtest/src/power_mgr_st_mock_test.cpp index 079a8350..a3c16000 100644 --- a/test/systemtest/src/power_mgr_st_mock_test.cpp +++ b/test/systemtest/src/power_mgr_st_mock_test.cpp @@ -289,6 +289,7 @@ HWTEST_F(PowerMgrSTMockTest, PowerMgrMock071, TestSize.Level2) .WillOnce(::testing::Return(ActionResult::SUCCESS)); sleep(REFRESHACTIVITY_WAIT_TIME_S + ONE_SECOND); pms->Lock(token); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, std::string("test")); EXPECT_EQ(pms->IsUsed(token), true); pms->UnLock(token); @@ -328,6 +329,7 @@ HWTEST_F(PowerMgrSTMockTest, PowerMgrMock072, TestSize.Level2) .WillOnce(::testing::Return(ActionResult::SUCCESS)); sleep(REFRESHACTIVITY_WAIT_TIME_S + ONE_SECOND); pms->Lock(token); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, std::string("test")); EXPECT_EQ(pms->IsUsed(token), true); pms->UnLock(token); EXPECT_EQ(pms->IsUsed(token), false); @@ -386,6 +388,7 @@ HWTEST_F(PowerMgrSTMockTest, PowerMgrMock075, TestSize.Level2) RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); pms->CreateRunningLock(token, info); pms->Lock(token); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, std::string("test")); EXPECT_EQ(pms->IsUsed(token), true); EXPECT_EQ(PowerState::AWAKE, pms->GetState()); pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); diff --git a/test/unittest/include/interface_test/power_state_machine_test.h b/test/unittest/include/interface_test/power_state_machine_test.h index 7c23715f..d549dc87 100644 --- a/test/unittest/include/interface_test/power_state_machine_test.h +++ b/test/unittest/include/interface_test/power_state_machine_test.h @@ -50,12 +50,14 @@ public: PowerStateTest1Callback() {}; virtual ~PowerStateTest1Callback() {}; virtual void OnPowerStateChanged(PowerState state) override; + virtual void OnAsyncPowerStateChanged(PowerState state) override; }; class PowerStateTest2Callback : public PowerStateCallbackStub { public: PowerStateTest2Callback() {}; virtual ~PowerStateTest2Callback() {}; virtual void OnPowerStateChanged(PowerState state) override; + virtual void OnAsyncPowerStateChanged(PowerState state) override; }; private: }; diff --git a/test/unittest/include/native_power_state_machine_test.h b/test/unittest/include/native_power_state_machine_test.h index 559196f3..86bf2fa0 100644 --- a/test/unittest/include/native_power_state_machine_test.h +++ b/test/unittest/include/native_power_state_machine_test.h @@ -53,6 +53,7 @@ public: PowerStateTest1Callback() {}; virtual ~PowerStateTest1Callback() {}; virtual void OnPowerStateChanged(PowerState state) override; + virtual void OnAsyncPowerStateChanged(PowerState state) override; }; class PowerStateTest2Callback : public PowerStateCallbackStub { @@ -60,6 +61,7 @@ public: PowerStateTest2Callback() {}; virtual ~PowerStateTest2Callback() {}; virtual void OnPowerStateChanged(PowerState state) override; + virtual void OnAsyncPowerStateChanged(PowerState state) override; }; } // namespace PowerMgr } // namespace OHOS diff --git a/test/unittest/src/interface_test/power_state_machine_test.cpp b/test/unittest/src/interface_test/power_state_machine_test.cpp index 98a43ede..a95e43fd 100644 --- a/test/unittest/src/interface_test/power_state_machine_test.cpp +++ b/test/unittest/src/interface_test/power_state_machine_test.cpp @@ -195,13 +195,25 @@ HWTEST_F (PowerStateMachineTest, PowerStateMachine007, TestSize.Level0) void PowerStateMachineTest::PowerStateTest1Callback::OnPowerStateChanged(PowerState state) { - POWER_HILOGI(LABEL_TEST, "PowerStateTest1Callback::OnPowerStateChanged state = %u.", + POWER_HILOGI( + LABEL_TEST, "PowerStateTest1Callback::OnPowerStateChanged state = %{public}u.", static_cast(state)); +} + +void PowerStateMachineTest::PowerStateTest1Callback::OnAsyncPowerStateChanged(PowerState state) +{ + POWER_HILOGI(LABEL_TEST, "PowerStateTest1Callback::OnAsyncPowerStateChanged state = %{public}u.", static_cast(state)); } void PowerStateMachineTest::PowerStateTest2Callback::OnPowerStateChanged(PowerState state) { - POWER_HILOGI(LABEL_TEST, "PowerStateTest2Callback::OnPowerStateChanged state = %u.", + POWER_HILOGI( + LABEL_TEST, "PowerStateTest2Callback::OnPowerStateChanged state = %{public}u.", static_cast(state)); +} + +void PowerStateMachineTest::PowerStateTest2Callback::OnAsyncPowerStateChanged(PowerState state) +{ + POWER_HILOGI(LABEL_TEST, "PowerStateTest2Callback::OnAsyncPowerStateChanged state = %{public}u.", static_cast(state)); } @@ -229,6 +241,30 @@ HWTEST_F (PowerStateMachineTest, PowerStateCallback001, TestSize.Level0) EXPECT_TRUE(powerMgrClient.UnRegisterPowerStateCallback(cb1)); POWER_HILOGI(LABEL_TEST, "PowerStateTestCallback::PowerStateCallback001 end."); } + +/** + * @tc.name: PowerStateCallback002 + * @tc.desc: test PowerStateCallback + * @tc.type: FUNC + */ +HWTEST_F (PowerStateMachineTest, PowerStateCallback002, TestSize.Level0) +{ + auto& powerMgrClient = PowerMgrClient::GetInstance(); + sptr cb1 = new PowerStateTest1Callback(); + powerMgrClient.RegisterPowerStateCallback(cb1, false); + POWER_HILOGI(LABEL_TEST, "PowerStateCallback002 1."); + { + sptr cb2 = new PowerStateTest2Callback(); + powerMgrClient.UnRegisterPowerStateCallback(cb2); + POWER_HILOGI(LABEL_TEST, "PowerStateCallback002 2."); + powerMgrClient.RegisterPowerStateCallback(cb2, false); + POWER_HILOGI(LABEL_TEST, "PowerStateCallback002 3."); + powerMgrClient.RegisterPowerStateCallback(cb2, false); + POWER_HILOGI(LABEL_TEST, "PowerStateCallback002 4."); + } + EXPECT_TRUE(powerMgrClient.UnRegisterPowerStateCallback(cb1)); + POWER_HILOGI(LABEL_TEST, "PowerStateTestCallback::PowerStateCallback002 end."); +} } void PowerStateMachineTest::WakeUpthread() diff --git a/test/unittest/src/native_power_state_machine_test.cpp b/test/unittest/src/native_power_state_machine_test.cpp index 4fc2b911..2cdceb2f 100644 --- a/test/unittest/src/native_power_state_machine_test.cpp +++ b/test/unittest/src/native_power_state_machine_test.cpp @@ -28,12 +28,26 @@ void NativePowerStateMachineTest::SetUpTestCase() {} void PowerStateTest1Callback::OnPowerStateChanged(PowerState state) { - POWER_HILOGI(LABEL_TEST, "PowerStateTest1Callback::OnPowerStateChanged state = %u.", static_cast(state)); + POWER_HILOGI( + LABEL_TEST, "PowerStateTest1Callback::OnPowerStateChanged state = %{public}u.", static_cast(state)); +} + +void PowerStateTest1Callback::OnAsyncPowerStateChanged(PowerState state) +{ + POWER_HILOGI(LABEL_TEST, "PowerStateTest1Callback::OnAsyncPowerStateChanged state = %{public}u.", + static_cast(state)); } void PowerStateTest2Callback::OnPowerStateChanged(PowerState state) { - POWER_HILOGI(LABEL_TEST, "PowerStateTest1Callback::OnPowerStateChanged state = %u.", static_cast(state)); + POWER_HILOGI( + LABEL_TEST, "PowerStateTest2Callback::OnPowerStateChanged state = %{public}u.", static_cast(state)); +} + +void PowerStateTest2Callback::OnAsyncPowerStateChanged(PowerState state) +{ + POWER_HILOGI(LABEL_TEST, "PowerStateTest2Callback::OnAsyncPowerStateChanged state = %{public}u.", + static_cast(state)); } namespace { @@ -98,6 +112,7 @@ HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine002, TestSize.Level EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true)); stateMachine->UnRegisterPowerStateCallback(cb); sptr cb1 = new PowerStateTest2Callback(); + stateMachine->RegisterPowerStateCallback(cb1); stateMachine->UnRegisterPowerStateCallback(cb1); sptr cb2 = nullptr; stateMachine->RegisterPowerStateCallback(cb2); @@ -105,6 +120,19 @@ HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine002, TestSize.Level stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT, true); EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true)); + sptr cb3 = new PowerStateTest1Callback(); + stateMachine->RegisterPowerStateCallback(cb3, false); + stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true); + EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true)); + stateMachine->UnRegisterPowerStateCallback(cb3); + sptr cb4 = new PowerStateTest2Callback(); + sptr cb5 = nullptr; + stateMachine->RegisterPowerStateCallback(cb4, false); + stateMachine->RegisterPowerStateCallback(cb5, false); + stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT, true); + EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true)); + stateMachine->UnRegisterPowerStateCallback(cb4); + stateMachine->UnRegisterPowerStateCallback(cb5); POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine002::fun is end!"); GTEST_LOG_(INFO) << "NativePowerStateMachine002: Suspend Device end."; } diff --git a/test/unittest/src/power_mgr_client_native_test.cpp b/test/unittest/src/power_mgr_client_native_test.cpp index 4f23e768..35759147 100644 --- a/test/unittest/src/power_mgr_client_native_test.cpp +++ b/test/unittest/src/power_mgr_client_native_test.cpp @@ -37,8 +37,8 @@ using namespace std; void PowerStateTestCallback::OnPowerStateChanged(PowerState state) { - POWER_HILOGI(LABEL_TEST, "PowerStateTestCallback::OnPowerStateChanged state = %u.", - static_cast(state)); + POWER_HILOGI( + LABEL_TEST, "PowerStateTestCallback::OnPowerStateChanged state = %{public}u.", static_cast(state)); } namespace { diff --git a/test/unittest/src/power_mgr_service_native_test.cpp b/test/unittest/src/power_mgr_service_native_test.cpp index a6ca3d50..bf80d38c 100644 --- a/test/unittest/src/power_mgr_service_native_test.cpp +++ b/test/unittest/src/power_mgr_service_native_test.cpp @@ -72,7 +72,8 @@ void PowerMgrServiceNativeTest::TearDown() void PowerStateTestCallback::OnPowerStateChanged(PowerState state) { - POWER_HILOGI(LABEL_TEST, "PowerStateTestCallback::OnPowerStateChanged state = %u.", static_cast(state)); + POWER_HILOGI( + LABEL_TEST, "PowerStateTestCallback::OnPowerStateChanged state = %{public}u.", static_cast(state)); } namespace { -- Gitee