From ccc1d8d8097747e3f0ffa46a89f382dc907e150c Mon Sep 17 00:00:00 2001 From: ShiJIe Date: Thu, 29 Jul 2021 13:26:32 +0800 Subject: [PATCH 01/11] add OAT.xml Signed-off-by: ShiJIe --- OAT.xml | 381 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 381 insertions(+) create mode 100644 OAT.xml diff --git a/OAT.xml b/OAT.xml new file mode 100644 index 00000000..f38256f8 --- /dev/null +++ b/OAT.xml @@ -0,0 +1,381 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + -- Gitee From 44c9e11258d5280309bb19ff6a6ed9d87e552c41 Mon Sep 17 00:00:00 2001 From: ShiJIe Date: Thu, 29 Jul 2021 15:38:33 +0800 Subject: [PATCH 02/11] Delete default configuration Signed-off-by: ShiJIe --- OAT.xml | 360 +------------------------------------------------------- 1 file changed, 2 insertions(+), 358 deletions(-) diff --git a/OAT.xml b/OAT.xml index f38256f8..230f70b5 100644 --- a/OAT.xml +++ b/OAT.xml @@ -12,370 +12,14 @@ 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. - - This is the configuration file template for OpenHarmony OSS Audit Tool, please copy it to your project root dir and modify it refer to OpenHarmony/tools_oat/README. --> + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -- Gitee From 02bc87376f6d20c571ed40ae3bd2d63472e821fa Mon Sep 17 00:00:00 2001 From: ShiJIe Date: Thu, 29 Jul 2021 17:40:28 +0800 Subject: [PATCH 03/11] Modify comments Signed-off-by: ShiJIe --- OAT.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/OAT.xml b/OAT.xml index 230f70b5..131151bd 100644 --- a/OAT.xml +++ b/OAT.xml @@ -17,7 +17,7 @@ - + -- Gitee From 9969e17820e693a2d3100d4c446dd51c0ac8930a Mon Sep 17 00:00:00 2001 From: Du Jiang Date: Fri, 16 Jul 2021 15:50:25 +0800 Subject: [PATCH 04/11] Enhance power manager features Optimize JS interface and PowerMgrClient. Put RunningLock class into power interface, because RunningLock is created by power. It's better to use same namespace. Add power state management in PowerStateMachine. Manage RunningLock with state machine. Add power napi to support JS interfaces. Add new interface for power, and fix bugs. Move cpp source code from innerkits to frameworks. There are only header files in intefaces folder. Call new interface of DisplayPowerManager. Change-Id: I7a743ceea498cb28b07d1eb4945a11f5544a9fbc --- frameworks/include/power_manager_napi.h | 64 +++ frameworks/include/power_napi_base.h | 69 +++ frameworks/include/running_lock_napi.h | 55 +++ frameworks/napi/power_manager_napi.cpp | 416 ++++++++++++++++++ frameworks/napi/power_napi_base.cpp | 167 +++++++ frameworks/napi/running_lock_napi.cpp | 237 ++++++++++ .../native}/power_mgr_client.cpp | 16 + .../native}/running_lock.cpp | 54 ++- .../native}/running_lock_info.cpp | 0 .../native}/running_lock_token_stub.cpp | 0 interfaces/innerkits/BUILD.gn | 8 +- .../innerkits/native/include/ipower_mgr.h | 10 +- .../native/include/power_mgr_client.h | 14 +- .../native/include/power_state_machine_info.h | 39 +- .../innerkits/native/include/running_lock.h | 10 +- interfaces/kits/js/@ohos.power.d.ts | 192 ++++++-- interfaces/kits/js/@ohos.runninglock.d.ts | 108 ----- interfaces/kits/js/BUILD.gn | 75 ++++ ohos.build | 4 +- powermgr.gni | 2 + .../include/actions/idevice_state_action.h | 9 + services/native/include/power_mgr_service.h | 4 + services/native/include/power_state_machine.h | 54 ++- .../native/include/powerms_event_handler.h | 2 + services/native/include/running_lock_inner.h | 2 +- services/native/include/running_lock_mgr.h | 63 ++- services/native/src/actions/default/BUILD.gn | 1 + .../actions/default/device_state_action.cpp | 67 ++- .../src/actions/default/device_state_action.h | 3 + services/native/src/power_mgr_service.cpp | 45 +- services/native/src/power_state_machine.cpp | 394 ++++++++++++++++- services/native/src/powerms_event_handler.cpp | 8 +- services/native/src/running_lock_mgr.cpp | 231 ++++++++-- services/zidl/include/power_mgr_proxy.h | 4 + services/zidl/include/power_mgr_stub.h | 4 + services/zidl/src/power_mgr_proxy.cpp | 106 +++++ services/zidl/src/power_mgr_stub.cpp | 48 ++ 37 files changed, 2349 insertions(+), 236 deletions(-) create mode 100644 frameworks/include/power_manager_napi.h create mode 100644 frameworks/include/power_napi_base.h create mode 100644 frameworks/include/running_lock_napi.h create mode 100644 frameworks/napi/power_manager_napi.cpp create mode 100644 frameworks/napi/power_napi_base.cpp create mode 100644 frameworks/napi/running_lock_napi.cpp rename {interfaces/innerkits/native/src => frameworks/native}/power_mgr_client.cpp (95%) rename {interfaces/innerkits/native/src => frameworks/native}/running_lock.cpp (77%) rename {interfaces/innerkits/native/src => frameworks/native}/running_lock_info.cpp (100%) rename {interfaces/innerkits/native/src => frameworks/native}/running_lock_token_stub.cpp (100%) delete mode 100644 interfaces/kits/js/@ohos.runninglock.d.ts create mode 100644 interfaces/kits/js/BUILD.gn diff --git a/frameworks/include/power_manager_napi.h b/frameworks/include/power_manager_napi.h new file mode 100644 index 00000000..3409e7b4 --- /dev/null +++ b/frameworks/include/power_manager_napi.h @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2021 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 POWERMGR_POWER_MANAGER_NAPI_H +#define POWERMGR_POWER_MANAGER_NAPI_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" +#include "power_mgr_client.h" +#include "power_napi_base.h" + +namespace OHOS { +namespace PowerMgr { + +class ShutdownContext : public PowerNapiContext { +public: + using PowerNapiContext::PowerNapiContext; + const std::string reason_; +protected: + virtual void Init(napi_value* args, uint32_t argc) override; +}; + + +class PowerManagerNapi { +public: + static napi_value Init(napi_env env, napi_value exports); +private: + PowerManagerNapi() = default; + ~PowerManagerNapi() = default; + static napi_value IsRunningLockTypeSupported(napi_env env, napi_callback_info info); + static napi_value CreateRunningLock(napi_env env, napi_callback_info info); + static napi_value ShutdownDevice(napi_env env, napi_callback_info info); + static napi_value RebootDevice(napi_env env, napi_callback_info info); + static napi_value IsScreenOn(napi_env env, napi_callback_info info); + static napi_value GetState(napi_env env, napi_callback_info info); + static napi_value GetMode(napi_env env, napi_callback_info info); + static napi_value InitRunningLockType(napi_env env, napi_value exports); + static napi_value InitPowerState(napi_env env, napi_value exports); + static napi_value InitPowerMode(napi_env env, napi_value exports); + static napi_value EnumRunningLockTypeConstructor(napi_env env, napi_callback_info info); + static napi_value EnumPowerStateConstructor(napi_env env, napi_callback_info info); + static napi_value EnumPowerModeConstructor(napi_env env, napi_callback_info info); + + static napi_ref runningLockTypeConstructor_; + static napi_ref powerStateConstructor_; + static napi_ref powerModeConstructor_; +}; + +} // namespace PowerMgr +} // namespace OHOS + +#endif //POWERMGR_POWER_MANAGER_NAPI_H diff --git a/frameworks/include/power_napi_base.h b/frameworks/include/power_napi_base.h new file mode 100644 index 00000000..9cba8a2d --- /dev/null +++ b/frameworks/include/power_napi_base.h @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2021 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 POWERMGR_POWER_NAPI_BASE_H +#define POWERMGR_POWER_NAPI_BASE_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" +#include "power_mgr_client.h" + +namespace OHOS { +namespace PowerMgr { + +enum AsyncStatus { + PENDING, + RESOLVED, + REJECTED, +}; + +class PowerNapiContext { + +using FreeFunc = std::function; +using ExecuteFunc = std::function; + +public: + PowerNapiContext(napi_env env, napi_value* args, uint32_t argc, + int32_t callbackArg, uint32_t cbParamCount, napi_value object = nullptr); + virtual ~PowerNapiContext(); + bool StartAsyncWork(const char* workName, ExecuteFunc exeFunc, FreeFunc freeFunc); + napi_value GetPromise() { return promise_; } + napi_env env_; + napi_value outValue_; +protected: + static void ExecuteAsyncWork(napi_env env, void *data); + static void CompleteAsyncWork(napi_env env, napi_status status, void *data); + + virtual void Init(napi_value* args, uint32_t argc); + virtual napi_value GetPromiseValue(); //default function is for Promise + virtual napi_value GetError(); //default function is always return undefined + //default function is for AsyncCallback + virtual void GetCallbackValues(napi_value* values, uint32_t size); + + uint32_t cbParamCount_; + napi_value object_; + napi_deferred deferred_; + napi_ref callbackRef_; + napi_async_work asyncWork_; + napi_value promise_; + ExecuteFunc exeFunc_; + FreeFunc freeFunc_; + AsyncStatus status_; +}; + +} // namespace PowerMgr +} // namespace OHOS + +#endif //POWERMGR_POWER_NAPI_BASE_H diff --git a/frameworks/include/running_lock_napi.h b/frameworks/include/running_lock_napi.h new file mode 100644 index 00000000..cb560bf8 --- /dev/null +++ b/frameworks/include/running_lock_napi.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2021 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 POWERMGR_RUNNING_LOCK_NAPI_H +#define POWERMGR_RUNNING_LOCK_NAPI_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" +#include "power_mgr_client.h" +#include "power_napi_base.h" + +namespace OHOS { +namespace PowerMgr { + +class RunningLockWrapper { +public: + RunningLockWrapper(std::shared_ptr lock) : lock_ptr(lock) {} + ~RunningLockWrapper() = default; + std::shared_ptr lock_ptr; +}; + +class RunningLockNapi { +public: + static napi_value InitRunningLockClass(napi_env env, napi_value exports); + static bool CreateRunningLock(napi_env env, napi_callback_info info, napi_value* result); +private: + RunningLockNapi() = default; + ~RunningLockNapi() = default; + static napi_value Lock(napi_env env, napi_callback_info info); + static napi_value IsUsed(napi_env env, napi_callback_info info); + static napi_value Unlock(napi_env env, napi_callback_info info); + + static void RemoveRunningLock(napi_env env, void* finalize_data, void* finalize_hint); + static napi_value ConstructRunningLockObject(napi_env env, napi_callback_info info); + static bool GetNativeLock(napi_env env, napi_value object, RunningLockWrapper** lock); + + static napi_ref runningLockConstructor_; +}; + +} // namespace PowerMgr +} // namespace OHOS + +#endif //POWERMGR_RUNNING_LOCK_NAPI_H diff --git a/frameworks/napi/power_manager_napi.cpp b/frameworks/napi/power_manager_napi.cpp new file mode 100644 index 00000000..9e357926 --- /dev/null +++ b/frameworks/napi/power_manager_napi.cpp @@ -0,0 +1,416 @@ +/* + * Copyright (c) 2021 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 +#include +#include +#include +#include "power_common.h" +#include "power_manager_napi.h" +#include "running_lock_napi.h" + +using namespace OHOS::PowerMgr; + +#define REASON_STRING_MAX (128) +#define LOCK_NAME_STRING_MAX (128) + +napi_ref PowerManagerNapi::runningLockTypeConstructor_ = nullptr; +napi_ref PowerManagerNapi::powerStateConstructor_ = nullptr; +napi_ref PowerManagerNapi::powerModeConstructor_ = nullptr; + +void ShutdownContext::Init(napi_value* args, uint32_t argc) +{ + if (argc < 1) { + return; + } + size_t out; + char reason[REASON_STRING_MAX]; + napi_get_value_string_latin1(env_, args[0], reason, REASON_STRING_MAX, &out); + reason_.copy(reason, strlen(reason), 0); +} + +napi_value PowerManagerNapi::Init(napi_env env, napi_value exports) +{ + napi_property_descriptor desc[] = { + DECLARE_NAPI_STATIC_FUNCTION("isRunningLockTypeSupported", IsRunningLockTypeSupported), + DECLARE_NAPI_STATIC_FUNCTION("createRunningLock", CreateRunningLock), + DECLARE_NAPI_STATIC_FUNCTION("shutownDevice", ShutdownDevice), + DECLARE_NAPI_STATIC_FUNCTION("rebootDevice", RebootDevice), + DECLARE_NAPI_STATIC_FUNCTION("isScreenOn", IsScreenOn), + DECLARE_NAPI_STATIC_FUNCTION("getState", GetState), + DECLARE_NAPI_STATIC_FUNCTION("getMode", GetMode), + }; + NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); + + RunningLockNapi::InitRunningLockClass(env, exports); + PowerManagerNapi::InitRunningLockType(env, exports); + PowerManagerNapi::InitPowerState(env, exports); + PowerManagerNapi::InitPowerMode(env, exports); + + return exports; +} + +napi_value PowerManagerNapi::IsRunningLockTypeSupported(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "enter"); + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_value jsthis; + void *data = nullptr; + uint32_t result; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); + NAPI_ASSERT(env, (status == napi_ok) && (argc >= 1), "Not enough parameters"); + + napi_valuetype type; + NAPI_CALL(env, napi_typeof(env, args[0], &type)); + NAPI_ASSERT(env, type == napi_number, "Wrong type of 1st parameter. number expected."); + + napi_get_value_uint32(env, args[0], &result); + + PowerNapiContext* context = new PowerNapiContext(env, args, argc, 1, 1); + + napi_value promise = context->GetPromise(); + context->StartAsyncWork("Power::IsRunningLockTypeSupported", + [context, result] { + bool ret = PowerMgrClient::GetInstance().IsRunningLockTypeSupported(result); + napi_get_boolean(context->env_, ret, &context->outValue_); + return true; + }, + [](PowerNapiContext* object) { delete object; } + ); + + POWER_HILOGD(MODULE_JS_NAPI, "return"); + return promise; +} + +napi_value PowerManagerNapi::CreateRunningLock(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "enter"); + size_t argc = 3; + napi_value args[3] = { 0 }; + napi_value jsthis; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); + NAPI_ASSERT(env, (status == napi_ok) && (argc >= 2), "Not enough parameters"); + + napi_valuetype type; + NAPI_CALL(env, napi_typeof(env, args[0], &type)); + NAPI_ASSERT(env, type == napi_string, "Wrong type of 1st parameter. string expected."); + NAPI_CALL(env, napi_typeof(env, args[1], &type)); + NAPI_ASSERT(env, type == napi_number, "Wrong type of 2st parameter. number expected."); + + char name[LOCK_NAME_STRING_MAX]; + size_t size; + napi_get_value_string_latin1(env, args[0], name, LOCK_NAME_STRING_MAX, &size); + uint32_t lockType; + napi_get_value_uint32(env, args[1], &lockType); + NAPI_ASSERT(env, lockType < static_cast(RunningLockType::RUNNINGLOCK_BUTT), + "RunningLock Type is not supported"); + + PowerNapiContext* context = new PowerNapiContext(env, args, argc, 2, 1); + + napi_value promise = context->GetPromise(); + context->StartAsyncWork("Power::CreateRunningLock", + [env, info, context] { + return RunningLockNapi::CreateRunningLock(env, info, &context->outValue_); + }, + [](PowerNapiContext* object) { delete object; } + ); + + POWER_HILOGD(MODULE_JS_NAPI, "return"); + return promise; +} + +napi_value PowerManagerNapi::ShutdownDevice(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "enter"); + uint32_t argc = 2; + napi_value args[2] = { 0 }; + napi_value jsthis; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); + NAPI_ASSERT(env, (status == napi_ok) && (argc >= 1), "Not enough parameters"); + + napi_valuetype type; + NAPI_CALL(env, napi_typeof(env, args[0], &type)); + NAPI_ASSERT(env, type == napi_string, "Wrong argument type. string expected."); + + ShutdownContext* context = new ShutdownContext(env, args, argc, 1, 0); + + napi_value promise = context->GetPromise(); + context->StartAsyncWork("Power::ShutdownDevice", + [context] { + PowerMgrClient::GetInstance().ShutDownDevice(context->reason_); + return true; + }, + [](PowerNapiContext* object) { delete object; } + ); + + POWER_HILOGD(MODULE_JS_NAPI, "return"); + return promise; +} + +napi_value PowerManagerNapi::RebootDevice(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "enter"); + uint32_t argc = 2; + napi_value args[2] = { 0 }; + napi_value jsthis; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); + NAPI_ASSERT(env, (status == napi_ok) && (argc >= 1), "Not enough parameters"); + + napi_valuetype type; + NAPI_CALL(env, napi_typeof(env, args[0], &type)); + NAPI_ASSERT(env, type == napi_string, "Wrong argument type. string expected."); + + ShutdownContext* context = new ShutdownContext(env, args, argc, 1, 0); + + napi_value promise = context->GetPromise(); + context->StartAsyncWork("Power::RebootDevice", + [context] { + PowerMgrClient::GetInstance().RebootDevice(context->reason_); + return true; + }, + [](PowerNapiContext* object) { delete object; } + ); + + POWER_HILOGD(MODULE_JS_NAPI, "return"); + return promise; +} + +napi_value PowerManagerNapi::IsScreenOn(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "enter"); + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_value jsthis; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); + NAPI_ASSERT(env, (status == napi_ok) && (argc >= 0), "Bad parameters"); + + PowerNapiContext* context = new PowerNapiContext(env, args, argc, 0, 1); + + napi_value promise = context->GetPromise(); + context->StartAsyncWork("Power::IsScreenOn", + [context] { + bool ret = PowerMgrClient::GetInstance().IsScreenOn(); + napi_get_boolean(context->env_, ret, &context->outValue_); + return true; + }, + [](PowerNapiContext* object) { delete object; } + ); + + POWER_HILOGD(MODULE_JS_NAPI, "return"); + return promise; +} + +napi_value PowerManagerNapi::GetState(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "enter"); + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_value jsthis; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); + NAPI_ASSERT(env, (status == napi_ok) && (argc >= 0), "Bad parameters"); + + PowerNapiContext* context = new PowerNapiContext(env, args, argc, 0, 1); + + napi_value promise = context->GetPromise(); + context->StartAsyncWork("Power::GetState", + [context] { + PowerState state = PowerMgrClient::GetInstance().GetState(); + napi_create_uint32(context->env_, static_cast(state), &context->outValue_); + return true; + }, + [](PowerNapiContext* object) { delete object; } + ); + + POWER_HILOGD(MODULE_JS_NAPI, "return"); + return promise; +} + +napi_value PowerManagerNapi::GetMode(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "enter"); + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_value jsthis; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); + NAPI_ASSERT(env, (status == napi_ok) && (argc >= 0), "Bad parameters"); + + PowerNapiContext* context = new PowerNapiContext(env, args, argc, 0, 1); + + napi_value promise = context->GetPromise(); + context->StartAsyncWork("Power::GetState", + [context] { + const char* error = "GetMode is unsupported"; + napi_create_string_utf8(context->env_, error, strlen(error), &context->outValue_); + return false; + }, + [context](PowerNapiContext* object) { delete context; } + ); + + POWER_HILOGD(MODULE_JS_NAPI, "return"); + return promise; +} + +napi_value PowerManagerNapi::InitRunningLockType(napi_env env, napi_value exports) +{ + napi_value background; + napi_value proximity; + int32_t refCount = 1; + + napi_create_uint32(env, static_cast(RunningLockType::RUNNINGLOCK_BACKGROUND), &background); + napi_create_uint32(env, static_cast(RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL), &proximity); + + napi_property_descriptor desc[] = { + DECLARE_NAPI_STATIC_PROPERTY("BACKGROUND", background), + DECLARE_NAPI_STATIC_PROPERTY("PROXIMITY_SCREEN_CONTROL", proximity), + }; + + napi_value result = nullptr; + napi_define_class(env, "RunningLockType", NAPI_AUTO_LENGTH, EnumRunningLockTypeConstructor, nullptr, + sizeof(desc) / sizeof(*desc), desc, &result); + napi_create_reference(env, result, refCount, &runningLockTypeConstructor_); + napi_set_named_property(env, exports, "RunningLockType", result); + + return exports; +} + +napi_value PowerManagerNapi::InitPowerState(napi_env env, napi_value exports) +{ + napi_value awake; + napi_value inactive; + napi_value sleep; + int32_t refCount = 1; + + napi_create_uint32(env, static_cast(PowerState::AWAKE), &awake); + napi_create_uint32(env, static_cast(PowerState::INACTIVE), &inactive); + napi_create_uint32(env, static_cast(PowerState::SLEEP), &sleep); + + napi_property_descriptor desc[] = { + DECLARE_NAPI_STATIC_PROPERTY("AWAKE", awake), + DECLARE_NAPI_STATIC_PROPERTY("INACTIVE", inactive), + DECLARE_NAPI_STATIC_PROPERTY("SLEEP", sleep), + }; + + napi_value result = nullptr; + napi_define_class(env, "PowerState", NAPI_AUTO_LENGTH, EnumPowerStateConstructor, nullptr, + sizeof(desc) / sizeof(*desc), desc, &result); + napi_create_reference(env, result, refCount, &powerStateConstructor_); + napi_set_named_property(env, exports, "PowerState", result); + + return exports; +} + +napi_value PowerManagerNapi::InitPowerMode(napi_env env, napi_value exports) +{ + napi_value normal; + napi_value power_save; + int32_t refCount = 1; + + napi_create_uint32(env, 0, &normal); + napi_create_uint32(env, 1, &power_save); + + napi_property_descriptor desc[] = { + DECLARE_NAPI_STATIC_PROPERTY("NORMAL", normal), + DECLARE_NAPI_STATIC_PROPERTY("POWER_SAVE", power_save), + }; + + napi_value result = nullptr; + napi_define_class(env, "PowerMode", NAPI_AUTO_LENGTH, EnumPowerModeConstructor, nullptr, + sizeof(desc) / sizeof(*desc), desc, &result); + napi_create_reference(env, result, refCount, &powerModeConstructor_); + napi_set_named_property(env, exports, "PowerMode", result); + + return exports; +} + +napi_value PowerManagerNapi::EnumRunningLockTypeConstructor(napi_env env, napi_callback_info info) +{ + napi_value thisArg = nullptr; + void *data = nullptr; + + napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data); + + return thisArg; +} + +napi_value PowerManagerNapi::EnumPowerStateConstructor(napi_env env, napi_callback_info info) +{ + napi_value thisArg = nullptr; + void *data = nullptr; + + napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data); + + return thisArg; +} + +napi_value PowerManagerNapi::EnumPowerModeConstructor(napi_env env, napi_callback_info info) +{ + napi_value thisArg = nullptr; + void *data = nullptr; + + napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data); + + return thisArg; +} + +EXTERN_C_START +/* + * function for module exports + */ +static napi_value PowerInit(napi_env env, napi_value exports) +{ + POWER_HILOGD(MODULE_JS_NAPI, "enter"); + + napi_value ret = PowerManagerNapi::Init(env, exports); + + POWER_HILOGD(MODULE_JS_NAPI, "return"); + + return ret; +} +EXTERN_C_END + +/* + * Module definition + */ +static napi_module g_module = { + .nm_version = 1, + .nm_flags = 0, + .nm_filename = "power", + .nm_register_func = PowerInit, + .nm_modname = "power", + .nm_priv = ((void *)0), + .reserved = {0} +}; + +/* + * Module registration + */ +extern "C" __attribute__((constructor)) void RegisterModule(void) +{ + napi_module_register(&g_module); +} diff --git a/frameworks/napi/power_napi_base.cpp b/frameworks/napi/power_napi_base.cpp new file mode 100644 index 00000000..26ec2a21 --- /dev/null +++ b/frameworks/napi/power_napi_base.cpp @@ -0,0 +1,167 @@ +/* + * Copyright (c) 2021 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 "power_common.h" +#include "power_napi_base.h" + +using namespace OHOS::PowerMgr; + +PowerNapiContext::PowerNapiContext(napi_env env, napi_value* args, uint32_t argc, + int32_t callbackArg, uint32_t cbParamCount, napi_value object) + : env_(env), cbParamCount_(cbParamCount), object_(object), + deferred_(nullptr), callbackRef_(nullptr), asyncWork_(nullptr), status_(AsyncStatus::PENDING) +{ + POWER_HILOGE(MODULE_INNERKIT, "%{public}s called.", __func__); + if (callbackArg >= 0 && callbackArg < static_cast(argc)) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, args[callbackArg], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, args[callbackArg], 1, &callbackRef_); + } + } + if (callbackRef_ == nullptr) { + napi_create_promise(env, &deferred_, &promise_); + } else { + napi_get_undefined(env, &promise_); + } + napi_get_undefined(env_, &outValue_); + Init(args, argc); +} + +PowerNapiContext::~PowerNapiContext() +{ + if (deferred_) { + napi_reject_deferred(env_, deferred_, GetError()); + } + if (callbackRef_) { + napi_delete_reference(env_, callbackRef_); + } + if (asyncWork_) { + napi_delete_async_work(env_, asyncWork_); + } +} + +void PowerNapiContext::ExecuteAsyncWork(napi_env env, void *data) +{ + PowerNapiContext* context = (PowerNapiContext*)data; + if (context->exeFunc_) { + bool ret = context->exeFunc_(); + POWER_HILOGI(MODULE_JS_NAPI, "execute work: %d", ret); + if (ret) { + context->status_ = AsyncStatus::RESOLVED; + } else { + context->status_ = AsyncStatus::REJECTED; + } + } else { + POWER_HILOGW(MODULE_JS_NAPI, "execute work: no exeFunc"); + context->status_ = AsyncStatus::REJECTED; + } +} + +void PowerNapiContext::CompleteAsyncWork(napi_env env, napi_status status, void *data) +{ + PowerNapiContext* context = (PowerNapiContext*)data; + if (context->deferred_) { + if (context->status_ == AsyncStatus::RESOLVED) { + POWER_HILOGI(MODULE_JS_NAPI, "work complete: resolved"); + napi_resolve_deferred(env, context->deferred_, context->GetPromiseValue()); + } else { + POWER_HILOGI(MODULE_JS_NAPI, "work complete: rejected"); + napi_reject_deferred(env, context->deferred_, context->GetError()); + } + context->deferred_ = nullptr; + } else if (context->callbackRef_) { + POWER_HILOGI(MODULE_JS_NAPI, "work complete: callback"); + napi_value result = 0; + napi_value callback = nullptr; + napi_get_reference_value(env, context->callbackRef_, &callback); + napi_value* values = nullptr; + uint32_t count = context->cbParamCount_; + if (count > 0) { + values = new napi_value[context->cbParamCount_]; + context->GetCallbackValues(values, count); + } else { + count = 1; + values = new napi_value[1]; + napi_get_undefined(env, &values[0]); + } + + napi_call_function(env, context->object_, callback, context->cbParamCount_, values, &result); + napi_delete_reference(env, context->callbackRef_); + if (values != nullptr) { + delete values; + } + context->callbackRef_ = nullptr; + } else { + POWER_HILOGE(MODULE_JS_NAPI, "work complete: nothing"); + } + napi_delete_async_work(env, context->asyncWork_); + context->asyncWork_ = nullptr; + if ( context->freeFunc_) { + context->freeFunc_(context); + } +} + +bool PowerNapiContext::StartAsyncWork(const char* workName, ExecuteFunc exeFunc, FreeFunc freeFunc) +{ + napi_status status; + + napi_value resourceName; + napi_create_string_latin1(this->env_, workName, NAPI_AUTO_LENGTH, &resourceName); + + exeFunc_ = exeFunc; + freeFunc_ = freeFunc; + + status = napi_create_async_work( + this->env_, + nullptr, + resourceName, + ExecuteAsyncWork, + CompleteAsyncWork, + (void *)this, + &asyncWork_); + + if (status != napi_ok) { + POWER_HILOGE(MODULE_JS_NAPI, "CreateAsyncWork failed: %d", status); + return false; + } + napi_queue_async_work(this->env_, asyncWork_); + + return true; +} + +void PowerNapiContext::Init(napi_value* args, uint32_t argc) +{ + // do nothing in base class +} + +napi_value PowerNapiContext::GetPromiseValue() +{ + return outValue_; +} + +napi_value PowerNapiContext::GetError() +{ + return outValue_; +} + +void PowerNapiContext::GetCallbackValues(napi_value* values, uint32_t size) +{ + if (size == 0) { + return; + } + values[0] = GetPromiseValue(); + return; +} diff --git a/frameworks/napi/running_lock_napi.cpp b/frameworks/napi/running_lock_napi.cpp new file mode 100644 index 00000000..86b69390 --- /dev/null +++ b/frameworks/napi/running_lock_napi.cpp @@ -0,0 +1,237 @@ +/* + * Copyright (c) 2021 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 +#include +#include +#include "power_common.h" +#include "running_lock_napi.h" + + +using namespace OHOS::PowerMgr; + +#define LOCK_NAME_STRING_MAX (128) + +napi_ref RunningLockNapi::runningLockConstructor_ = nullptr; + +napi_value RunningLockNapi::InitRunningLockClass(napi_env env, napi_value exports) +{ + int32_t refCount = 1; + napi_property_descriptor desc[] = { + DECLARE_NAPI_FUNCTION("lock", Lock), + DECLARE_NAPI_FUNCTION("isUsed", IsUsed), + DECLARE_NAPI_FUNCTION("unlock", Unlock), + }; + napi_value result = nullptr; + napi_define_class(env, "RunningLock", NAPI_AUTO_LENGTH, ConstructRunningLockObject, nullptr, + sizeof(desc) / sizeof(*desc), desc, &result); + napi_create_reference(env, result, refCount, &runningLockConstructor_); + napi_set_named_property(env, exports, "RunningLock", result); + + return exports; +} + +bool RunningLockNapi::CreateRunningLock(napi_env env, napi_callback_info info, napi_value* result) +{ + POWER_HILOGD(MODULE_JS_NAPI, "enter"); + + napi_value constructor; + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_value jsthis = nullptr; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); + if (argc < 2) { + return false; + } + + napi_get_reference_value(env, runningLockConstructor_, &constructor); + status = napi_new_instance(env, constructor, argc, args, result); + if (status != napi_ok) { + return false; + } + + char name[LOCK_NAME_STRING_MAX]; + size_t out; + napi_get_value_string_latin1(env, args[0], name, sizeof(LOCK_NAME_STRING_MAX), &out); + std::string nameStr = name; + + uint32_t type; + napi_get_value_uint32(env, args[1], &type); + + std::shared_ptr lock = PowerMgrClient::GetInstance() + .CreateRunningLock(nameStr, static_cast(type), false); + if (lock == nullptr) { + return false; + } + + RunningLockWrapper* wrapper = new RunningLockWrapper(lock); + status = napi_wrap(env, *result, reinterpret_cast(wrapper), + RemoveRunningLock, nullptr, nullptr); + if (status != napi_ok) { + delete wrapper; + return false; + } + + return true; +} + +napi_value RunningLockNapi::Lock(napi_env env, napi_callback_info info) +{ + size_t argc = 2; + napi_value args[2] = { 0 }; + napi_value jsthis; + void *data = nullptr; + uint32_t timeout = 0; + PowerNapiContext* context; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); + NAPI_ASSERT(env, status == napi_ok, "Failed to get parameters"); + + RunningLockWrapper* wrapper = nullptr; + bool success = GetNativeLock(env, jsthis, &wrapper); + NAPI_ASSERT(env, success == true, "This object is not created by PowerManager"); + + if (argc >= 1) { + napi_valuetype type; + NAPI_CALL(env, napi_typeof(env, args[0], &type)); + if (type == napi_number) { + napi_get_value_uint32(env, args[0], &timeout); + context = new PowerNapiContext(env, args, argc, 1, 0); + } else if (type == napi_function) { + context = new PowerNapiContext(env, args, argc, 0, 0); + } else { + context = new PowerNapiContext(env, args, argc, -1, 0); + } + } else { + context = new PowerNapiContext(env, args, argc, -1, 0); + } + + napi_value promise = context->GetPromise(); + context->StartAsyncWork("RunningLock::Lock", + [wrapper, timeout] { + ErrCode ret = wrapper->lock_ptr->Lock(timeout); + return ret == ERR_OK? true: false; + }, + [](PowerNapiContext* object) { delete object; } + ); + + return promise; +} + +napi_value RunningLockNapi::IsUsed(napi_env env, napi_callback_info info) +{ + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_value jsthis; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); + NAPI_ASSERT(env, status == napi_ok, "Failed to get parameters"); + + RunningLockWrapper* wrapper = nullptr; + bool success = GetNativeLock(env, jsthis, &wrapper); + NAPI_ASSERT(env, success == true, "This object is not created by PowerManager"); + + PowerNapiContext* context = new PowerNapiContext(env, args, argc, 0, 0); + + napi_value promise = context->GetPromise(); + context->StartAsyncWork("RunningLock::IsUsed", + [context, wrapper] { + bool ret = wrapper->lock_ptr->IsUsed(); + napi_get_boolean(context->env_, ret, &context->outValue_); + return true; + }, + [](PowerNapiContext* object) { delete object; } + ); + + return promise; +} + +napi_value RunningLockNapi::Unlock(napi_env env, napi_callback_info info) +{ + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_value jsthis; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); + NAPI_ASSERT(env, status == napi_ok, "Failed to get parameters"); + + RunningLockWrapper* wrapper = nullptr; + bool success = GetNativeLock(env, jsthis, &wrapper); + NAPI_ASSERT(env, success == true, "This object is not created by PowerManager"); + + PowerNapiContext* context = new PowerNapiContext(env, args, argc, 0, 0); + + napi_value promise = context->GetPromise(); + context->StartAsyncWork("RunningLock::Unlock", + [wrapper] { + ErrCode ret = wrapper->lock_ptr->UnLock(); + return ret == ERR_OK? true: false; + }, + [](PowerNapiContext* object) { delete object; } + ); + + return promise; +} + +void RunningLockNapi::RemoveRunningLock(napi_env env, void* finalize_data, void* finalize_hint) +{ + RunningLockWrapper* wrapper = reinterpret_cast(finalize_data); + delete wrapper; +} + +napi_value RunningLockNapi::ConstructRunningLockObject(napi_env env, napi_callback_info info) +{ + size_t argc = 0; + napi_value args[3] = { 0 }; + napi_value jsthis = nullptr; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); + if (status != napi_ok) { + return nullptr; + } + + return jsthis; +} + +bool RunningLockNapi::GetNativeLock(napi_env env, napi_value object, RunningLockWrapper** lock) +{ + napi_value constructor = nullptr; + bool is_instance = false; + void* result = nullptr; + + napi_status status = napi_get_reference_value(env, runningLockConstructor_, &constructor); + if (status != napi_ok) { + return false; + } + + status = napi_instanceof(env, object, constructor, &is_instance); + if (status != napi_ok || !is_instance) { + return false; + } + + status = napi_unwrap(env, object, &result); + if (status != napi_ok) { + return false; + } + + *lock = reinterpret_cast(result); + return true; +} + diff --git a/interfaces/innerkits/native/src/power_mgr_client.cpp b/frameworks/native/power_mgr_client.cpp similarity index 95% rename from interfaces/innerkits/native/src/power_mgr_client.cpp rename to frameworks/native/power_mgr_client.cpp index c47bff08..758b107a 100644 --- a/interfaces/innerkits/native/src/power_mgr_client.cpp +++ b/frameworks/native/power_mgr_client.cpp @@ -149,6 +149,16 @@ void PowerMgrClient::RefreshActivity(UserActivityType type, bool needChangeBackl POWER_HILOGI(MODULE_INNERKIT, " Calling RefreshActivity Success!"); } +bool PowerMgrClient::IsRunningLockTypeSupported(uint32_t type) +{ + if (type >= static_cast(RunningLockType::RUNNINGLOCK_BUTT)) { + return false; + } + + RETURN_IF_WITH_RET(Connect() != ERR_OK, false); + return proxy_->IsRunningLockTypeSupported(type); +} + bool PowerMgrClient::ForceSuspendDevice() { RETURN_IF_WITH_RET(Connect() != ERR_OK, false); @@ -166,6 +176,12 @@ bool PowerMgrClient::IsScreenOn() return ret; } +PowerState PowerMgrClient::GetState() +{ + RETURN_IF_WITH_RET(Connect() != ERR_OK, PowerState::UNKNOWN); + return proxy_->GetState(); +} + std::shared_ptr PowerMgrClient::CreateRunningLock(const std::string& name, RunningLockType type, const int screenOnFlag) { diff --git a/interfaces/innerkits/native/src/running_lock.cpp b/frameworks/native/running_lock.cpp similarity index 77% rename from interfaces/innerkits/native/src/running_lock.cpp rename to frameworks/native/running_lock.cpp index cf57661c..7328e654 100644 --- a/interfaces/innerkits/native/src/running_lock.cpp +++ b/frameworks/native/running_lock.cpp @@ -31,7 +31,9 @@ RunningLock::RunningLock(const wptr& proxy, const std::string& name, RunningLock::~RunningLock() { - UnLock(); + if (token_ != nullptr) { + Release(); + } } bool RunningLock::Init() @@ -42,6 +44,7 @@ bool RunningLock::Init() POWER_HILOGE(MODULE_INNERKIT, "RunningLock::%{public}s :creating RunningLockTokenStub error.", __func__); return false; } + Create(); return true; } @@ -57,11 +60,7 @@ ErrCode RunningLock::Lock(uint32_t timeOutMs) } POWER_HILOGI(MODULE_INNERKIT, "RunningLock::%{public}s :service lock is called", __func__); proxy->Lock(token_, runningLockInfo_, timeOutMs); - if (timeOutMs != 0) { - usedState_ = RunningLockState::UNKNOWN; - } else { - usedState_ = RunningLockState::USED; - } + return ERR_OK; } @@ -79,28 +78,20 @@ ErrCode RunningLock::UnLock() } POWER_HILOGI(MODULE_INNERKIT, "RunningLock::%{public}s :really called service UnLock.", __func__); proxy->UnLock(token_); - usedState_ = RunningLockState::UNUSED; return ERR_OK; } bool RunningLock::CheckUsedNoLock() { - if (usedState_ <= RunningLockState::USED) { - return (usedState_ == RunningLockState::USED); - } sptr proxy = proxy_.promote(); if (proxy == nullptr) { POWER_HILOGE(MODULE_INNERKIT, "RunningLock::%{public}s :proxy nullptr.", __func__); return false; } bool ret = proxy->IsUsed(token_); - if (!ret) { - // only ret false can update the unknown state. - usedState_ = RunningLockState::UNUSED; - return false; - } - POWER_HILOGI(MODULE_INNERKIT, "RunningLock::%{public}s, usedState_ = %d.", __func__, usedState_); - return true; + + POWER_HILOGI(MODULE_INNERKIT, "RunningLock::%{public}s, ret = %d.", __func__, ret); + return ret; } bool RunningLock::IsUsed() @@ -139,5 +130,34 @@ const WorkTriggerList& RunningLock::GetWorkTriggerList() const { return runningLockInfo_.workTriggerlist; } + +void RunningLock::Create() +{ + lock_guard lock(mutex_); + POWER_HILOGI(MODULE_INNERKIT, "RunningLock::%{public}s", __func__); + + sptr proxy = proxy_.promote(); + if (proxy == nullptr) { + POWER_HILOGE(MODULE_INNERKIT, "RunningLock::%{public}s :proxy nullptr.", __func__); + return; + } + POWER_HILOGI(MODULE_INNERKIT, "RunningLock::%{public}s :service lock is called", __func__); + proxy->CreateRunningLock(token_, runningLockInfo_); +} + +void RunningLock::Release() +{ + lock_guard lock(mutex_); + POWER_HILOGI(MODULE_INNERKIT, "RunningLock::%{public}s ", __func__); + + sptr proxy = proxy_.promote(); + if (proxy == nullptr) { + POWER_HILOGE(MODULE_INNERKIT, "RunningLock::%{public}s :proxy nullptr.", __func__); + return; + } + POWER_HILOGI(MODULE_INNERKIT, "RunningLock::%{public}s :service lock is called", __func__); + proxy->ReleaseRunningLock(token_); +} + } // namespace PowerMgr } // namespace OHOS diff --git a/interfaces/innerkits/native/src/running_lock_info.cpp b/frameworks/native/running_lock_info.cpp similarity index 100% rename from interfaces/innerkits/native/src/running_lock_info.cpp rename to frameworks/native/running_lock_info.cpp diff --git a/interfaces/innerkits/native/src/running_lock_token_stub.cpp b/frameworks/native/running_lock_token_stub.cpp similarity index 100% rename from interfaces/innerkits/native/src/running_lock_token_stub.cpp rename to frameworks/native/running_lock_token_stub.cpp diff --git a/interfaces/innerkits/BUILD.gn b/interfaces/innerkits/BUILD.gn index db852c3c..b9ff6f65 100644 --- a/interfaces/innerkits/BUILD.gn +++ b/interfaces/innerkits/BUILD.gn @@ -28,10 +28,10 @@ ohos_shared_library("powermgr_client") { sources = [ "${powermgr_service_path}/zidl/src/power_mgr_proxy.cpp", "${powermgr_service_path}/zidl/src/power_state_callback_proxy.cpp", - "native/src/power_mgr_client.cpp", - "native/src/running_lock.cpp", - "native/src/running_lock_info.cpp", - "native/src/running_lock_token_stub.cpp", + "${powermgr_framework_path}/native/power_mgr_client.cpp", + "${powermgr_framework_path}/native/running_lock.cpp", + "${powermgr_framework_path}/native/running_lock_info.cpp", + "${powermgr_framework_path}/native/running_lock_token_stub.cpp", ] configs = [ diff --git a/interfaces/innerkits/native/include/ipower_mgr.h b/interfaces/innerkits/native/include/ipower_mgr.h index d8c224e8..b4ebed61 100644 --- a/interfaces/innerkits/native/include/ipower_mgr.h +++ b/interfaces/innerkits/native/include/ipower_mgr.h @@ -31,7 +31,10 @@ namespace PowerMgr { class IPowerMgr : public IRemoteBroker { public: enum { - RUNNINGLOCK_LOCK = 0, + CREATE_RUNNINGLOCK = 0, + RELEASE_RUNNINGLOCK, + IS_RUNNINGLOCK_TYPE_SUPPORTED, + RUNNINGLOCK_LOCK, RUNNINGLOCK_UNLOCK, RUNNINGLOCK_SET_WORK_TRIGGER_LIST, RUNNINGLOCK_ISUSED, @@ -39,6 +42,7 @@ public: WAKEUP_DEVICE, SUSPEND_DEVICE, REFRESH_ACTIVITY, + GET_STATE, IS_SCREEN_ON, FORCE_DEVICE_SUSPEND, REBOOT_DEVICE, @@ -49,6 +53,9 @@ public: UNREG_SHUTDOWN_CALLBACK }; + virtual void CreateRunningLock(const sptr& token, const RunningLockInfo& runningLockInfo) = 0; + virtual void ReleaseRunningLock(const sptr& token) = 0; + virtual bool IsRunningLockTypeSupported(uint32_t type) = 0; virtual void Lock(const sptr& token, const RunningLockInfo& runningLockInfo, uint32_t timeOutMs) = 0; virtual void UnLock(const sptr& token) = 0; @@ -62,6 +69,7 @@ public: virtual void SuspendDevice(int64_t callTimeMs, SuspendDeviceType reason, bool suspendImmed) = 0; virtual void WakeupDevice(int64_t callTimeMs, WakeupDeviceType reason, const std::string& details) = 0; virtual void RefreshActivity(int64_t callTimeMs, UserActivityType type, bool needChangeBacklight) = 0; + virtual PowerState GetState() = 0; virtual bool IsScreenOn() = 0; virtual bool ForceSuspendDevice(int64_t callTimeMs) = 0; virtual void RegisterPowerStateCallback(const sptr& callback) = 0; diff --git a/interfaces/innerkits/native/include/power_mgr_client.h b/interfaces/innerkits/native/include/power_mgr_client.h index e5a73f10..e920c69e 100644 --- a/interfaces/innerkits/native/include/power_mgr_client.h +++ b/interfaces/innerkits/native/include/power_mgr_client.h @@ -72,17 +72,29 @@ public: */ void RefreshActivity(UserActivityType type = UserActivityType::USER_ACTIVITY_TYPE_OTHER, bool needChangeBacklight = true); - /** * Check whether the device screen is on. The result may be true or false, depending on the system state. */ bool IsScreenOn(); + /** + * Get Power state. The result is PowerState type. + */ + PowerState GetState(); + /** * Forcibly suspend the device into deepsleep, and return the suspend result. */ bool ForceSuspendDevice(); + /** + * Check whether the type of running lock is supported + */ + bool IsRunningLockTypeSupported(uint32_t type); + + /** + * Create a running lock + */ std::shared_ptr CreateRunningLock(const std::string& name, RunningLockType type, const int screenOnFlag = 0); void ProxyRunningLock(bool proxyLock, pid_t uid, pid_t pid = INVALID_PID); diff --git a/interfaces/innerkits/native/include/power_state_machine_info.h b/interfaces/innerkits/native/include/power_state_machine_info.h index 86621c07..235711e2 100644 --- a/interfaces/innerkits/native/include/power_state_machine_info.h +++ b/interfaces/innerkits/native/include/power_state_machine_info.h @@ -51,7 +51,7 @@ enum class PowerState : uint32_t { /** * Power State: screen on and cpu on. */ - AWAKE, + AWAKE = 0, /** * Power State: screen off and cpu on. @@ -62,6 +62,21 @@ enum class PowerState : uint32_t { * Power State: screen off and cpu off. */ SLEEP, + + /** + * Power State: unknown. + */ + UNKNOWN, +}; + +/** + * Display State of Device. + */ +enum class DisplayState : uint32_t { + DISPLAY_OFF = 0, + DISPLAY_DIM = 1, + DISPLAY_ON = 2, + DISPLAY_SUSPEND = 3, }; // UserActivityType list, must sync with A_PMS @@ -102,6 +117,28 @@ enum class SuspendDeviceType : uint32_t { SUSPEND_DEVICE_REASON_FORCE_SUSPEND = 8, SUSPEND_DEVICE_REASON_MAX = SUSPEND_DEVICE_REASON_FORCE_SUSPEND, }; + +enum class StateChangeReason : uint32_t { + STATE_CHANGE_REASON_INIT = 0, + STATE_CHANGE_REASON_TIMEOUT = 1, + STATE_CHANGE_REASON_RUNNING_LOCK = 2, + STATE_CHANGE_REASON_BATTERY = 3, + STATE_CHANGE_REASON_THERMAL = 4, + STATE_CHANGE_REASON_WORK = 5, + STATE_CHANGE_REASON_SYSTEM = 6, + STATE_CHANGE_REASON_APPLICATION = 10, + STATE_CHANGE_REASON_SETTINGS = 11, + STATE_CHANGE_REASON_HARD_KEY = 12, + STATE_CHANGE_REASON_TOUCH = 13, + STATE_CHANGE_REASON_CABLE = 14, + STATE_CHANGE_REASON_SENSOR = 15, + STATE_CHANGE_REASON_LID = 16, + STATE_CHANGE_REASON_CAMERA = 17, + STATE_CHANGE_REASON_ACCESSIBILITY = 18, + STATE_CHANGE_REASON_REMOTE = 100, + STATE_CHANGE_REASON_UNKNOWN = 1000, +}; + } // namespace PowerMgr } // namespace OHOS #endif // POWERMGR_POWER_STATE_MACHINE_INFO_H diff --git a/interfaces/innerkits/native/include/running_lock.h b/interfaces/innerkits/native/include/running_lock.h index 182d1e71..7c07ebf2 100644 --- a/interfaces/innerkits/native/include/running_lock.h +++ b/interfaces/innerkits/native/include/running_lock.h @@ -32,13 +32,6 @@ public: ~RunningLock(); DISALLOW_COPY_AND_MOVE(RunningLock); - enum class RunningLockState { - UNUSED = 0, - USED, - UNKNOWN, - BUTT, - }; - bool Init(); bool IsUsed(); @@ -68,9 +61,10 @@ public: static constexpr uint32_t CREATE_WITH_SCREEN_ON = 0x10000000; private: + void Create(); + void Release(); std::mutex mutex_; RunningLockInfo runningLockInfo_; - RunningLockState usedState_ {RunningLockState::UNUSED}; sptr token_; wptr proxy_; bool CheckUsedNoLock(); diff --git a/interfaces/kits/js/@ohos.power.d.ts b/interfaces/kits/js/@ohos.power.d.ts index 042b39bd..a2204f2e 100644 --- a/interfaces/kits/js/@ohos.power.d.ts +++ b/interfaces/kits/js/@ohos.power.d.ts @@ -23,35 +23,169 @@ import {AsyncCallback} from './basic'; * @since 6 */ declare namespace power { - /** - * Shuts down the system. - * - *

This method requires the ohos.permission.SHUTDOWN permission. - * - * @param reason Indicates the shutdown reason. - * @since 6 - */ - function shutownDevice(reason: string): void; - - /** - * Restarts the system. - * - *

This method requires the ohos.permission.REBOOT permission. - * - * @param reason Indicates the restart reason. For example, "recovery" indicates entering the recovery mode - * after the restart. If the parameter is not specified, the system enters the normal mode after the restart. - * @since 6 - */ - function rebootDevice(reason: string): void; - - /** - * Checks whether the screen of a device is on or off. - * - * @return Returns true if the screen is on; returns false otherwise. - * @since 6 - */ - function isScreenOn(callback: AsyncCallback): void; - function isScreenOn(): Promise; + /** + * Enumerates the {@link RunningLock} types. + * + *

Two {@link RunningLock} types are available: {@link BACKGROUND}, and {@link PROXIMITY_SCREEN_CONTROL}. + * {@link BACKGROUND} ensures that applications can run in the background. + * {@link PROXIMITY_SCREEN_CONTROL} determines whether to turn on or off the screen based on the proximity sensor. + * + * @since 6 + */ + export enum RunningLockType { + /** + * Indicates the lock that prevents the system from hibernating. + */ + BACKGROUND = 1, + /** + * Indicates the lock that determines whether to turn on or off the screen based on the proximity sensor. + * For example, during a call, if the proximity sensor detects that the device is moving close to + * the user's ear, the screen turns off; if the proximity sensor detects that the device is moving away + * from the user's ear, the screen turns on. + */ + PROXIMITY_SCREEN_CONTROL + } + /** + * Enumerates the {@link PowerState} types. + * + *

Three {@link PowerState} types are available: {@link AWAKE}, {@link SLEEP}, and {@link INACTIVE}. + * {@link AWAKE} Indicates that the screen is on and the system is running. + * {@link INACTIVE} Indicates that the screen is off and the system is running. + * {@link SLEEP} Indicates that the screen is on and the system is running. + * + * @since 6 + */ + export enum PowerState { + /** + * Indicates that the screen is on and the system is running. + */ + AWAKE = 0, + /** + * Indicates that the screen is off and the system is running. + */ + INACTIVE, + /** + * Indicates that the screen is off and the system is hibernating. + */ + SLEEP, + } + + export enum PowerMode { + /** + * Normal power mode + */ + NORMAL = 0, + /** + * Power save mode + */ + POWER_SAVE, + } + + class RunningLock { + /** + * Prevents the system from hibernating and sets the lock duration. + * + * @param timeout Indicates the lock duration (ms). After the lock duration times out, the lock is automatically + * released and the system hibernates if no other {@link RunningLock} is set. + * @since 6 + */ + function lock(timeout: number, callback: AsyncCallback): void; + function lock(timeout: number): Promise; + + /** + * Checks whether a lock is held or in use. + * + * @return Returns true if the lock is held or in use; returns false if the lock has been released. + * @since 6 + */ + function isUsed(callback: AsyncCallback): void; + function isUsed(): Promise; + + /** + * Release the {@link RunningLock} that prevents the system from hibernating. + * + * @since 6 + */ + function unlock(callback: AsyncCallback): void; + function unlock(): Promise; + } + + /** + * Checks whether the specified {@link RunningLockType} is supported. + * + * @param type Indicates the specified {@link RunningLockType}. + * @return Returns true if the specified {@link RunningLockType} is supported; + * returns false otherwise. + * @since 6 + */ + function isRunningLockTypeSupported(type: RunningLockType, callback: AsyncCallback): void; + function isRunningLockTypeSupported(type: RunningLockType): Promise; + + /** + * Creates a RunningLock object. + * + *

This method requires the ohos.permission.RUNNING_LOCK permission. + * + *

The {@link RunningLock} object can be used to perform a lock operation to prevent the system from hibernating. + * + * @param name Indicates the RunningLock name. A recommended name consists of the package or class name and + * a suffix. + * @param type Indicates the RunningLockType. + * @return Returns the RunningLock object. + * @since 6 + */ + function createRunningLock(name: string, type: RunningLockType, callback: AsyncCallback): void; + function createRunningLock(name: string, type: RunningLockType): Promise; + + /** + * Shuts down the system. + * + *

This method requires the ohos.permission.SHUTDOWN permission. + * + * @param reason Indicates the shutdown reason. + * @since 6 + */ + function shutownDevice(callback: AsyncCallback): void; + function shutownDevice(reason: string): Promise; + + /** + * Restarts the system. + * + *

This method requires the ohos.permission.REBOOT permission. + * + * @param reason Indicates the restart reason. For example, "recovery" indicates entering the recovery mode + * after the restart. If the parameter is not specified, the system enters the normal mode after the restart. + * @since 6 + */ + function rebootDevice(callback: AsyncCallback): void; + function rebootDevice(reason: string): Promise; + + /** + * Checks whether the screen of a device is on or off. + * + * @return Returns true if the screen is on; returns false otherwise. + * @since 6 + */ + function isScreenOn(callback: AsyncCallback): void; + function isScreenOn(): Promise; + + /** + * Get power state. + * + * @return Returns power state indicates the specified {@link PowerState} + * @since 6 + */ + function getState(callback: AsyncCallback): void; + function getState(): Promise; + + /** + * Get power mode. + * + * @return Returns current power mode name. + * @since 6 + */ + function getMode(callback: AsyncCallback): void; + function getMode(): Promise; } export default power; diff --git a/interfaces/kits/js/@ohos.runninglock.d.ts b/interfaces/kits/js/@ohos.runninglock.d.ts deleted file mode 100644 index 6e363fc7..00000000 --- a/interfaces/kits/js/@ohos.runninglock.d.ts +++ /dev/null @@ -1,108 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -import {AsyncCallback} from './basic.d.ts'; - -/** - * Provides a mechanism to prevent the system from hibernating so that the applications can run in the background or - * when the screen is off. - * - *

{@link createRunningLock} can be called to obtain a {@link RunningLock}. - *

{@link lock} can be called to set the lock duration, during which the system will not hibernate. After the - * lock duration times out, the lock is automatically released and the system hibernates if no other {@link - * RunningLock} is set. - * - * @SysCap SystemCapability.PowerMgr.PowerManager - * @devices phone, tablet - * @since 6 - */ -declare namespace runningLock { - - class RunningLock { - /** - * Prevents the system from hibernating and sets the lock duration. - * - * @param timeout Indicates the lock duration (ms). After the lock duration times out, the lock is automatically - * released and the system hibernates if no other {@link RunningLock} is set. - * @since 6 - */ - function lock(timeout: number): void; - - /** - * Checks whether a lock is held or in use. - * - * @return Returns true if the lock is held or in use; returns false if the lock has been released. - * @since 6 - */ - function isUsed(): boolean; - - /** - * Release the {@link RunningLock} that prevents the system from hibernating. - * - * @since 6 - */ - function unlock(): void; - } - - /** - * Enumerates the {@link RunningLock} types. - * - *

Two {@link RunningLock} types are available: {@link BACKGROUND}, and {@link PROXIMITY_SCREEN_CONTROL}. - * {@link BACKGROUND} ensures that applications can run in the background. - * {@link PROXIMITY_SCREEN_CONTROL} determines whether to turn on or off the screen based on the proximity sensor. - * - * @since 6 - */ - export enum RunningLockType { - /** - * Indicates the lock that prevents the system from hibernating. - */ - BACKGROUND = 1, - /** - * Indicates the lock that determines whether to turn on or off the screen based on the proximity sensor. - * For example, during a call, if the proximity sensor detects that the device is moving close to - * the user's ear, the screen turns off; if the proximity sensor detects that the device is moving away - * from the user's ear, the screen turns on. - */ - PROXIMITY_SCREEN_CONTROL - } - - /** - * Checks whether the specified {@link RunningLockType} is supported. - * - * @param type Indicates the specified {@link RunningLockType}. - * @return Returns true if the specified {@link RunningLockType} is supported; - * returns false otherwise. - * @since 6 - */ - function isRunningLockTypeSupported(type: RunningLockType, callback: AsyncCallback): void; - function isRunningLockTypeSupported(type: RunningLockType): Promise; - /** - * Creates a {@link RunningLock} object. - * - *

This method requires the ohos.permission.RUNNING_LOCK permission. - * - *

The {@link RunningLock} object can be used to perform a lock operation to prevent the system from hibernating. - * - * @param name Indicates the {@link RunningLock} name. A recommended name consists of the package or class name and - * a suffix. - * @param type Indicates the {@link RunningLockType}. - * @return Returns the {@link RunningLock} object. - * @since 6 - */ - function createRunningLock(name: string, type: RunningLockType, callback: AsyncCallback): void; - function createRunningLock(name: string, type: RunningLockType): Promise; -} -export default runningLock; diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn new file mode 100644 index 00000000..6035d19c --- /dev/null +++ b/interfaces/kits/js/BUILD.gn @@ -0,0 +1,75 @@ +# Copyright (C) 2021 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. + +import("//build/ohos.gni") +import("//build/ohos/ace/ace.gni") +import("//base/powermgr/power_manager/powermgr.gni") + +config("powermgr_private_config") { + include_dirs = [ + "${powermgr_root_path}/frameworks/include", + "${powermgr_service_path}/zidl/include", + "//utils/system/safwk/native/include", + ] +} + +config("powermgr_public_config") { + include_dirs = [ "native/include" ] +} + +js_declaration("power_js") { + part_name = "power_manager" + sources = [ + "./@ohos.power.d.ts", + ] +} + +ohos_copy("power_declaration") { + sources = [ + "./@ohos.power.d.ts", + ] + outputs = [ target_out_dir + "/$target_name/" ] + module_source_dir = target_out_dir + "/$target_name" + module_install_name = "" +} + +ohos_shared_library("power") { + configs = [ + "${powermgr_utils_path}:utils_config", + ":powermgr_private_config", + ] + + public_configs = [ ":powermgr_public_config" ] + + sources = [ + "//base/powermgr/power_manager/frameworks/napi/power_napi_base.cpp", + "//base/powermgr/power_manager/frameworks/napi/power_manager_napi.cpp", + "//base/powermgr/power_manager/frameworks/napi/running_lock_napi.cpp", + ] + + deps = [ + "//foundation/ace/napi:ace_napi", + "//base/powermgr/power_manager/interfaces/innerkits:powermgr_client", + "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog", + "//utils/native/base:utils" + ] + + external_deps = [ + "ipc:ipc_core", + "hiviewdfx_hilog_native:libhilog", + ] + + relative_install_dir = "module/power_manager" + part_name = "power_manager" + subsystem_name = "powermgr" +} diff --git a/ohos.build b/ohos.build index 79b3bcce..1ca753a1 100644 --- a/ohos.build +++ b/ohos.build @@ -5,7 +5,9 @@ "module_list": [ "//base/powermgr/power_manager/interfaces/innerkits:powermgr_client", "//base/powermgr/power_manager/sa_profile:powermgr_sa_profile", - "//base/powermgr/power_manager/services:powermgrservice" + "//base/powermgr/power_manager/services:powermgrservice", + "//base/powermgr/power_manager/interfaces/kits/js:power", + "//base/powermgr/power_manager/interfaces/kits/js:power_js" ], "inner_kits": [ { diff --git a/powermgr.gni b/powermgr.gni index c9a67498..5236f4e3 100644 --- a/powermgr.gni +++ b/powermgr.gni @@ -19,6 +19,8 @@ powermgr_root_path = "//base/powermgr/power_manager" powermgr_service_path = "${powermgr_root_path}/services" +powermgr_framework_path = "${powermgr_root_path}/frameworks" + powermgr_interfaces_path = "${powermgr_root_path}/interfaces" powermgr_native_innerkits_path = "${powermgr_interfaces_path}/innerkits" diff --git a/services/native/include/actions/idevice_state_action.h b/services/native/include/actions/idevice_state_action.h index 9289012c..ceb437ee 100644 --- a/services/native/include/actions/idevice_state_action.h +++ b/services/native/include/actions/idevice_state_action.h @@ -22,6 +22,12 @@ namespace OHOS { namespace PowerMgr { + +enum ActionResult { + SUCCESS = 0, + FAILED = 1, +}; + class IDeviceStateAction { public: IDeviceStateAction() = default; @@ -32,6 +38,9 @@ public: virtual void Wakeup(int64_t callTimeMs, WakeupDeviceType type, const std::string& details, const std::string& pkgName) = 0; virtual void RefreshActivity(int64_t callTimeMs, UserActivityType type, uint32_t flags) = 0; + virtual DisplayState GetDisplayState() = 0; + virtual uint32_t SetDisplayState(DisplayState state) = 0; + virtual uint32_t GoToSleep() = 0; }; } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/include/power_mgr_service.h b/services/native/include/power_mgr_service.h index e7647fc3..c5254a1b 100644 --- a/services/native/include/power_mgr_service.h +++ b/services/native/include/power_mgr_service.h @@ -45,8 +45,12 @@ public: virtual void SuspendDevice(int64_t callTimeMs, SuspendDeviceType reason, bool suspendImmed) override; virtual void WakeupDevice(int64_t callTimeMs, WakeupDeviceType reason, const std::string& details) override; virtual void RefreshActivity(int64_t callTimeMs, UserActivityType type, bool needChangeBacklight) override; + virtual PowerState GetState() override; virtual bool IsScreenOn() override; virtual bool ForceSuspendDevice(int64_t callTimeMs) override; + virtual void CreateRunningLock(const sptr& token, const RunningLockInfo& runningLockInfo) override; + virtual void ReleaseRunningLock(const sptr& token) override; + virtual bool IsRunningLockTypeSupported(uint32_t type) override; void Lock(const sptr& token, const RunningLockInfo& runningLockInfo, uint32_t timeOutMS) override; void UnLock(const sptr& token) override; void ForceUnLock(const sptr& token); diff --git a/services/native/include/power_state_machine.h b/services/native/include/power_state_machine.h index 5aecd6ac..0df7c39a 100644 --- a/services/native/include/power_state_machine.h +++ b/services/native/include/power_state_machine.h @@ -25,20 +25,15 @@ #include "power_common.h" #include "power_mgr_monitor.h" #include "power_state_machine_info.h" +#include "running_lock_info.h" namespace OHOS { namespace PowerMgr { class RunningLockMgr; class PowerMgrService; -enum class ScreenStateType { - SCREEN_OFF = 0, - SCREEN_ON = 1, - SCREEN_DIM = 2, -}; - struct ScreenState { - ScreenStateType state; + DisplayState state; int64_t lastUpdateTime; }; @@ -54,7 +49,15 @@ struct DevicePowerState { int64_t lastSuspendDeviceTime; }; -class PowerStateMachine { +enum class TransitResult { + SUCCESS = 0, + ALREADY_IN_STATE = 1, + LOCKING = 2, + HDI_ERR = 3, + OTHER_ERR = 99 +}; + +class PowerStateMachine : public std::enable_shared_from_this { public: explicit PowerStateMachine(const wptr& pms); ~PowerStateMachine(); @@ -67,12 +70,16 @@ public: void RefreshActivityInner(pid_t pid, int64_t callTimeMs, UserActivityType type, bool needChangeBacklight); void ReceiveScreenEvent(bool isScreenOn); bool IsScreenOn(); + PowerState GetState() { return currentState_; }; bool ForceSuspendDeviceInner(pid_t pid, int64_t callTimeMs); void RegisterPowerStateCallback(const sptr& callback); void UnRegisterPowerStateCallback(const sptr& callback); void SetDelayTimer(int64_t delayTime, int32_t event); void CancelDelayTimer(int32_t event); - void HandleDelayTimer(); + void ResetInactiveTimer(); + void ResetSleepTimer(); + void HandleDelayTimer(int32_t event); + bool SetState(PowerState state, StateChangeReason reason, bool force = false); // only use for test int64_t GetLastSuspendDeviceTime() const { @@ -98,18 +105,45 @@ public: }; private: + class StateController { + public: + StateController(PowerState state, std::shared_ptr owner, + std::function action) + : state_(state), owner_(owner), action_(action) {} + ~StateController() = default; + PowerState GetState() { return state_; } + TransitResult TransitTo(StateChangeReason reason, bool ignoreLock = false); + protected: + bool CheckState(); + PowerState state_; + StateChangeReason lastReason_; + std::weak_ptr owner_; + std::function action_; + }; + struct classcomp { bool operator() (const sptr& l, const sptr& r) const { return l->AsObject() < r->AsObject(); } }; - void NotifyPowerStateChanged(PowerState state); void SendEventToPowerMgrNotify(PowerState state, int64_t callTime); + bool CheckRunningLock(PowerState state); + int64_t GetDisplayOffTime(); + int64_t GetSleepTime(); + void HandleActivityTimeout(); + void HandleActivityOffTimeout(); + void HandleActivitySleepTimeout(); + StateChangeReason GetReasonByUserActivity(UserActivityType type); + StateChangeReason GetReasonByWakeType(WakeupDeviceType type); + StateChangeReason GetReasionBySuspendType(SuspendDeviceType type); const wptr pms_; PowerMgrMonitor powerMgrMonitor_; + PowerState currentState_; + std::map>> lockMap_; + std::map> controllerMap_; std::mutex mutex_; DevicePowerState mDeviceState_; sptr powerStateCBDeathRecipient_; diff --git a/services/native/include/powerms_event_handler.h b/services/native/include/powerms_event_handler.h index c52788d5..ee8cd3d3 100644 --- a/services/native/include/powerms_event_handler.h +++ b/services/native/include/powerms_event_handler.h @@ -28,6 +28,8 @@ public: enum { CHECK_RUNNINGLOCK_OVERTIME_MSG = 1, CHECK_USER_ACTIVITY_TIMEOUT_MSG = 2, + CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG = 3, + CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG = 4, }; PowermsEventHandler(const std::shared_ptr& runner, diff --git a/services/native/include/running_lock_inner.h b/services/native/include/running_lock_inner.h index 59008007..4a39f368 100644 --- a/services/native/include/running_lock_inner.h +++ b/services/native/include/running_lock_inner.h @@ -95,7 +95,7 @@ private: std::mutex mutex_; RunningLockInfo runningLockInfo_; UserIPCInfo userIPCinfo_; - bool disabled_ {false}; + bool disabled_ {true}; bool reallyLocked_ {false}; bool overTimeFlag_ {false}; int64_t lockTimeMs_ {0}; diff --git a/services/native/include/running_lock_mgr.h b/services/native/include/running_lock_mgr.h index 3c93480d..65d05890 100644 --- a/services/native/include/running_lock_mgr.h +++ b/services/native/include/running_lock_mgr.h @@ -31,10 +31,16 @@ namespace OHOS { namespace PowerMgr { class PowerMgrService; class PowermsEventHandler; +class PowerStateMachine; using RunningLockMap = std::map, std::shared_ptr>; class RunningLockMgr { public: + enum class SystemLockType : uint32_t { + SYSTEM_LOCK_APP = 0, + SYSTEM_LOCK_DISPLAY = 1, + SYSTEM_LOCK_OTHER + }; using RunningLockProxyMap = std::unordered_map>; explicit RunningLockMgr(const wptr& pms) : pms_(pms) {} ~RunningLockMgr(); @@ -42,6 +48,11 @@ public: void Lock(const sptr& token, const RunningLockInfo& runningLockInfo, const UserIPCInfo &userIPCinfo, uint32_t timeOutMS = 0); void UnLock(const sptr token); + std::shared_ptr CreateRunningLock(const sptr& token, + const RunningLockInfo& runningLockInfo, const UserIPCInfo &userIPCinfo); + void ReleaseLock(const sptr token); + void acquireSystemLock(SystemLockType type); + void releaseSystemLock(SystemLockType type); uint32_t GetRunningLockNum(RunningLockType type = RunningLockType::RUNNINGLOCK_BUTT); uint32_t GetValidRunningLockNum(RunningLockType type = RunningLockType::RUNNINGLOCK_BUTT); void SetWorkTriggerList(const sptr& token, const WorkTriggerList& workTriggerList); @@ -64,6 +75,53 @@ public: void DumpInfo(std::string& result); private: + static constexpr const char* const LOCK_TAG_APP = "lock_app"; + static constexpr const char* const LOCK_TAG_DISPLAY = "lock_display"; + static constexpr const char* const LOCK_TAG_OTHER = "lock_other"; + + class SystemLock { + public: + SystemLock(std::shared_ptr action, const char * const tag) + : action_(action), tag_(tag), locking_(false){}; + ~SystemLock() = default; + void Lock(); + void Unlock(); + bool IsLocking() { return locking_; }; + private: + std::shared_ptr action_; + const std::string tag_; + bool locking_; + }; + + class LockCounter { + public: + LockCounter(RunningLockType type, std::function activate) + : type_(type), activate_(activate), counter_(0) {} + ~LockCounter() = default; + uint32_t Increase(); + uint32_t Decrease(); + uint32_t GetCount() { return counter_; } + RunningLockType GetType() { return type_; } + private: + const RunningLockType type_; + std::shared_ptr action_; + std::function activate_; + uint32_t counter_; + }; + + class ProximityController { + public: + ProximityController(); + ~ProximityController(); + void Enable(); + void Disable(); + bool IsEnabled() { return enabled_; } + private: + void OnProximity(); + void OnAway(); + bool enabled_; + }; + class RunningLockDeathRecipient : public IRemoteObject::DeathRecipient { public: RunningLockDeathRecipient() = default; @@ -76,12 +134,13 @@ private: void UnLockReally(const sptr& token, std::shared_ptr& lockInner); void ProxyRunningLockInner(bool proxyLock); void RemoveAndPostUnlockTask(const sptr& token, uint32_t timeOutMS = 0); - std::shared_ptr CreateRunningLockInner(const sptr& token, - const RunningLockInfo& runningLockInfo, const UserIPCInfo &userIPCinfo); const wptr pms_; + ProximityController proximityController_; std::weak_ptr handler_; std::mutex mutex_; RunningLockMap runningLocks_; + std::map> systemLocks_; + std::map> lockCounters_; RunningLockProxyMap proxyMap_; sptr runningLockDeathRecipient_; std::shared_ptr runningLockAction_; diff --git a/services/native/src/actions/default/BUILD.gn b/services/native/src/actions/default/BUILD.gn index 4006e670..0ee29eff 100644 --- a/services/native/src/actions/default/BUILD.gn +++ b/services/native/src/actions/default/BUILD.gn @@ -38,6 +38,7 @@ ohos_source_set("${powermgr_actions_default_target}") { external_deps = [ "display_manager_native:displaymgr", "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", ] part_name = "${powermgr_native_part_name}" diff --git a/services/native/src/actions/default/device_state_action.cpp b/services/native/src/actions/default/device_state_action.cpp index 94abc7aa..18492ab3 100644 --- a/services/native/src/actions/default/device_state_action.cpp +++ b/services/native/src/actions/default/device_state_action.cpp @@ -15,31 +15,88 @@ #include "device_state_action.h" -#include "display_manager.h" +#include "display_mgr_client.h" #include "system_suspend_controller.h" +#include "power_state_machine_info.h" -using namespace OHOS::DisplayMgr; using namespace std; namespace OHOS { namespace PowerMgr { + +using namespace DisplayPowerMgr; + void DeviceStateAction::Suspend(int64_t callTimeMs, SuspendDeviceType type, uint32_t flags) { - DisplayManager::SetScreenState(ScreenState::SCREEN_STATE_OFF); + DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayPowerMgr::DisplayState::DISPLAY_OFF); SystemSuspendController::GetInstance().EnableSuspend(); } void DeviceStateAction::ForceSuspend() { - DisplayManager::SetScreenState(ScreenState::SCREEN_STATE_OFF); + DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayPowerMgr::DisplayState::DISPLAY_OFF); SystemSuspendController::GetInstance().ForceSuspend(); } void DeviceStateAction::Wakeup(int64_t callTimeMs, WakeupDeviceType type, const string& details, const string& pkgName) { + DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayPowerMgr::DisplayState::DISPLAY_ON); SystemSuspendController::GetInstance().DisableSuspend(); - DisplayManager::SetScreenState(ScreenState::SCREEN_STATE_ON); } + +DisplayState DeviceStateAction::GetDisplayState() +{ + DisplayPowerMgr::DisplayState state = DisplayPowerMgrClient::GetInstance().GetDisplayState(); + DisplayState ret = DisplayState::DISPLAY_ON; + switch (state) { + case DisplayPowerMgr::DisplayState::DISPLAY_ON: + ret = DisplayState::DISPLAY_ON; + break; + case DisplayPowerMgr::DisplayState::DISPLAY_DIM: + ret = DisplayState::DISPLAY_DIM; + break; + case DisplayPowerMgr::DisplayState::DISPLAY_OFF: + ret = DisplayState::DISPLAY_OFF; + break; + case DisplayPowerMgr::DisplayState::DISPLAY_SUSPEND: + ret = DisplayState::DISPLAY_SUSPEND; + break; + default: + break; + } + return ret; +} + +uint32_t DeviceStateAction::SetDisplayState(DisplayState state) +{ + DisplayPowerMgr::DisplayState dispState = DisplayPowerMgr::DisplayState::DISPLAY_ON; + switch(state) { + case DisplayState::DISPLAY_ON: + dispState = DisplayPowerMgr::DisplayState::DISPLAY_ON; + break; + case DisplayState::DISPLAY_DIM: + dispState = DisplayPowerMgr::DisplayState::DISPLAY_DIM; + break; + case DisplayState::DISPLAY_OFF: + dispState = DisplayPowerMgr::DisplayState::DISPLAY_OFF; + break; + case DisplayState::DISPLAY_SUSPEND: + dispState = DisplayPowerMgr::DisplayState::DISPLAY_SUSPEND; + break; + default: + break; + } + + bool ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(dispState); + return ret? ActionResult::SUCCESS: ActionResult::FAILED; +} + +uint32_t DeviceStateAction::GoToSleep() +{ + SystemSuspendController::GetInstance().ForceSuspend(); + return ActionResult::SUCCESS; +} + } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/src/actions/default/device_state_action.h b/services/native/src/actions/default/device_state_action.h index a0aaec92..7d5f5f60 100644 --- a/services/native/src/actions/default/device_state_action.h +++ b/services/native/src/actions/default/device_state_action.h @@ -28,6 +28,9 @@ public: const std::string& pkgName) override; void RefreshActivity(int64_t callTimeMs __unused, UserActivityType type __unused, uint32_t flags __unused) override {} + DisplayState GetDisplayState() override; + uint32_t SetDisplayState(DisplayState state) override; + uint32_t GoToSleep() override; }; } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/src/power_mgr_service.cpp b/services/native/src/power_mgr_service.cpp index 535e8682..ca73385f 100644 --- a/services/native/src/power_mgr_service.cpp +++ b/services/native/src/power_mgr_service.cpp @@ -198,6 +198,11 @@ void PowerMgrService::RefreshActivity(int64_t callTimeMs, UserActivityType type, powerStateMachine_->RefreshActivityInner(pid, callTimeMs, type, needChangeBacklight); } +PowerState PowerMgrService::GetState() +{ + return powerStateMachine_->GetState(); +} + bool PowerMgrService::IsScreenOn() { return powerStateMachine_->IsScreenOn(); @@ -220,6 +225,42 @@ inline void PowerMgrService::FillUserIPCInfo(UserIPCInfo &userIPCinfo) userIPCinfo.uid = IPCSkeleton::GetCallingUid(); } +void PowerMgrService::CreateRunningLock(const sptr& token, const RunningLockInfo& runningLockInfo) +{ + auto uid = IPCSkeleton::GetCallingUid(); + if ((uid >= APP_FIRST_UID) && !Permission::CheckCallingPermission("ohos.permission.RUNNING_LOCK")) { + POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, %{public}d permission check fail", __func__, uid); + return; + } + + POWER_HILOGI(MODULE_SERVICE, "%{public}s :name = %s, type = %d", __func__, + runningLockInfo.name.c_str(), runningLockInfo.type); + + UserIPCInfo userIPCInfo; + FillUserIPCInfo(userIPCInfo); + runningLockMgr_->CreateRunningLock(token, runningLockInfo, userIPCInfo); +} + +void PowerMgrService::ReleaseRunningLock(const sptr& token) +{ + auto uid = IPCSkeleton::GetCallingUid(); + if ((uid >= APP_FIRST_UID) && !Permission::CheckCallingPermission("ohos.permission.RUNNING_LOCK")) { + POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, %{public}d permission check fail", __func__, uid); + return; + } + + POWER_HILOGI(MODULE_SERVICE, "%{public}s called.", __func__); + runningLockMgr_->ReleaseLock(token); +} + +bool PowerMgrService::IsRunningLockTypeSupported(uint32_t type) +{ + if (type >= static_cast(RunningLockType::RUNNINGLOCK_BUTT)) { + return false; + } + return true; +} + void PowerMgrService::Lock(const sptr& token, const RunningLockInfo& runningLockInfo, uint32_t timeOutMS) { auto uid = IPCSkeleton::GetCallingUid(); @@ -234,8 +275,6 @@ void PowerMgrService::Lock(const sptr& token, const RunningLockIn UserIPCInfo userIPCInfo; FillUserIPCInfo(userIPCInfo); runningLockMgr_->Lock(token, runningLockInfo, userIPCInfo, timeOutMS); - // notify runninglock is changed, true means unlock, false means lock - NotifyRunningLockChanged(false); } void PowerMgrService::UnLock(const sptr& token) @@ -248,8 +287,6 @@ void PowerMgrService::UnLock(const sptr& token) POWER_HILOGI(MODULE_SERVICE, "%{public}s called.", __func__); runningLockMgr_->UnLock(token); - // notify runninglock is changed, true means unlock, false means lock - NotifyRunningLockChanged(true); } void PowerMgrService::ForceUnLock(const sptr& token) diff --git a/services/native/src/power_state_machine.cpp b/services/native/src/power_state_machine.cpp index 24b64fb3..91055adb 100644 --- a/services/native/src/power_state_machine.cpp +++ b/services/native/src/power_state_machine.cpp @@ -30,15 +30,28 @@ namespace OHOS { namespace PowerMgr { -PowerStateMachine::PowerStateMachine(const wptr& pms) : pms_(pms) +PowerStateMachine::PowerStateMachine(const wptr& pms) + : pms_(pms), currentState_(PowerState::UNKNOWN) { + POWER_HILOGI(MODULE_SERVICE,"PowerStateMachine_currentState: func is Start."); // NOTICE Need get screen state when device startup, rightnow we set screen is on as default - mDeviceState_.screenState.state = ScreenStateType::SCREEN_ON; mDeviceState_.screenState.lastUpdateTime = GetTickCount(); mDeviceState_.lastWakeupEventTime = 0; mDeviceState_.lastRefreshActivityTime = 0; mDeviceState_.lastWakeupDeviceTime = 0; mDeviceState_.lastSuspendDeviceTime = 0; + + //init lock map which will block state transit + std::vector awakeBlocker {}; + std::vector inactiveBlocker {RunningLockType::RUNNINGLOCK_SCREEN, + RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL}; + std::vector sleepBlocker {RunningLockType::RUNNINGLOCK_BACKGROUND}; + lockMap_.emplace(PowerState::AWAKE, std::make_shared>(awakeBlocker)); + lockMap_.emplace(PowerState::INACTIVE, std::make_shared>(inactiveBlocker)); + lockMap_.emplace(PowerState::SLEEP, std::make_shared>(sleepBlocker)); + + + POWER_HILOGI(MODULE_SERVICE,"PowerStateMachine_currentState: func is End."); } PowerStateMachine::~PowerStateMachine() {} @@ -46,6 +59,52 @@ PowerStateMachine::~PowerStateMachine() {} bool PowerStateMachine::Init() { POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine:: Init start"); + + //init state controller map + controllerMap_.emplace(PowerState::AWAKE, + std::make_shared(PowerState::AWAKE, shared_from_this(), [this] { + POWER_HILOGI(MODULE_SERVICE,"StateController_AWAKE: func is Start."); + uint32_t ret = stateAction_->SetDisplayState(DisplayState::DISPLAY_ON); + if (ret != ActionResult::SUCCESS) { + POWER_HILOGE(MODULE_SERVICE, "Failed to go to AWAKE, Display Err"); + return TransitResult::HDI_ERR; + } + ResetInactiveTimer(); + POWER_HILOGI(MODULE_SERVICE,"StateController_AWAKE: func is End."); + return TransitResult::SUCCESS; + }) + ); + controllerMap_.emplace(PowerState::INACTIVE, + std::make_shared(PowerState::INACTIVE, shared_from_this(), [this] { + POWER_HILOGI(MODULE_SERVICE,"StateController_INACTIVE: func is Start."); + uint32_t ret = stateAction_->SetDisplayState(DisplayState::DISPLAY_OFF); + if (ret != ActionResult::SUCCESS) { + POWER_HILOGE(MODULE_SERVICE, "Failed to go to INACTIVE, Display Err"); + return TransitResult::HDI_ERR; + } + ResetSleepTimer(); + POWER_HILOGI(MODULE_SERVICE,"StateController_INACTIVE: func is End."); + return TransitResult::SUCCESS; + }) + ); + controllerMap_.emplace(PowerState::SLEEP, + std::make_shared(PowerState::SLEEP, shared_from_this(), [this] { + POWER_HILOGI(MODULE_SERVICE,"StateController_SLEEP: func is Start."); + uint32_t ret = stateAction_->SetDisplayState(DisplayState::DISPLAY_OFF); + if (ret != ActionResult::SUCCESS) { + POWER_HILOGE(MODULE_SERVICE, "Failed to go to SLEEP, Display Err"); + return TransitResult::HDI_ERR; + } + ret = stateAction_->GoToSleep(); + if (ret != ActionResult::SUCCESS) { + POWER_HILOGE(MODULE_SERVICE, "Failed to go to SLEEP, Sleep Err"); + return TransitResult::HDI_ERR; + } + POWER_HILOGI(MODULE_SERVICE,"StateController_SLEEP: func is End."); + return TransitResult::SUCCESS; + }) + ); + stateAction_ = PowerMgrFactory::GetDeviceStateAction(); if (powerStateCBDeathRecipient_ == nullptr) { powerStateCBDeathRecipient_ = new PowerStateCallbackDeathRecipient(); @@ -55,6 +114,12 @@ bool PowerStateMachine::Init() POWER_HILOGE(MODULE_SERVICE, "Failed to start monitor"); return false; } + + if (IsScreenOn()) { + SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_INIT, true); + } else { + SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_INIT, true); + } POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine:: Init success!"); return true; } @@ -74,18 +139,25 @@ void PowerStateMachine::SuspendDeviceInner(pid_t pid, int64_t callTimeMs, Suspen } else { POWER_HILOGE(MODULE_SERVICE, "Suspend Device Failed, Screen State is ignored!"); } + + SetState(PowerState::INACTIVE, GetReasionBySuspendType(type), true); + POWER_HILOGI(MODULE_SERVICE, "SuspendDeviceInner: fun is End!"); } void PowerStateMachine::WakeupDeviceInner(pid_t pid, int64_t callTimeMs, WakeupDeviceType type, const std::string& details, const std::string& pkgName) { POWER_HILOGI(MODULE_SERVICE, "PID: %{public}d Try to Wakeup Device!!", pid); - // Check the screen state + + // Call legacy wakeup, Check the screen state if (stateAction_ != nullptr) { stateAction_->Wakeup(callTimeMs, type, details, pkgName); } mDeviceState_.lastWakeupDeviceTime = callTimeMs; - POWER_HILOGD(MODULE_SERVICE, "Wakeup Device Call Binder Success!!"); + + SetState(PowerState::AWAKE, GetReasonByWakeType(type), true); + + POWER_HILOGD(MODULE_SERVICE, "Wakeup Device Call"); } void PowerStateMachine::RefreshActivityInner(pid_t pid, int64_t callTimeMs, UserActivityType type, @@ -104,26 +176,40 @@ void PowerStateMachine::RefreshActivityInner(pid_t pid, int64_t callTimeMs, User if (stateAction_ != nullptr) { stateAction_->RefreshActivity(callTimeMs, type, needChangeBacklight ? REFRESH_ACTIVITY_NEED_CHANGE_LIGHTS : REFRESH_ACTIVITY_NO_CHANGE_LIGHTS); + stateAction_->SetDisplayState(DisplayState::DISPLAY_ON); } + //reset timer + ResetInactiveTimer(); POWER_HILOGD(MODULE_SERVICE, "Refresh Activity Call Binder Success!!"); } else { POWER_HILOGE(MODULE_SERVICE, "RefreshActivity Failed, Screen is Off!"); } + POWER_HILOGI(MODULE_SERVICE, "RefreshActivityInner: fun is End!"); } bool PowerStateMachine::ForceSuspendDeviceInner(pid_t pid, int64_t callTimeMs) { + POWER_HILOGI(MODULE_SERVICE, "ForceSuspendDeviceInner: fun is Start!"); if (stateAction_ != nullptr) { stateAction_->ForceSuspend(); } - return true; + + bool ret = SetState(PowerState::SLEEP, StateChangeReason::STATE_CHANGE_REASON_SYSTEM, true); + if (!ret) { + // if can't go to sleep, turn to inactive + SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_SYSTEM, true); + } + POWER_HILOGI(MODULE_SERVICE, "ForceSuspendDeviceInner: fun is End!"); + return ret; } bool PowerStateMachine::IsScreenOn() { + POWER_HILOGI(MODULE_SERVICE, "IsScreenOn: fun is Start!"); std::lock_guard lock(mutex_); - if (mDeviceState_.screenState.state == ScreenStateType::SCREEN_ON || - mDeviceState_.screenState.state == ScreenStateType::SCREEN_DIM) { + DisplayState state = stateAction_->GetDisplayState(); + if (state == DisplayState::DISPLAY_ON || + state == DisplayState::DISPLAY_DIM) { POWER_HILOGI(MODULE_SERVICE, "Current Screen State: On!"); return true; } @@ -133,10 +219,10 @@ bool PowerStateMachine::IsScreenOn() void PowerStateMachine::ReceiveScreenEvent(bool isScreenOn) { + POWER_HILOGI(MODULE_SERVICE, "ReceiveScreenEvent: fun is Start!"); std::lock_guard lock(mutex_); auto prestate = mDeviceState_.screenState.state; mDeviceState_.screenState.lastUpdateTime = GetTickCount(); - mDeviceState_.screenState.state = isScreenOn ? ScreenStateType::SCREEN_ON : ScreenStateType::SCREEN_OFF; if (prestate != mDeviceState_.screenState.state) { NotifyPowerStateChanged(isScreenOn ? PowerState::AWAKE : PowerState::INACTIVE); } @@ -146,6 +232,7 @@ void PowerStateMachine::ReceiveScreenEvent(bool isScreenOn) void PowerStateMachine::RegisterPowerStateCallback(const sptr& callback) { + POWER_HILOGI(MODULE_SERVICE, "RegisterPowerStateCallback: fun is Start!"); std::lock_guard lock(mutex_); RETURN_IF(callback == nullptr); auto object = callback->AsObject(); @@ -162,6 +249,7 @@ void PowerStateMachine::RegisterPowerStateCallback(const sptr& callback) { + POWER_HILOGI(MODULE_SERVICE, "UnRegisterPowerStateCallback: fun is Start!"); std::lock_guard lock(mutex_); RETURN_IF(callback == nullptr); auto object = callback->AsObject(); @@ -192,6 +280,7 @@ void PowerStateMachine::NotifyPowerStateChanged(PowerState state) void PowerStateMachine::SendEventToPowerMgrNotify(PowerState state, int64_t callTime) { + POWER_HILOGD(MODULE_SERVICE, "SendEventToPowerMgrNotify: fun is Start!"); auto pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { POWER_HILOGE(MODULE_SERVICE, "SendEventToPowerMgrNotify pms is Null, Fail!!"); @@ -204,15 +293,19 @@ void PowerStateMachine::SendEventToPowerMgrNotify(PowerState state, int64_t call } if (state == PowerState::AWAKE) { notify->PublishScreenOnEvents(callTime); - } else { + } else if(state == PowerState::INACTIVE) { notify->PublishScreenOffEvents(callTime); + } else { + POWER_HILOGI(MODULE_SERVICE, "No need to publish event, state:%d", state); } + POWER_HILOGD(MODULE_SERVICE, "SendEventToPowerMgrNotify: fun is End!"); } const std::string TASK_UNREG_POWER_STATE_CALLBACK = "PowerState_UnRegPowerStateCB"; void PowerStateMachine::PowerStateCallbackDeathRecipient::OnRemoteDied(const wptr& remote) { + POWER_HILOGD(MODULE_SERVICE, "OnRemoteDied: fun is Start!"); if (remote == nullptr || remote.promote() == nullptr) { return; } @@ -229,10 +322,12 @@ void PowerStateMachine::PowerStateCallbackDeathRecipient::OnRemoteDied(const wpt sptr callback = iface_cast(remote.promote()); std::function unRegFunc = std::bind(&PowerMgrService::UnRegisterPowerStateCallback, pms, callback); handler->PostTask(unRegFunc, TASK_UNREG_POWER_STATE_CALLBACK); + POWER_HILOGD(MODULE_SERVICE, "OnRemoteDied: fun is End!"); } void PowerStateMachine::SetDelayTimer(int64_t delayTime, int32_t event) { + POWER_HILOGD(MODULE_SERVICE, "SetDelayTimer: fun is Start!"); auto pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { return; @@ -243,10 +338,12 @@ void PowerStateMachine::SetDelayTimer(int64_t delayTime, int32_t event) return; } handler->SendEvent(event, 0, delayTime); + POWER_HILOGD(MODULE_SERVICE, "SetDelayTimer: fun is End!"); } void PowerStateMachine::CancelDelayTimer(int32_t event) { + POWER_HILOGD(MODULE_SERVICE, "CancelDelayTimer: fun is Start!"); auto pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { return; @@ -258,11 +355,286 @@ void PowerStateMachine::CancelDelayTimer(int32_t event) } handler->RemoveEvent(event); POWER_HILOGI(MODULE_SERVICE, "remove event success"); + POWER_HILOGD(MODULE_SERVICE, "CancelDelayTimer: fun is End!"); +} + +void PowerStateMachine::ResetInactiveTimer() +{ + POWER_HILOGD(MODULE_SERVICE, "ResetInactiveTimer: fun is Start!"); + CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG); + CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG); + CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG); + + if (this->CheckRunningLock(PowerState::INACTIVE)) { + this->SetDelayTimer(this->GetDisplayOffTime()/2, PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG); + } + POWER_HILOGD(MODULE_SERVICE, "ResetInactiveTimer: fun is End!"); +} + +void PowerStateMachine::ResetSleepTimer() +{ + POWER_HILOGD(MODULE_SERVICE, "ResetSleepTimer: fun is Start!"); + CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG); + CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG); + CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG); + + if (this->CheckRunningLock(PowerState::SLEEP)) { + this->SetDelayTimer(this->GetSleepTime(), PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG); + } + POWER_HILOGD(MODULE_SERVICE, "ResetSleepTimer: fun is End!"); +} + +void PowerStateMachine::HandleDelayTimer(int32_t event) +{ + POWER_HILOGD(MODULE_SERVICE, "handle delay timer: (%d)", event); + switch (event) { + case PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG: + HandleActivityTimeout(); + break; + case PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG: + HandleActivityOffTimeout(); + break; + case PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG: + HandleActivitySleepTimeout(); + break; + default: + break; + } + POWER_HILOGD(MODULE_SERVICE, "ResetSleepTimer: fun is End!"); +} + +void PowerStateMachine::HandleActivityTimeout() +{ + POWER_HILOGI(MODULE_SERVICE, "HandleActivityTimeout (%{public}d)", stateAction_->GetDisplayState()); + if (stateAction_->GetDisplayState() == DisplayState::DISPLAY_ON) { + stateAction_->SetDisplayState(DisplayState::DISPLAY_DIM); + SetDelayTimer(GetDisplayOffTime()/2, PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG); + } + POWER_HILOGI(MODULE_SERVICE, "HandleActivityTimeout: fun is End!"); +} + +void PowerStateMachine::HandleActivityOffTimeout() +{ + POWER_HILOGI(MODULE_SERVICE, "HandleActivityDimTimeout (%{public}d)", stateAction_->GetDisplayState()); + if (stateAction_->GetDisplayState() == DisplayState::DISPLAY_DIM) { + SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT); + } + POWER_HILOGI(MODULE_SERVICE, "HandleActivityOffTimeOut: fun is End!"); +} + +void PowerStateMachine::HandleActivitySleepTimeout() +{ + POWER_HILOGI(MODULE_SERVICE, "HandleActivityOffTimeout (%{public}d)", stateAction_->GetDisplayState()); + if (stateAction_->GetDisplayState() == DisplayState::DISPLAY_OFF) { + SetState(PowerState::SLEEP, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT); + } + POWER_HILOGI(MODULE_SERVICE, "HandleActivitySleepTimeout: fun is End!"); +} + +bool PowerStateMachine::CheckRunningLock(PowerState state) +{ + POWER_HILOGI(MODULE_SERVICE, "CheckRunningLock: fun is Start!"); + auto pms = pms_.promote(); + if (pms == nullptr) { + POWER_HILOGE(MODULE_SERVICE, "CheckRunningLock: promote failed!"); + return false; + } + auto runningLockMgr = pms->GetRunningLockMgr(); + if (runningLockMgr == nullptr) { + POWER_HILOGE(MODULE_SERVICE, "CheckRunningLock: GetRunningLockMgr failed!"); + return false; + } + auto iterator = lockMap_.find(state); + if (iterator == lockMap_.end()) { + POWER_HILOGE(MODULE_SERVICE, "CheckRunningLock: map find failed!"); + return false; + } + + std::shared_ptr> pLock = iterator->second; + for (std::vector::const_iterator iter = pLock->begin();iter != pLock->end(); ++iter) { + uint32_t count = runningLockMgr->GetValidRunningLockNum(*iter); + if(count > 0) { + POWER_HILOGE(MODULE_SERVICE, "RunningLock(%d) is locking (%d) for state (%d)",*iter, count, state); + return false; + } + } + + POWER_HILOGI(MODULE_SERVICE, "No RunningLock block for state (%d)", state); + return true; +} + +int64_t PowerStateMachine::GetDisplayOffTime() +{ + POWER_HILOGI(MODULE_SERVICE, "GetDisplayOffTime: fun is Start!"); + //temp solution, will get from mode xml + return 5000; +} + +int64_t PowerStateMachine::GetSleepTime() +{ + POWER_HILOGI(MODULE_SERVICE, "GetSleepTime: fun is Start!"); + //temp solution, will get from mode xml + return 5000; +} + +bool PowerStateMachine::SetState(PowerState state, StateChangeReason reason, bool force) +{ + POWER_HILOGI(MODULE_SERVICE, "SetState state=%{public}d, reason=%{public}d, force=%{public}d", + state, reason, force); + auto iterator = controllerMap_.find(state); + if (iterator == controllerMap_.end()) { + return false; + } + std::shared_ptr pController = iterator->second; + if (pController == nullptr) { + POWER_HILOGE(MODULE_SERVICE, "AWAKE State not initiated"); + return false; + } + TransitResult ret = pController->TransitTo(reason, true); + POWER_HILOGI(MODULE_SERVICE, "SetState: fun is End!"); + return (ret == TransitResult::SUCCESS || ret ==TransitResult::ALREADY_IN_STATE); } -void PowerStateMachine::HandleDelayTimer() +StateChangeReason PowerStateMachine::GetReasonByUserActivity(UserActivityType type) { - POWER_HILOGI(MODULE_SERVICE, "handle delay timer success"); + POWER_HILOGI(MODULE_SERVICE, "GetReasonByUserActivity Start:%{public}d", type); + StateChangeReason ret = StateChangeReason::STATE_CHANGE_REASON_UNKNOWN; + switch(type) { + case UserActivityType::USER_ACTIVITY_TYPE_BUTTON: + ret = StateChangeReason::STATE_CHANGE_REASON_HARD_KEY; + break; + case UserActivityType::USER_ACTIVITY_TYPE_TOUCH: + ret = StateChangeReason::STATE_CHANGE_REASON_TOUCH; + break; + case UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY: + ret = StateChangeReason::STATE_CHANGE_REASON_ACCESSIBILITY; + break; + case UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE: + ret = StateChangeReason::STATE_CHANGE_REASON_APPLICATION; + break; + case UserActivityType::USER_ACTIVITY_TYPE_ATTENTION: //fail through + case UserActivityType::USER_ACTIVITY_TYPE_OTHER: //fail through + default: + break; + } + POWER_HILOGI(MODULE_SERVICE, "GetReasonByUserActivity: fun is End!"); + return ret; +} + + +StateChangeReason PowerStateMachine::GetReasonByWakeType(WakeupDeviceType type) +{ + POWER_HILOGI(MODULE_SERVICE, "GetReasonByWakeType Start:%{public}d", type); + StateChangeReason ret = StateChangeReason::STATE_CHANGE_REASON_UNKNOWN; + switch(type) { + case WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON: + case WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY: + ret = StateChangeReason::STATE_CHANGE_REASON_HARD_KEY; + break; + case WakeupDeviceType::WAKEUP_DEVICE_APPLICATION: + ret = StateChangeReason::STATE_CHANGE_REASON_APPLICATION; + break; + case WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN: + case WakeupDeviceType::WAKEUP_DEVICE_HDMI: + ret = StateChangeReason::STATE_CHANGE_REASON_CABLE; + break; + case WakeupDeviceType::WAKEUP_DEVICE_GESTURE: + ret = StateChangeReason::STATE_CHANGE_REASON_TOUCH; + break; + case WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH: + ret = StateChangeReason::STATE_CHANGE_REASON_CAMERA; + break; + case WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION: + ret = StateChangeReason::STATE_CHANGE_REASON_SENSOR; + break; + case WakeupDeviceType::WAKEUP_DEVICE_LID: + ret = StateChangeReason::STATE_CHANGE_REASON_LID; + break; + case WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN: //fail through + default: + break; + } + POWER_HILOGI(MODULE_SERVICE, "GetReasonByWakeType: fun is End!"); + return ret; +} + +StateChangeReason PowerStateMachine::GetReasionBySuspendType(SuspendDeviceType type) +{ + POWER_HILOGI(MODULE_SERVICE, "GetReasionBySuspendType Start:%{public}d", type); + StateChangeReason ret = StateChangeReason::STATE_CHANGE_REASON_UNKNOWN; + switch(type) { + case SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION: + ret = StateChangeReason::STATE_CHANGE_REASON_APPLICATION; + break; + case SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN: + ret = StateChangeReason::STATE_CHANGE_REASON_REMOTE; + break; + case SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT: + ret = StateChangeReason::STATE_CHANGE_REASON_TIMEOUT; + break; + case SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH: + ret = StateChangeReason::STATE_CHANGE_REASON_LID; + break; + case SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON: + case SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON: + ret = StateChangeReason::STATE_CHANGE_REASON_HARD_KEY; + break; + case SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI: + ret = StateChangeReason::STATE_CHANGE_REASON_CABLE; + break; + case SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY: + ret = StateChangeReason::STATE_CHANGE_REASON_ACCESSIBILITY; + break; + case SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND: + ret = StateChangeReason::STATE_CHANGE_REASON_SYSTEM; + break; + default: + break; + } + POWER_HILOGI(MODULE_SERVICE, "GetReasionBySuspendType: fun is End!"); + return ret; +} + +TransitResult PowerStateMachine::StateController::TransitTo(StateChangeReason reason, bool ignoreLock) +{ + POWER_HILOGI(MODULE_SERVICE, "TransitTo start"); + std::shared_ptr owner = owner_.lock(); + if (owner == nullptr) { + POWER_HILOGE(MODULE_SERVICE, "TransitTo: no owner"); + return TransitResult::OTHER_ERR; + } + POWER_HILOGI(MODULE_SERVICE, "Transit from %{public}d to %{public}d for %{public}d", + owner->currentState_, this->state_, reason); + TransitResult ret = TransitResult::OTHER_ERR; + if (!CheckState()) { + POWER_HILOGE(MODULE_SERVICE, "TransitTo: already in %d", owner->currentState_); + return TransitResult::ALREADY_IN_STATE; + } + if (!ignoreLock && !owner->CheckRunningLock(GetState())) { + POWER_HILOGE(MODULE_SERVICE, "TransitTo: running lock block"); + return TransitResult::LOCKING; + } + ret = action_(); + if (ret == TransitResult::SUCCESS) { + lastReason_ = reason; + owner->currentState_ = GetState(); + owner->NotifyPowerStateChanged(owner->currentState_); + } + + POWER_HILOGI(MODULE_SERVICE, "Transit End, result=%{public}d", ret); + return ret; } + +bool PowerStateMachine::StateController::CheckState() +{ + POWER_HILOGI(MODULE_SERVICE, "CheckState: fun is Start!"); + std::shared_ptr owner = owner_.lock(); + if (owner == nullptr) { + return false; + } + POWER_HILOGI(MODULE_SERVICE, "CheckState: fun is End!"); + return !(GetState() == owner->currentState_); +} + } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/src/powerms_event_handler.cpp b/services/native/src/powerms_event_handler.cpp index b793e47c..6a4ef8e5 100644 --- a/services/native/src/powerms_event_handler.cpp +++ b/services/native/src/powerms_event_handler.cpp @@ -44,16 +44,18 @@ void PowermsEventHandler::ProcessEvent([[maybe_unused]] const AppExecFwk::InnerE runningLockMgr->CheckOverTime(); break; } - case CHECK_USER_ACTIVITY_TIMEOUT_MSG: { + case CHECK_USER_ACTIVITY_TIMEOUT_MSG: //fallthrough + case CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG: //fallthrough + case CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG: { auto powerStateMachine = pmsptr->GetPowerStateMachine(); if (powerStateMachine == nullptr) { return; } - powerStateMachine->HandleDelayTimer(); + powerStateMachine->HandleDelayTimer(event->GetInnerEventId()); break; } default: - POWER_HILOGD(MODULE_SERVICE, "PowermsEventHandler::no event id matched."); + POWER_HILOGD(MODULE_SERVICE, "PowermsEventHandler::no event id matched."); } } } // namespace PowerMgr diff --git a/services/native/src/running_lock_mgr.cpp b/services/native/src/running_lock_mgr.cpp index 94481fbd..de8c3218 100644 --- a/services/native/src/running_lock_mgr.cpp +++ b/services/native/src/running_lock_mgr.cpp @@ -53,6 +53,62 @@ bool RunningLockMgr::Init() return false; } handler_ = pmsptr->GetHandler(); + + systemLocks_.emplace(SystemLockType::SYSTEM_LOCK_APP, + std::make_shared(runningLockAction_, LOCK_TAG_APP)); + systemLocks_.emplace(SystemLockType::SYSTEM_LOCK_DISPLAY, + std::make_shared(runningLockAction_, LOCK_TAG_DISPLAY)); + + lockCounters_.emplace(RunningLockType::RUNNINGLOCK_SCREEN, std::make_shared( + RunningLockType::RUNNINGLOCK_SCREEN, [this](bool active) { + auto pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + return; + } + auto stateMachine = pms->GetPowerStateMachine(); + if (stateMachine == nullptr) { + return; + } + if (active) { + stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK); + } else { + stateMachine->ResetInactiveTimer(); + } + }) + ); + + lockCounters_.emplace(RunningLockType::RUNNINGLOCK_BACKGROUND, std::make_shared( + RunningLockType::RUNNINGLOCK_SCREEN, [this](bool active) { + auto iterator = systemLocks_.find(SystemLockType::SYSTEM_LOCK_APP); + if (iterator == systemLocks_.end()) { + return; + } + std::shared_ptr pSysLock = iterator->second; + if (active) { + pSysLock->Lock(); + } else { + pSysLock->Unlock(); + } + }) + ); + + lockCounters_.emplace(RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL, std::make_shared( + RunningLockType::RUNNINGLOCK_SCREEN, [this](bool active) { + auto iterator = systemLocks_.find(SystemLockType::SYSTEM_LOCK_APP); + if (iterator == systemLocks_.end()) { + return; + } + std::shared_ptr pSysLock = iterator->second; + if (active) { + pSysLock->Lock(); + proximityController_.Enable(); + } else { + pSysLock->Unlock(); + proximityController_.Disable(); + } + }) + ); + POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::Init success"); return true; } @@ -67,7 +123,7 @@ std::shared_ptr RunningLockMgr::GetRunningLockInner(const sptr return nullptr; } -std::shared_ptr RunningLockMgr::CreateRunningLockInner(const sptr& token, +std::shared_ptr RunningLockMgr::CreateRunningLock(const sptr& token, const RunningLockInfo& runningLockInfo, const UserIPCInfo& userIPCinfo) { auto lockInner = RunningLockInner::CreateRunningLockInner(runningLockInfo, userIPCinfo); @@ -79,10 +135,24 @@ std::shared_ptr RunningLockMgr::CreateRunningLockInner(const s runningLocks_.emplace(token, lockInner); token->AddDeathRecipient(runningLockDeathRecipient_); - SetRunningLockDisableFlag(lockInner); return lockInner; } +void RunningLockMgr::ReleaseLock(const sptr token) +{ + std::lock_guard lock(mutex_); + POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :token = %p", __func__, token.GetRefPtr()); + auto lockInner = GetRunningLockInner(token); + if (lockInner == nullptr) { + return; + } + if (!lockInner->GetDisabled()) { + UnLock(token); + } + runningLocks_.erase(token); + token->RemoveDeathRecipient(runningLockDeathRecipient_); +} + void RunningLockMgr::RemoveAndPostUnlockTask(const sptr& token, uint32_t timeOutMS) { auto handler = handler_.lock(); @@ -108,21 +178,28 @@ void RunningLockMgr::Lock(const sptr& token, const RunningLockInf auto lockInner = GetRunningLockInner(token); if (lockInner == nullptr) { - lockInner = CreateRunningLockInner(token, runningLockInfo, userIPCinfo); - if (lockInner == nullptr) { - POWER_HILOGE(MODULE_SERVICE, "RunningLockMgr::%{public}s :CreateRunningLockInner err,name = %s,type = %d", - __func__, runningLockInfo.name.c_str(), runningLockInfo.type); - return; - } + POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::Lock failed, can't find %p", token.GetRefPtr()); + return; + } + if (!lockInner->GetDisabled()) { + POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::Lock, this lock(%s) is already on", + lockInner->GetRunningLockName().c_str()); + return; + } + lockInner->SetDisabled(false); - LockReally(token, lockInner); - POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::%{public}s :insert ok,name = %s,type = %d", __func__, - runningLockInfo.name.c_str(), runningLockInfo.type); - } else { - POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::%{public}s :GetRunningLockInner ok,name = %s,type = %d", - __func__, runningLockInfo.name.c_str(), runningLockInfo.type); + auto iterator = lockCounters_.find(lockInner->GetRunningLockType()); + if (iterator == lockCounters_.end()) { + POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::Lock failed, unsupported type %d", + lockInner->GetRunningLockType()); + return; + } + std::shared_ptr counter = iterator->second; + counter->Increase(); + + if (timeOutMS > 0) { + RemoveAndPostUnlockTask(token, timeOutMS); } - RemoveAndPostUnlockTask(token, timeOutMS); } void RunningLockMgr::UnLock(const sptr token) @@ -134,22 +211,29 @@ void RunningLockMgr::UnLock(const sptr token) if (lockInner == nullptr) { return; } - RemoveAndPostUnlockTask(token); - runningLocks_.erase(token); - token->RemoveDeathRecipient(runningLockDeathRecipient_); - // Only disabled lock can really unlocked it. + if (lockInner->GetDisabled()) { + POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::Unlock, this lock(%s) is already off", + lockInner->GetRunningLockName().c_str()); + return; + } lockInner->SetDisabled(true); - UnLockReally(token, lockInner); - POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::%{public}s :name = %s,type = %d,use_count = %ld,erase ok", __func__, - lockInner->GetRunningLockName().c_str(), lockInner->GetRunningLockType(), - lockInner.use_count()); + RemoveAndPostUnlockTask(token); + + auto iterator = lockCounters_.find(lockInner->GetRunningLockType()); + if (iterator == lockCounters_.end()) { + POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::Unlock failed, unsupported type %d", + lockInner->GetRunningLockType()); + return; + } + std::shared_ptr counter = iterator->second; + counter->Decrease(); } bool RunningLockMgr::IsUsed(const sptr& token) { std::lock_guard lock(mutex_); auto lockInner = GetRunningLockInner(token); - if (lockInner == nullptr) { + if (lockInner == nullptr || lockInner->GetDisabled()) { return false; } return true; @@ -170,12 +254,14 @@ uint32_t RunningLockMgr::GetRunningLockNum(RunningLockType type) uint32_t RunningLockMgr::GetValidRunningLockNum(RunningLockType type) { std::lock_guard lock(mutex_); - return std::count_if(runningLocks_.begin(), runningLocks_.end(), - [&type](const auto& pair) { - auto& lockinner = pair.second; - return (((type == lockinner->GetRunningLockType()) || (type == RunningLockType::RUNNINGLOCK_BUTT)) && - (lockinner->GetDisabled() == false)); - }); + auto iterator = lockCounters_.find(type); + if (iterator == lockCounters_.end()) { + POWER_HILOGD(MODULE_SERVICE, "GetValidRunningLockNum failed, unsupported type %d", type); + return 0; + } + std::shared_ptr counter = iterator->second; + + return counter->GetCount(); } bool RunningLockMgr::ExistValidRunningLock() @@ -573,5 +659,90 @@ void RunningLockMgr::RunningLockDeathRecipient::OnRemoteDied(const wptrPostTask(forceUnLockFunc, TASK_RUNNINGLOCK_FORCEUNLOCK); } + +void RunningLockMgr::SystemLock::Lock() +{ + if (!locking_) { + action_->Lock(RunningLockType::RUNNINGLOCK_BUTT, tag_.c_str()); + locking_ = true; + } +} + +void RunningLockMgr::SystemLock::Unlock() +{ + if (locking_) { + action_->Unlock(RunningLockType::RUNNINGLOCK_BUTT, tag_.c_str()); + locking_ = false; + } +} + +uint32_t RunningLockMgr::LockCounter::Increase() +{ + ++counter_; + if (counter_ == 1) { + activate_(true); + } + return counter_; +} + +uint32_t RunningLockMgr::LockCounter::Decrease() +{ + --counter_; + if (counter_ == 0) { + activate_(false); + } + return counter_; +} + +RunningLockMgr::ProximityController::ProximityController() : enabled_(false) +{ +} + +RunningLockMgr::ProximityController::~ProximityController() +{ +} + +void RunningLockMgr::ProximityController::Enable() +{ + enabled_ = true; +} + +void RunningLockMgr::ProximityController::Disable() +{ + enabled_ = false; +} + +void RunningLockMgr::ProximityController::OnProximity() +{ + if (!enabled_) { + return; + } + auto pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + return; + } + auto stateMachine = pms->GetPowerStateMachine(); + if (stateMachine == nullptr) { + return; + } + stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_SENSOR, true); +} + +void RunningLockMgr::ProximityController::OnAway() +{ + if (!enabled_) { + return; + } + auto pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + return; + } + auto stateMachine = pms->GetPowerStateMachine(); + if (stateMachine == nullptr) { + return; + } + stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_SENSOR, true); +} + } // namespace PowerMgr } // namespace OHOS diff --git a/services/zidl/include/power_mgr_proxy.h b/services/zidl/include/power_mgr_proxy.h index 9ad1ab8d..0d4e2415 100644 --- a/services/zidl/include/power_mgr_proxy.h +++ b/services/zidl/include/power_mgr_proxy.h @@ -31,6 +31,9 @@ public: ~PowerMgrProxy() = default; DISALLOW_COPY_AND_MOVE(PowerMgrProxy); + virtual void CreateRunningLock(const sptr& token, const RunningLockInfo& runningLockInfo) override; + virtual void ReleaseRunningLock(const sptr& token) override; + virtual bool IsRunningLockTypeSupported(uint32_t type) override; virtual void Lock(const sptr& token, const RunningLockInfo& runningLockInfo, uint32_t timeOutMs) override; virtual void UnLock(const sptr& token) override; @@ -41,6 +44,7 @@ public: virtual void SuspendDevice(int64_t callTimeMs, SuspendDeviceType reason, bool suspendImmed) override; virtual void WakeupDevice(int64_t callTimeMs, WakeupDeviceType reason, const std::string& details) override; virtual void RefreshActivity(int64_t callTimeMs, UserActivityType type, bool needChangeBacklight) override; + virtual PowerState GetState() override; virtual bool IsScreenOn() override; virtual bool ForceSuspendDevice(int64_t callTimeMs) override; virtual void RebootDevice(const std::string& reason) override; diff --git a/services/zidl/include/power_mgr_stub.h b/services/zidl/include/power_mgr_stub.h index 74f92b23..354f2376 100644 --- a/services/zidl/include/power_mgr_stub.h +++ b/services/zidl/include/power_mgr_stub.h @@ -34,9 +34,13 @@ private: int32_t WakeupDeviceStub(MessageParcel& data); int32_t SuspendDeviceStub(MessageParcel& data); int32_t RefreshActivityStub(MessageParcel& data); + int32_t GetStateStub(MessageParcel& reply); int32_t IsScreeOnStub(MessageParcel& reply); int32_t ForceSuspendDeviceStub(MessageParcel& data, MessageParcel& reply); int32_t ProxyRunningLockStub(MessageParcel& data); + int32_t CreateRunningLockStub(MessageParcel& data); + int32_t ReleaseRunningLockStub(MessageParcel& data); + int32_t IsRunningLockTypeSupportedStub(MessageParcel& data); int32_t LockStub(MessageParcel& data); int32_t UnLockStub(MessageParcel& data); int32_t SetWorkTriggerListStub(MessageParcel& data); diff --git a/services/zidl/src/power_mgr_proxy.cpp b/services/zidl/src/power_mgr_proxy.cpp index c1557ef1..30256077 100644 --- a/services/zidl/src/power_mgr_proxy.cpp +++ b/services/zidl/src/power_mgr_proxy.cpp @@ -23,6 +23,84 @@ namespace OHOS { namespace PowerMgr { +void PowerMgrProxy::CreateRunningLock(const sptr& token, const RunningLockInfo& runningLockInfo) +{ + sptr remote = Remote(); + RETURN_IF(remote == nullptr); + + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s write descriptor failed!", __func__); + return; + } + + WRITE_PARCEL_NO_RET(data, RemoteObject, token.GetRefPtr()); + WRITE_PARCEL_NO_RET(data, Parcelable, &runningLockInfo); + + int ret = remote->SendRequest(static_cast(IPowerMgr::CREATE_RUNNINGLOCK), + data, reply, option); + if (ret != ERR_OK) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s SendRequest is failed, error code: %d", __func__, ret); + return; + } +} + +void PowerMgrProxy::ReleaseRunningLock(const sptr& token) +{ + sptr remote = Remote(); + RETURN_IF(remote == nullptr); + + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s write descriptor failed!", __func__); + return; + } + + WRITE_PARCEL_NO_RET(data, RemoteObject, token.GetRefPtr()); + + int ret = remote->SendRequest(static_cast(IPowerMgr::RELEASE_RUNNINGLOCK), + data, reply, option); + if (ret != ERR_OK) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s SendRequest is failed, error code: %d", __func__, ret); + return; + } +} + +bool PowerMgrProxy::IsRunningLockTypeSupported(uint32_t type) +{ + sptr remote = Remote(); + RETURN_IF_WITH_RET(remote == nullptr, false); + + bool result = false; + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s write descriptor failed!", __func__); + return result; + } + + WRITE_PARCEL_WITH_RET(data, Uint32, static_cast(type), false); + int ret = remote->SendRequest(static_cast(IPowerMgr::IS_RUNNINGLOCK_TYPE_SUPPORTED), data, reply, option); + if (ret != ERR_OK) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s SendRequest is failed, error code: %d", __func__, ret); + return result; + } + + if (!reply.ReadBool(result)) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s Readback fail!", __func__); + } + + return result; +} + void PowerMgrProxy::Lock(const sptr& token, const RunningLockInfo& runningLockInfo, uint32_t timeOutMs) { sptr remote = Remote(); @@ -295,6 +373,34 @@ bool PowerMgrProxy::ForceSuspendDevice(int64_t callTimeMs) return result; } +PowerState PowerMgrProxy::GetState() +{ + sptr remote = Remote(); + RETURN_IF_WITH_RET(remote == nullptr, PowerState::UNKNOWN); + + uint32_t result = 0; + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s write descriptor failed!", __func__); + return PowerState::UNKNOWN; + } + + int ret = remote->SendRequest(static_cast(IPowerMgr::IS_SCREEN_ON), data, reply, option); + if (ret != ERR_OK) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s SendRequest is failed, error code: %d", __func__, ret); + return PowerState::UNKNOWN; + } + if (!reply.ReadUint32(result)) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s Readback fail!", __func__); + return PowerState::UNKNOWN; + } + + return static_cast(result); +} + bool PowerMgrProxy::IsScreenOn() { sptr remote = Remote(); diff --git a/services/zidl/src/power_mgr_stub.cpp b/services/zidl/src/power_mgr_stub.cpp index 023fcd64..dcab4ce7 100644 --- a/services/zidl/src/power_mgr_stub.cpp +++ b/services/zidl/src/power_mgr_stub.cpp @@ -51,12 +51,24 @@ int PowerMgrStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessagePar case static_cast(IPowerMgr::SHUTDOWN_DEVICE): { return ShutDownDeviceStub(data); } + case static_cast(IPowerMgr::GET_STATE): { + return GetStateStub(reply); + } case static_cast(IPowerMgr::IS_SCREEN_ON): { return IsScreeOnStub(reply); } case static_cast(IPowerMgr::FORCE_DEVICE_SUSPEND): { return ForceSuspendDeviceStub(data, reply); } + case static_cast(IPowerMgr::CREATE_RUNNINGLOCK): { + return CreateRunningLockStub(data); + } + case static_cast(IPowerMgr::RELEASE_RUNNINGLOCK): { + return ReleaseRunningLockStub(data); + } + case static_cast(IPowerMgr::IS_RUNNINGLOCK_TYPE_SUPPORTED): { + return IsRunningLockTypeSupportedStub(data); + } case static_cast(IPowerMgr::RUNNINGLOCK_LOCK): { return LockStub(data); } @@ -91,6 +103,32 @@ int PowerMgrStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessagePar return ERR_OK; } +int32_t PowerMgrStub::CreateRunningLockStub(MessageParcel& data) +{ + sptr token = data.ReadRemoteObject(); + RETURN_IF_WITH_RET((token == nullptr), E_READ_PARCEL_ERROR); + std::unique_ptr runningLockInfo(data.ReadParcelable()); + RETURN_IF_WITH_RET((runningLockInfo == nullptr), E_READ_PARCEL_ERROR); + CreateRunningLock(token, *runningLockInfo); + return ERR_OK; +} + +int32_t PowerMgrStub::ReleaseRunningLockStub(MessageParcel& data) +{ + sptr token = data.ReadRemoteObject(); + RETURN_IF_WITH_RET((token == nullptr), E_READ_PARCEL_ERROR); + ReleaseRunningLock(token); + return ERR_OK; +} + +int32_t PowerMgrStub::IsRunningLockTypeSupportedStub(MessageParcel& data) +{ + uint32_t type = 0; + READ_PARCEL_WITH_RET(data, Uint32, type, E_READ_PARCEL_ERROR); + IsRunningLockTypeSupported(type); + return ERR_OK; +} + int32_t PowerMgrStub::LockStub(MessageParcel& data) { sptr token = data.ReadRemoteObject(); @@ -212,6 +250,16 @@ int32_t PowerMgrStub::ForceSuspendDeviceStub(MessageParcel& data, MessageParcel& return ERR_OK; } +int32_t PowerMgrStub::GetStateStub(MessageParcel& reply) +{ + PowerState ret = GetState(); + if (!reply.WriteUint32(static_cast(ret))) { + POWER_HILOGE(MODULE_SERVICE, "PowerMgrStub:: GetStateStub Writeback Fail!"); + return E_WRITE_PARCEL_ERROR; + } + return ERR_OK; +} + int32_t PowerMgrStub::IsScreeOnStub(MessageParcel& reply) { bool ret = false; -- Gitee From 623c3fa76a0ee9a5a6e74b47eec4cadef19251ee Mon Sep 17 00:00:00 2001 From: Du Jiang Date: Tue, 20 Jul 2021 13:58:00 +0800 Subject: [PATCH 05/11] Fix dead lock in running lock RunningLock client can be used by multiple caller, then the call will be added in request list of proxy. It's not good to set mutex in client side. So delete all mutex in RunningLock client. In PowerStateMachine, delete mutex which don't refer to list. Add mutex when refer to callback list. From Service side, only lock mutex when operate lock list. Also Fix static check in this patch. Change-Id: I5778baee5e44643ada2defdb3efde516138839af --- frameworks/include/power_manager_napi.h | 3 - frameworks/include/power_napi_base.h | 3 - frameworks/include/running_lock_napi.h | 3 +- frameworks/napi/power_manager_napi.cpp | 71 +++++++------- frameworks/napi/power_napi_base.cpp | 10 +- frameworks/napi/running_lock_napi.cpp | 51 +++++----- frameworks/native/running_lock.cpp | 7 -- .../native/include/power_state_machine_info.h | 1 - services/native/include/power_state_machine.h | 1 + services/native/include/running_lock_mgr.h | 1 + .../actions/default/device_state_action.cpp | 4 +- services/native/src/power_state_machine.cpp | 92 ++++++++++--------- services/native/src/powerms_event_handler.cpp | 4 +- services/native/src/running_lock_mgr.cpp | 25 +++-- 14 files changed, 144 insertions(+), 132 deletions(-) diff --git a/frameworks/include/power_manager_napi.h b/frameworks/include/power_manager_napi.h index 3409e7b4..83c0246b 100644 --- a/frameworks/include/power_manager_napi.h +++ b/frameworks/include/power_manager_napi.h @@ -23,7 +23,6 @@ namespace OHOS { namespace PowerMgr { - class ShutdownContext : public PowerNapiContext { public: using PowerNapiContext::PowerNapiContext; @@ -32,7 +31,6 @@ protected: virtual void Init(napi_value* args, uint32_t argc) override; }; - class PowerManagerNapi { public: static napi_value Init(napi_env env, napi_value exports); @@ -57,7 +55,6 @@ private: static napi_ref powerStateConstructor_; static napi_ref powerModeConstructor_; }; - } // namespace PowerMgr } // namespace OHOS diff --git a/frameworks/include/power_napi_base.h b/frameworks/include/power_napi_base.h index 9cba8a2d..cb41e1c5 100644 --- a/frameworks/include/power_napi_base.h +++ b/frameworks/include/power_napi_base.h @@ -22,7 +22,6 @@ namespace OHOS { namespace PowerMgr { - enum AsyncStatus { PENDING, RESOLVED, @@ -30,7 +29,6 @@ enum AsyncStatus { }; class PowerNapiContext { - using FreeFunc = std::function; using ExecuteFunc = std::function; @@ -62,7 +60,6 @@ protected: FreeFunc freeFunc_; AsyncStatus status_; }; - } // namespace PowerMgr } // namespace OHOS diff --git a/frameworks/include/running_lock_napi.h b/frameworks/include/running_lock_napi.h index cb560bf8..5e4aac15 100644 --- a/frameworks/include/running_lock_napi.h +++ b/frameworks/include/running_lock_napi.h @@ -48,8 +48,7 @@ private: static napi_ref runningLockConstructor_; }; - } // namespace PowerMgr } // namespace OHOS -#endif //POWERMGR_RUNNING_LOCK_NAPI_H +#endif // POWERMGR_RUNNING_LOCK_NAPI_H diff --git a/frameworks/napi/power_manager_napi.cpp b/frameworks/napi/power_manager_napi.cpp index 9e357926..00654cab 100644 --- a/frameworks/napi/power_manager_napi.cpp +++ b/frameworks/napi/power_manager_napi.cpp @@ -13,18 +13,23 @@ * limitations under the License. */ +#include "power_manager_napi.h" + #include #include #include #include #include "power_common.h" -#include "power_manager_napi.h" #include "running_lock_napi.h" using namespace OHOS::PowerMgr; -#define REASON_STRING_MAX (128) -#define LOCK_NAME_STRING_MAX (128) +static const uint8_t ARG_0 = 0; +static const uint8_t ARG_1 = 1; +static const uint8_t ARG_2 = 2; +static const uint8_t ARG_3 = 3; +static const uint8_t REASON_STRING_MAX = 128; +static const uint8_t LOCK_NAME_STRING_MAX = 128; napi_ref PowerManagerNapi::runningLockTypeConstructor_ = nullptr; napi_ref PowerManagerNapi::powerStateConstructor_ = nullptr; @@ -37,7 +42,7 @@ void ShutdownContext::Init(napi_value* args, uint32_t argc) } size_t out; char reason[REASON_STRING_MAX]; - napi_get_value_string_latin1(env_, args[0], reason, REASON_STRING_MAX, &out); + napi_get_value_string_latin1(env_, args[ARG_0], reason, REASON_STRING_MAX, &out); reason_.copy(reason, strlen(reason), 0); } @@ -65,22 +70,22 @@ napi_value PowerManagerNapi::Init(napi_env env, napi_value exports) napi_value PowerManagerNapi::IsRunningLockTypeSupported(napi_env env, napi_callback_info info) { POWER_HILOGD(MODULE_JS_NAPI, "enter"); - size_t argc = 2; - napi_value args[2] = { 0 }; + size_t argc = ARG_2; + napi_value args[ARG_2] = { 0 }; napi_value jsthis; void *data = nullptr; uint32_t result; napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - NAPI_ASSERT(env, (status == napi_ok) && (argc >= 1), "Not enough parameters"); + NAPI_ASSERT(env, (status == napi_ok) && (argc >= ARG_2 - 1), "Not enough parameters"); napi_valuetype type; - NAPI_CALL(env, napi_typeof(env, args[0], &type)); + NAPI_CALL(env, napi_typeof(env, args[ARG_0], &type)); NAPI_ASSERT(env, type == napi_number, "Wrong type of 1st parameter. number expected."); - napi_get_value_uint32(env, args[0], &result); + napi_get_value_uint32(env, args[ARG_0], &result); - PowerNapiContext* context = new PowerNapiContext(env, args, argc, 1, 1); + PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_2 - 1, ARG_1); napi_value promise = context->GetPromise(); context->StartAsyncWork("Power::IsRunningLockTypeSupported", @@ -99,8 +104,8 @@ napi_value PowerManagerNapi::IsRunningLockTypeSupported(napi_env env, napi_callb napi_value PowerManagerNapi::CreateRunningLock(napi_env env, napi_callback_info info) { POWER_HILOGD(MODULE_JS_NAPI, "enter"); - size_t argc = 3; - napi_value args[3] = { 0 }; + size_t argc = ARG_3; + napi_value args[ARG_3] = { 0 }; napi_value jsthis; void *data = nullptr; @@ -108,20 +113,20 @@ napi_value PowerManagerNapi::CreateRunningLock(napi_env env, napi_callback_info NAPI_ASSERT(env, (status == napi_ok) && (argc >= 2), "Not enough parameters"); napi_valuetype type; - NAPI_CALL(env, napi_typeof(env, args[0], &type)); + NAPI_CALL(env, napi_typeof(env, args[ARG_0], &type)); NAPI_ASSERT(env, type == napi_string, "Wrong type of 1st parameter. string expected."); - NAPI_CALL(env, napi_typeof(env, args[1], &type)); + NAPI_CALL(env, napi_typeof(env, args[ARG_1], &type)); NAPI_ASSERT(env, type == napi_number, "Wrong type of 2st parameter. number expected."); char name[LOCK_NAME_STRING_MAX]; size_t size; - napi_get_value_string_latin1(env, args[0], name, LOCK_NAME_STRING_MAX, &size); + napi_get_value_string_latin1(env, args[ARG_0], name, LOCK_NAME_STRING_MAX, &size); uint32_t lockType; napi_get_value_uint32(env, args[1], &lockType); NAPI_ASSERT(env, lockType < static_cast(RunningLockType::RUNNINGLOCK_BUTT), "RunningLock Type is not supported"); - PowerNapiContext* context = new PowerNapiContext(env, args, argc, 2, 1); + PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_3 - 1, ARG_1); napi_value promise = context->GetPromise(); context->StartAsyncWork("Power::CreateRunningLock", @@ -138,19 +143,19 @@ napi_value PowerManagerNapi::CreateRunningLock(napi_env env, napi_callback_info napi_value PowerManagerNapi::ShutdownDevice(napi_env env, napi_callback_info info) { POWER_HILOGD(MODULE_JS_NAPI, "enter"); - uint32_t argc = 2; - napi_value args[2] = { 0 }; + uint32_t argc = ARG_2; + napi_value args[ARG_2] = { 0 }; napi_value jsthis; void *data = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - NAPI_ASSERT(env, (status == napi_ok) && (argc >= 1), "Not enough parameters"); + NAPI_ASSERT(env, (status == napi_ok) && (argc >= ARG_1), "Not enough parameters"); napi_valuetype type; - NAPI_CALL(env, napi_typeof(env, args[0], &type)); + NAPI_CALL(env, napi_typeof(env, args[ARG_0], &type)); NAPI_ASSERT(env, type == napi_string, "Wrong argument type. string expected."); - ShutdownContext* context = new ShutdownContext(env, args, argc, 1, 0); + ShutdownContext* context = new ShutdownContext(env, args, argc, ARG_2 - 1, ARG_0); napi_value promise = context->GetPromise(); context->StartAsyncWork("Power::ShutdownDevice", @@ -168,8 +173,8 @@ napi_value PowerManagerNapi::ShutdownDevice(napi_env env, napi_callback_info inf napi_value PowerManagerNapi::RebootDevice(napi_env env, napi_callback_info info) { POWER_HILOGD(MODULE_JS_NAPI, "enter"); - uint32_t argc = 2; - napi_value args[2] = { 0 }; + uint32_t argc = ARG_2; + napi_value args[ARG_2] = { 0 }; napi_value jsthis; void *data = nullptr; @@ -180,7 +185,7 @@ napi_value PowerManagerNapi::RebootDevice(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_typeof(env, args[0], &type)); NAPI_ASSERT(env, type == napi_string, "Wrong argument type. string expected."); - ShutdownContext* context = new ShutdownContext(env, args, argc, 1, 0); + ShutdownContext* context = new ShutdownContext(env, args, argc, ARG_2 - 1, ARG_0); napi_value promise = context->GetPromise(); context->StartAsyncWork("Power::RebootDevice", @@ -198,15 +203,15 @@ napi_value PowerManagerNapi::RebootDevice(napi_env env, napi_callback_info info) napi_value PowerManagerNapi::IsScreenOn(napi_env env, napi_callback_info info) { POWER_HILOGD(MODULE_JS_NAPI, "enter"); - size_t argc = 1; - napi_value args[1] = { 0 }; + size_t argc = ARG_1; + napi_value args[ARG_1] = { 0 }; napi_value jsthis; void *data = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); NAPI_ASSERT(env, (status == napi_ok) && (argc >= 0), "Bad parameters"); - PowerNapiContext* context = new PowerNapiContext(env, args, argc, 0, 1); + PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_1 - 1, ARG_1); napi_value promise = context->GetPromise(); context->StartAsyncWork("Power::IsScreenOn", @@ -225,15 +230,15 @@ napi_value PowerManagerNapi::IsScreenOn(napi_env env, napi_callback_info info) napi_value PowerManagerNapi::GetState(napi_env env, napi_callback_info info) { POWER_HILOGD(MODULE_JS_NAPI, "enter"); - size_t argc = 1; - napi_value args[1] = { 0 }; + size_t argc = ARG_1; + napi_value args[ARG_1] = { 0 }; napi_value jsthis; void *data = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); NAPI_ASSERT(env, (status == napi_ok) && (argc >= 0), "Bad parameters"); - PowerNapiContext* context = new PowerNapiContext(env, args, argc, 0, 1); + PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_1 - 1, ARG_1); napi_value promise = context->GetPromise(); context->StartAsyncWork("Power::GetState", @@ -252,15 +257,15 @@ napi_value PowerManagerNapi::GetState(napi_env env, napi_callback_info info) napi_value PowerManagerNapi::GetMode(napi_env env, napi_callback_info info) { POWER_HILOGD(MODULE_JS_NAPI, "enter"); - size_t argc = 1; - napi_value args[1] = { 0 }; + size_t argc = ARG_1; + napi_value args[ARG_1] = { 0 }; napi_value jsthis; void *data = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); NAPI_ASSERT(env, (status == napi_ok) && (argc >= 0), "Bad parameters"); - PowerNapiContext* context = new PowerNapiContext(env, args, argc, 0, 1); + PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_1 - 1, ARG_1); napi_value promise = context->GetPromise(); context->StartAsyncWork("Power::GetState", diff --git a/frameworks/napi/power_napi_base.cpp b/frameworks/napi/power_napi_base.cpp index 26ec2a21..a7f3089d 100644 --- a/frameworks/napi/power_napi_base.cpp +++ b/frameworks/napi/power_napi_base.cpp @@ -13,13 +13,14 @@ * limitations under the License. */ -#include "power_common.h" #include "power_napi_base.h" +#include "power_common.h" + using namespace OHOS::PowerMgr; PowerNapiContext::PowerNapiContext(napi_env env, napi_value* args, uint32_t argc, - int32_t callbackArg, uint32_t cbParamCount, napi_value object) + int32_t callbackArg, uint32_t cbParamCount, napi_value object) : env_(env), cbParamCount_(cbParamCount), object_(object), deferred_(nullptr), callbackRef_(nullptr), asyncWork_(nullptr), status_(AsyncStatus::PENDING) { @@ -36,6 +37,9 @@ PowerNapiContext::PowerNapiContext(napi_env env, napi_value* args, uint32_t argc } else { napi_get_undefined(env, &promise_); } + if (object_ == nullptr) { + napi_get_global(env, &object_); + } napi_get_undefined(env_, &outValue_); Init(args, argc); } @@ -109,7 +113,7 @@ void PowerNapiContext::CompleteAsyncWork(napi_env env, napi_status status, void } napi_delete_async_work(env, context->asyncWork_); context->asyncWork_ = nullptr; - if ( context->freeFunc_) { + if (context->freeFunc_) { context->freeFunc_(context); } } diff --git a/frameworks/napi/running_lock_napi.cpp b/frameworks/napi/running_lock_napi.cpp index 86b69390..510ca647 100644 --- a/frameworks/napi/running_lock_napi.cpp +++ b/frameworks/napi/running_lock_napi.cpp @@ -13,16 +13,21 @@ * limitations under the License. */ +#include "running_lock_napi.h" + #include #include #include #include "power_common.h" -#include "running_lock_napi.h" using namespace OHOS::PowerMgr; -#define LOCK_NAME_STRING_MAX (128) +static const uint8_t ARG_0 = 0; +static const uint8_t ARG_1 = 1; +static const uint8_t ARG_2 = 2; +static const uint8_t ARG_3 = 3; +static const uint8_t LOCK_NAME_STRING_MAX = 128; napi_ref RunningLockNapi::runningLockConstructor_ = nullptr; @@ -48,13 +53,13 @@ bool RunningLockNapi::CreateRunningLock(napi_env env, napi_callback_info info, n POWER_HILOGD(MODULE_JS_NAPI, "enter"); napi_value constructor; - size_t argc = 2; - napi_value args[2] = { 0 }; + size_t argc = ARG_2; + napi_value args[ARG_2] = { 0 }; napi_value jsthis = nullptr; void *data = nullptr; napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - if (argc < 2) { + if (argc < ARG_2) { return false; } @@ -66,11 +71,11 @@ bool RunningLockNapi::CreateRunningLock(napi_env env, napi_callback_info info, n char name[LOCK_NAME_STRING_MAX]; size_t out; - napi_get_value_string_latin1(env, args[0], name, sizeof(LOCK_NAME_STRING_MAX), &out); + napi_get_value_string_latin1(env, args[ARG_0], name, sizeof(LOCK_NAME_STRING_MAX), &out); std::string nameStr = name; uint32_t type; - napi_get_value_uint32(env, args[1], &type); + napi_get_value_uint32(env, args[ARG_1], &type); std::shared_ptr lock = PowerMgrClient::GetInstance() .CreateRunningLock(nameStr, static_cast(type), false); @@ -91,8 +96,8 @@ bool RunningLockNapi::CreateRunningLock(napi_env env, napi_callback_info info, n napi_value RunningLockNapi::Lock(napi_env env, napi_callback_info info) { - size_t argc = 2; - napi_value args[2] = { 0 }; + size_t argc = ARG_2; + napi_value args[ARG_2] = { 0 }; napi_value jsthis; void *data = nullptr; uint32_t timeout = 0; @@ -105,26 +110,26 @@ napi_value RunningLockNapi::Lock(napi_env env, napi_callback_info info) bool success = GetNativeLock(env, jsthis, &wrapper); NAPI_ASSERT(env, success == true, "This object is not created by PowerManager"); - if (argc >= 1) { + if (argc >= ARG_1) { napi_valuetype type; NAPI_CALL(env, napi_typeof(env, args[0], &type)); if (type == napi_number) { napi_get_value_uint32(env, args[0], &timeout); - context = new PowerNapiContext(env, args, argc, 1, 0); + context = new PowerNapiContext(env, args, argc, ARG_2 - 1, ARG_0, jsthis); } else if (type == napi_function) { - context = new PowerNapiContext(env, args, argc, 0, 0); + context = new PowerNapiContext(env, args, argc, ARG_1 - 1, ARG_0, jsthis); } else { - context = new PowerNapiContext(env, args, argc, -1, 0); + context = new PowerNapiContext(env, args, argc, -1, ARG_0, jsthis); } } else { - context = new PowerNapiContext(env, args, argc, -1, 0); + context = new PowerNapiContext(env, args, argc, -1, ARG_0, jsthis); } napi_value promise = context->GetPromise(); context->StartAsyncWork("RunningLock::Lock", [wrapper, timeout] { ErrCode ret = wrapper->lock_ptr->Lock(timeout); - return ret == ERR_OK? true: false; + return ret == ERR_OK ? true : false; }, [](PowerNapiContext* object) { delete object; } ); @@ -134,8 +139,8 @@ napi_value RunningLockNapi::Lock(napi_env env, napi_callback_info info) napi_value RunningLockNapi::IsUsed(napi_env env, napi_callback_info info) { - size_t argc = 1; - napi_value args[1] = { 0 }; + size_t argc = ARG_1; + napi_value args[ARG_1] = { 0 }; napi_value jsthis; void *data = nullptr; @@ -146,7 +151,7 @@ napi_value RunningLockNapi::IsUsed(napi_env env, napi_callback_info info) bool success = GetNativeLock(env, jsthis, &wrapper); NAPI_ASSERT(env, success == true, "This object is not created by PowerManager"); - PowerNapiContext* context = new PowerNapiContext(env, args, argc, 0, 0); + PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_0, ARG_0, jsthis); napi_value promise = context->GetPromise(); context->StartAsyncWork("RunningLock::IsUsed", @@ -163,8 +168,8 @@ napi_value RunningLockNapi::IsUsed(napi_env env, napi_callback_info info) napi_value RunningLockNapi::Unlock(napi_env env, napi_callback_info info) { - size_t argc = 1; - napi_value args[1] = { 0 }; + size_t argc = ARG_1; + napi_value args[ARG_1] = { 0 }; napi_value jsthis; void *data = nullptr; @@ -175,13 +180,13 @@ napi_value RunningLockNapi::Unlock(napi_env env, napi_callback_info info) bool success = GetNativeLock(env, jsthis, &wrapper); NAPI_ASSERT(env, success == true, "This object is not created by PowerManager"); - PowerNapiContext* context = new PowerNapiContext(env, args, argc, 0, 0); + PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_0, ARG_0, jsthis); napi_value promise = context->GetPromise(); context->StartAsyncWork("RunningLock::Unlock", [wrapper] { ErrCode ret = wrapper->lock_ptr->UnLock(); - return ret == ERR_OK? true: false; + return ret == ERR_OK ? true : false; }, [](PowerNapiContext* object) { delete object; } ); @@ -198,7 +203,7 @@ void RunningLockNapi::RemoveRunningLock(napi_env env, void* finalize_data, void* napi_value RunningLockNapi::ConstructRunningLockObject(napi_env env, napi_callback_info info) { size_t argc = 0; - napi_value args[3] = { 0 }; + napi_value args[ARG_3] = { 0 }; napi_value jsthis = nullptr; void *data = nullptr; diff --git a/frameworks/native/running_lock.cpp b/frameworks/native/running_lock.cpp index 7328e654..5c20a1d3 100644 --- a/frameworks/native/running_lock.cpp +++ b/frameworks/native/running_lock.cpp @@ -38,7 +38,6 @@ RunningLock::~RunningLock() bool RunningLock::Init() { - lock_guard lock(mutex_); token_ = new (std::nothrow)RunningLockTokenStub(); if (token_ == nullptr) { POWER_HILOGE(MODULE_INNERKIT, "RunningLock::%{public}s :creating RunningLockTokenStub error.", __func__); @@ -50,7 +49,6 @@ bool RunningLock::Init() ErrCode RunningLock::Lock(uint32_t timeOutMs) { - lock_guard lock(mutex_); POWER_HILOGI(MODULE_INNERKIT, "RunningLock::%{public}s :timeOutMs = %u.", __func__, timeOutMs); sptr proxy = proxy_.promote(); @@ -66,7 +64,6 @@ ErrCode RunningLock::Lock(uint32_t timeOutMs) ErrCode RunningLock::UnLock() { - lock_guard lock(mutex_); POWER_HILOGI(MODULE_INNERKIT, "RunningLock::%{public}s.", __func__); if (!CheckUsedNoLock()) { return ERR_OK; @@ -96,14 +93,12 @@ bool RunningLock::CheckUsedNoLock() bool RunningLock::IsUsed() { - lock_guard lock(mutex_); POWER_HILOGI(MODULE_INNERKIT, "RunningLock::%{public}s.", __func__); return CheckUsedNoLock(); } ErrCode RunningLock::SetWorkTriggerList(const WorkTriggerList& workTriggerList) { - lock_guard lock(mutex_); auto& list = runningLockInfo_.workTriggerlist; list.clear(); for (auto& w : workTriggerList) { @@ -133,7 +128,6 @@ const WorkTriggerList& RunningLock::GetWorkTriggerList() const void RunningLock::Create() { - lock_guard lock(mutex_); POWER_HILOGI(MODULE_INNERKIT, "RunningLock::%{public}s", __func__); sptr proxy = proxy_.promote(); @@ -147,7 +141,6 @@ void RunningLock::Create() void RunningLock::Release() { - lock_guard lock(mutex_); POWER_HILOGI(MODULE_INNERKIT, "RunningLock::%{public}s ", __func__); sptr proxy = proxy_.promote(); diff --git a/interfaces/innerkits/native/include/power_state_machine_info.h b/interfaces/innerkits/native/include/power_state_machine_info.h index 235711e2..1f7d23f3 100644 --- a/interfaces/innerkits/native/include/power_state_machine_info.h +++ b/interfaces/innerkits/native/include/power_state_machine_info.h @@ -138,7 +138,6 @@ enum class StateChangeReason : uint32_t { STATE_CHANGE_REASON_REMOTE = 100, STATE_CHANGE_REASON_UNKNOWN = 1000, }; - } // namespace PowerMgr } // namespace OHOS #endif // POWERMGR_POWER_STATE_MACHINE_INFO_H diff --git a/services/native/include/power_state_machine.h b/services/native/include/power_state_machine.h index 0df7c39a..4764d7d0 100644 --- a/services/native/include/power_state_machine.h +++ b/services/native/include/power_state_machine.h @@ -127,6 +127,7 @@ private: return l->AsObject() < r->AsObject(); } }; + void InitStateMap(); void NotifyPowerStateChanged(PowerState state); void SendEventToPowerMgrNotify(PowerState state, int64_t callTime); bool CheckRunningLock(PowerState state); diff --git a/services/native/include/running_lock_mgr.h b/services/native/include/running_lock_mgr.h index 65d05890..08d98c48 100644 --- a/services/native/include/running_lock_mgr.h +++ b/services/native/include/running_lock_mgr.h @@ -128,6 +128,7 @@ private: virtual void OnRemoteDied(const wptr& remote); virtual ~RunningLockDeathRecipient() = default; }; + bool InitLocks(); bool MatchProxyMap(const UserIPCInfo& userIPCinfo); void SetRunningLockDisableFlag(std::shared_ptr& lockInner, bool forceRefresh = false); void LockReally(const sptr& token, std::shared_ptr& lockInner); diff --git a/services/native/src/actions/default/device_state_action.cpp b/services/native/src/actions/default/device_state_action.cpp index 18492ab3..b1ca8c21 100644 --- a/services/native/src/actions/default/device_state_action.cpp +++ b/services/native/src/actions/default/device_state_action.cpp @@ -71,7 +71,7 @@ DisplayState DeviceStateAction::GetDisplayState() uint32_t DeviceStateAction::SetDisplayState(DisplayState state) { DisplayPowerMgr::DisplayState dispState = DisplayPowerMgr::DisplayState::DISPLAY_ON; - switch(state) { + switch (state) { case DisplayState::DISPLAY_ON: dispState = DisplayPowerMgr::DisplayState::DISPLAY_ON; break; @@ -89,7 +89,7 @@ uint32_t DeviceStateAction::SetDisplayState(DisplayState state) } bool ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(dispState); - return ret? ActionResult::SUCCESS: ActionResult::FAILED; + return ret ? ActionResult::SUCCESS : ActionResult::FAILED; } uint32_t DeviceStateAction::GoToSleep() diff --git a/services/native/src/power_state_machine.cpp b/services/native/src/power_state_machine.cpp index 91055adb..052aa674 100644 --- a/services/native/src/power_state_machine.cpp +++ b/services/native/src/power_state_machine.cpp @@ -33,7 +33,7 @@ namespace PowerMgr { PowerStateMachine::PowerStateMachine(const wptr& pms) : pms_(pms), currentState_(PowerState::UNKNOWN) { - POWER_HILOGI(MODULE_SERVICE,"PowerStateMachine_currentState: func is Start."); + POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine_currentState: func is Start."); // NOTICE Need get screen state when device startup, rightnow we set screen is on as default mDeviceState_.screenState.lastUpdateTime = GetTickCount(); mDeviceState_.lastWakeupEventTime = 0; @@ -41,17 +41,16 @@ PowerStateMachine::PowerStateMachine(const wptr& pms) mDeviceState_.lastWakeupDeviceTime = 0; mDeviceState_.lastSuspendDeviceTime = 0; - //init lock map which will block state transit + // init lock map which will block state transit std::vector awakeBlocker {}; - std::vector inactiveBlocker {RunningLockType::RUNNINGLOCK_SCREEN, + std::vector inactiveBlocker {RunningLockType::RUNNINGLOCK_SCREEN, RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL}; std::vector sleepBlocker {RunningLockType::RUNNINGLOCK_BACKGROUND}; lockMap_.emplace(PowerState::AWAKE, std::make_shared>(awakeBlocker)); lockMap_.emplace(PowerState::INACTIVE, std::make_shared>(inactiveBlocker)); lockMap_.emplace(PowerState::SLEEP, std::make_shared>(sleepBlocker)); - - POWER_HILOGI(MODULE_SERVICE,"PowerStateMachine_currentState: func is End."); + POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine_currentState: func is End."); } PowerStateMachine::~PowerStateMachine() {} @@ -60,30 +59,52 @@ bool PowerStateMachine::Init() { POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine:: Init start"); - //init state controller map + InitStateMap(); + stateAction_ = PowerMgrFactory::GetDeviceStateAction(); + if (powerStateCBDeathRecipient_ == nullptr) { + powerStateCBDeathRecipient_ = new PowerStateCallbackDeathRecipient(); + } + + if (!powerMgrMonitor_.Start()) { + POWER_HILOGE(MODULE_SERVICE, "Failed to start monitor"); + return false; + } + + if (IsScreenOn()) { + SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_INIT, true); + } else { + SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_INIT, true); + } + POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine:: Init success!"); + return true; +} + +void PowerStateMachine::InitStateMap() +{ + // init state controller map controllerMap_.emplace(PowerState::AWAKE, std::make_shared(PowerState::AWAKE, shared_from_this(), [this] { - POWER_HILOGI(MODULE_SERVICE,"StateController_AWAKE: func is Start."); + POWER_HILOGI(MODULE_SERVICE, "StateController_AWAKE: func is Start."); uint32_t ret = stateAction_->SetDisplayState(DisplayState::DISPLAY_ON); if (ret != ActionResult::SUCCESS) { POWER_HILOGE(MODULE_SERVICE, "Failed to go to AWAKE, Display Err"); return TransitResult::HDI_ERR; } ResetInactiveTimer(); - POWER_HILOGI(MODULE_SERVICE,"StateController_AWAKE: func is End."); + POWER_HILOGI(MODULE_SERVICE, "StateController_AWAKE: func is End."); return TransitResult::SUCCESS; }) ); controllerMap_.emplace(PowerState::INACTIVE, std::make_shared(PowerState::INACTIVE, shared_from_this(), [this] { - POWER_HILOGI(MODULE_SERVICE,"StateController_INACTIVE: func is Start."); + POWER_HILOGI(MODULE_SERVICE, "StateController_INACTIVE: func is Start."); uint32_t ret = stateAction_->SetDisplayState(DisplayState::DISPLAY_OFF); if (ret != ActionResult::SUCCESS) { POWER_HILOGE(MODULE_SERVICE, "Failed to go to INACTIVE, Display Err"); return TransitResult::HDI_ERR; } ResetSleepTimer(); - POWER_HILOGI(MODULE_SERVICE,"StateController_INACTIVE: func is End."); + POWER_HILOGI(MODULE_SERVICE, "StateController_INACTIVE: func is End."); return TransitResult::SUCCESS; }) ); @@ -104,24 +125,6 @@ bool PowerStateMachine::Init() return TransitResult::SUCCESS; }) ); - - stateAction_ = PowerMgrFactory::GetDeviceStateAction(); - if (powerStateCBDeathRecipient_ == nullptr) { - powerStateCBDeathRecipient_ = new PowerStateCallbackDeathRecipient(); - } - - if (!powerMgrMonitor_.Start()) { - POWER_HILOGE(MODULE_SERVICE, "Failed to start monitor"); - return false; - } - - if (IsScreenOn()) { - SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_INIT, true); - } else { - SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_INIT, true); - } - POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine:: Init success!"); - return true; } void PowerStateMachine::SuspendDeviceInner(pid_t pid, int64_t callTimeMs, SuspendDeviceType type, bool suspendImmed, @@ -206,7 +209,6 @@ bool PowerStateMachine::ForceSuspendDeviceInner(pid_t pid, int64_t callTimeMs) bool PowerStateMachine::IsScreenOn() { POWER_HILOGI(MODULE_SERVICE, "IsScreenOn: fun is Start!"); - std::lock_guard lock(mutex_); DisplayState state = stateAction_->GetDisplayState(); if (state == DisplayState::DISPLAY_ON || state == DisplayState::DISPLAY_DIM) { @@ -268,6 +270,7 @@ void PowerStateMachine::NotifyPowerStateChanged(PowerState state) { POWER_HILOGI(MODULE_SERVICE, "%{public}s state = %u, listeners.size = %d", __func__, static_cast(state), static_cast(powerStateListeners_.size())); + std::lock_guard lock(mutex_); int64_t now = GetTickCount(); // Send Notification event SendEventToPowerMgrNotify(state, now); @@ -293,7 +296,7 @@ void PowerStateMachine::SendEventToPowerMgrNotify(PowerState state, int64_t call } if (state == PowerState::AWAKE) { notify->PublishScreenOnEvents(callTime); - } else if(state == PowerState::INACTIVE) { + } else if (state == PowerState::INACTIVE) { notify->PublishScreenOffEvents(callTime); } else { POWER_HILOGI(MODULE_SERVICE, "No need to publish event, state:%d", state); @@ -354,7 +357,6 @@ void PowerStateMachine::CancelDelayTimer(int32_t event) return; } handler->RemoveEvent(event); - POWER_HILOGI(MODULE_SERVICE, "remove event success"); POWER_HILOGD(MODULE_SERVICE, "CancelDelayTimer: fun is End!"); } @@ -366,7 +368,8 @@ void PowerStateMachine::ResetInactiveTimer() CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG); if (this->CheckRunningLock(PowerState::INACTIVE)) { - this->SetDelayTimer(this->GetDisplayOffTime()/2, PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG); + const uint32_t HALF = 2; + this->SetDelayTimer(this->GetDisplayOffTime() / HALF, PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG); } POWER_HILOGD(MODULE_SERVICE, "ResetInactiveTimer: fun is End!"); } @@ -407,8 +410,9 @@ void PowerStateMachine::HandleActivityTimeout() { POWER_HILOGI(MODULE_SERVICE, "HandleActivityTimeout (%{public}d)", stateAction_->GetDisplayState()); if (stateAction_->GetDisplayState() == DisplayState::DISPLAY_ON) { + const uint32_t HALF = 2; stateAction_->SetDisplayState(DisplayState::DISPLAY_DIM); - SetDelayTimer(GetDisplayOffTime()/2, PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG); + SetDelayTimer(GetDisplayOffTime() / HALF, PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG); } POWER_HILOGI(MODULE_SERVICE, "HandleActivityTimeout: fun is End!"); } @@ -451,9 +455,9 @@ bool PowerStateMachine::CheckRunningLock(PowerState state) } std::shared_ptr> pLock = iterator->second; - for (std::vector::const_iterator iter = pLock->begin();iter != pLock->end(); ++iter) { + for (std::vector::const_iterator iter = pLock->begin(); iter != pLock->end(); ++iter) { uint32_t count = runningLockMgr->GetValidRunningLockNum(*iter); - if(count > 0) { + if (count > 0) { POWER_HILOGE(MODULE_SERVICE, "RunningLock(%d) is locking (%d) for state (%d)",*iter, count, state); return false; } @@ -466,15 +470,17 @@ bool PowerStateMachine::CheckRunningLock(PowerState state) int64_t PowerStateMachine::GetDisplayOffTime() { POWER_HILOGI(MODULE_SERVICE, "GetDisplayOffTime: fun is Start!"); - //temp solution, will get from mode xml - return 5000; + // temp solution, will get from SettingsProvider + const uint32_t time = 5000; + return time; } int64_t PowerStateMachine::GetSleepTime() { POWER_HILOGI(MODULE_SERVICE, "GetSleepTime: fun is Start!"); - //temp solution, will get from mode xml - return 5000; + // temp solution, will get from mode xml + const uint32_t time = 5000; + return time; } bool PowerStateMachine::SetState(PowerState state, StateChangeReason reason, bool force) @@ -492,14 +498,14 @@ bool PowerStateMachine::SetState(PowerState state, StateChangeReason reason, boo } TransitResult ret = pController->TransitTo(reason, true); POWER_HILOGI(MODULE_SERVICE, "SetState: fun is End!"); - return (ret == TransitResult::SUCCESS || ret ==TransitResult::ALREADY_IN_STATE); + return (ret == TransitResult::SUCCESS || ret == TransitResult::ALREADY_IN_STATE); } StateChangeReason PowerStateMachine::GetReasonByUserActivity(UserActivityType type) { POWER_HILOGI(MODULE_SERVICE, "GetReasonByUserActivity Start:%{public}d", type); StateChangeReason ret = StateChangeReason::STATE_CHANGE_REASON_UNKNOWN; - switch(type) { + switch (type) { case UserActivityType::USER_ACTIVITY_TYPE_BUTTON: ret = StateChangeReason::STATE_CHANGE_REASON_HARD_KEY; break; @@ -526,7 +532,7 @@ StateChangeReason PowerStateMachine::GetReasonByWakeType(WakeupDeviceType type) { POWER_HILOGI(MODULE_SERVICE, "GetReasonByWakeType Start:%{public}d", type); StateChangeReason ret = StateChangeReason::STATE_CHANGE_REASON_UNKNOWN; - switch(type) { + switch (type) { case WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON: case WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY: ret = StateChangeReason::STATE_CHANGE_REASON_HARD_KEY; @@ -562,7 +568,7 @@ StateChangeReason PowerStateMachine::GetReasionBySuspendType(SuspendDeviceType t { POWER_HILOGI(MODULE_SERVICE, "GetReasionBySuspendType Start:%{public}d", type); StateChangeReason ret = StateChangeReason::STATE_CHANGE_REASON_UNKNOWN; - switch(type) { + switch (type) { case SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION: ret = StateChangeReason::STATE_CHANGE_REASON_APPLICATION; break; diff --git a/services/native/src/powerms_event_handler.cpp b/services/native/src/powerms_event_handler.cpp index 6a4ef8e5..22fbf3e2 100644 --- a/services/native/src/powerms_event_handler.cpp +++ b/services/native/src/powerms_event_handler.cpp @@ -44,8 +44,8 @@ void PowermsEventHandler::ProcessEvent([[maybe_unused]] const AppExecFwk::InnerE runningLockMgr->CheckOverTime(); break; } - case CHECK_USER_ACTIVITY_TIMEOUT_MSG: //fallthrough - case CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG: //fallthrough + case CHECK_USER_ACTIVITY_TIMEOUT_MSG: // fallthrough + case CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG: // fallthrough case CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG: { auto powerStateMachine = pmsptr->GetPowerStateMachine(); if (powerStateMachine == nullptr) { diff --git a/services/native/src/running_lock_mgr.cpp b/services/native/src/running_lock_mgr.cpp index de8c3218..5278b06a 100644 --- a/services/native/src/running_lock_mgr.cpp +++ b/services/native/src/running_lock_mgr.cpp @@ -38,6 +38,7 @@ RunningLockMgr::~RunningLockMgr() {} bool RunningLockMgr::Init() { POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::Init start"); + std::lock_guard lock(mutex_); if (runningLockDeathRecipient_ == nullptr) { runningLockDeathRecipient_ = new RunningLockDeathRecipient(); } @@ -59,6 +60,14 @@ bool RunningLockMgr::Init() systemLocks_.emplace(SystemLockType::SYSTEM_LOCK_DISPLAY, std::make_shared(runningLockAction_, LOCK_TAG_DISPLAY)); + bool ret = InitLocks(); + + POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::Init success"); + return ret; +} + +bool RunningLockMgr::InitLocks() +{ lockCounters_.emplace(RunningLockType::RUNNINGLOCK_SCREEN, std::make_shared( RunningLockType::RUNNINGLOCK_SCREEN, [this](bool active) { auto pms = DelayedSpSingleton::GetInstance(); @@ -109,12 +118,12 @@ bool RunningLockMgr::Init() }) ); - POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::Init success"); return true; } std::shared_ptr RunningLockMgr::GetRunningLockInner(const sptr& token) { + std::lock_guard lock(mutex_); auto iterator = runningLocks_.find(token); if (iterator != runningLocks_.end()) { POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::%{public}s :find by token.", __func__); @@ -133,14 +142,15 @@ std::shared_ptr RunningLockMgr::CreateRunningLock(const sptrAddDeathRecipient(runningLockDeathRecipient_); return lockInner; } void RunningLockMgr::ReleaseLock(const sptr token) { - std::lock_guard lock(mutex_); POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :token = %p", __func__, token.GetRefPtr()); auto lockInner = GetRunningLockInner(token); if (lockInner == nullptr) { @@ -149,7 +159,9 @@ void RunningLockMgr::ReleaseLock(const sptr token) if (!lockInner->GetDisabled()) { UnLock(token); } + mutex_.lock(); runningLocks_.erase(token); + mutex_.unlock(); token->RemoveDeathRecipient(runningLockDeathRecipient_); } @@ -172,7 +184,6 @@ void RunningLockMgr::RemoveAndPostUnlockTask(const sptr& token, u void RunningLockMgr::Lock(const sptr& token, const RunningLockInfo& runningLockInfo, const UserIPCInfo& userIPCinfo, uint32_t timeOutMS) { - std::lock_guard lock(mutex_); POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :token = %p,name = %s,type = %d", __func__, token.GetRefPtr(), runningLockInfo.name.c_str(), runningLockInfo.type); @@ -204,7 +215,6 @@ void RunningLockMgr::Lock(const sptr& token, const RunningLockInf void RunningLockMgr::UnLock(const sptr token) { - std::lock_guard lock(mutex_); POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :token = %p", __func__, token.GetRefPtr()); auto lockInner = GetRunningLockInner(token); @@ -231,7 +241,6 @@ void RunningLockMgr::UnLock(const sptr token) bool RunningLockMgr::IsUsed(const sptr& token) { - std::lock_guard lock(mutex_); auto lockInner = GetRunningLockInner(token); if (lockInner == nullptr || lockInner->GetDisabled()) { return false; @@ -253,7 +262,6 @@ uint32_t RunningLockMgr::GetRunningLockNum(RunningLockType type) uint32_t RunningLockMgr::GetValidRunningLockNum(RunningLockType type) { - std::lock_guard lock(mutex_); auto iterator = lockCounters_.find(type); if (iterator == lockCounters_.end()) { POWER_HILOGD(MODULE_SERVICE, "GetValidRunningLockNum failed, unsupported type %d", type); @@ -278,7 +286,6 @@ bool RunningLockMgr::ExistValidRunningLock() void RunningLockMgr::SetWorkTriggerList(const sptr& token, const WorkTriggerList& workTriggerList) { - std::lock_guard lock(mutex_); POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :token = %p", __func__, token.GetRefPtr()); auto lockInner = GetRunningLockInner(token); @@ -294,6 +301,7 @@ void RunningLockMgr::SetWorkTriggerList(const sptr& token, const // If disabled, we really unlock here. UnLockReally(token, lockInner); } + void RunningLockMgr::NotifyHiViewRunningLockInfo(const string& tokenStr, const RunningLockInner& lockInner, RunningLockChangedType changeType) const { @@ -319,7 +327,6 @@ void RunningLockMgr::NotifyHiViewRunningLockInfo(const string& tokenStr, const R void RunningLockMgr::CheckOverTime() { - std::lock_guard lock(mutex_); auto handler = handler_.lock(); if (handler == nullptr) { return; @@ -528,7 +535,6 @@ void RunningLockMgr::ProxyRunningLockInner(bool proxyLock) void RunningLockMgr::ProxyRunningLock(bool proxyLock, pid_t uid, pid_t pid) { - std::lock_guard lock(mutex_); POWER_HILOGD(MODULE_SERVICE, "%{public}s :proxyLock = %d, uid = %d, pid = %d", __func__, proxyLock, uid, pid); auto it = proxyMap_.find(uid); @@ -743,6 +749,5 @@ void RunningLockMgr::ProximityController::OnAway() } stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_SENSOR, true); } - } // namespace PowerMgr } // namespace OHOS -- Gitee From 62360c7f8a933d433cf3ac259c845337706c2318 Mon Sep 17 00:00:00 2001 From: Du Jiang Date: Tue, 10 Aug 2021 14:41:02 +0800 Subject: [PATCH 06/11] Add Power mode management and power HDI Power mode management feature is added to support power save mode. Power mode features can be customized via xml file, then do action when power mode changes. Power HDI is added so that power will not write to kernel directly. It's controlled by Micro: POWER_SUSPEND_NO_HDI, which will disable HDI call if the micro is defined. After system suspend, the program is hanging out at the syscall. We add callback to check when the "mem" syscall is complete. Change-Id: Ibc61a8742af3187e7a0828e3ff313873e0140abb --- frameworks/include/power_napi_base.h | 9 +- frameworks/include/running_lock_napi.h | 3 +- frameworks/napi/power_manager_napi.cpp | 27 +- frameworks/napi/power_napi_base.cpp | 46 +-- frameworks/napi/running_lock_napi.cpp | 45 ++- frameworks/native/power_mgr_client.cpp | 79 ++--- hdi/BUILD.gn | 21 ++ hdi/api/include/power_hdf_client.h | 41 +++ hdi/api/include/power_hdf_info.h | 33 ++ hdi/client/BUILD.gn | 47 +++ hdi/client/src/power_hdf_client.cpp | 113 ++++++ hdi/service/BUILD.gn | 55 +++ hdi/service/include/power_hdf_service.h | 55 +++ hdi/service/src/power_hdf_service.cpp | 237 +++++++++++++ interfaces/innerkits/BUILD.gn | 2 + .../innerkits/native/include/ipower_mgr.h | 14 +- .../native/include/ipower_mode_callback.h | 38 ++ .../native/include/ishutdown_callback.h | 9 +- .../native/include/power_mgr_client.h | 32 +- interfaces/kits/js/@ohos.power.d.ts | 25 +- interfaces/kits/js/BUILD.gn | 6 +- ohos.build | 6 +- powermgr.gni | 2 + services/BUILD.gn | 12 + .../include/actions/idevice_state_action.h | 2 +- services/native/include/power_mgr_service.h | 9 + services/native/include/power_mode_module.h | 81 +++++ services/native/include/power_mode_policy.h | 66 ++++ services/native/include/power_save_model.h | 60 ++++ services/native/include/power_state_machine.h | 3 + .../native/include/powerms_event_handler.h | 1 + services/native/profile/BUILD.gn | 22 ++ services/native/profile/power_mode_config.xml | 21 ++ services/native/src/actions/default/BUILD.gn | 8 +- .../actions/default/device_power_action.cpp | 12 +- .../src/actions/default/device_power_action.h | 2 + .../actions/default/device_state_action.cpp | 15 +- .../src/actions/default/device_state_action.h | 2 +- .../default/suspend/isuspend_controller.h | 4 +- .../default/suspend/suspend_controller.cpp | 56 ++- .../default/suspend/suspend_controller.h | 18 +- .../default/system_suspend_controller.cpp | 30 +- .../default/system_suspend_controller.h | 8 +- services/native/src/power_mgr_service.cpp | 43 ++- services/native/src/power_mode_module.cpp | 330 ++++++++++++++++++ services/native/src/power_mode_policy.cpp | 119 +++++++ services/native/src/power_save_model.cpp | 114 ++++++ services/native/src/power_state_machine.cpp | 44 ++- services/native/src/powerms_event_handler.cpp | 3 +- .../unittest/src/power_state_machine_test.cpp | 6 +- .../test/unittest/src/running_lock_test.cpp | 39 --- services/zidl/include/power_mgr_proxy.h | 4 + services/zidl/include/power_mgr_stub.h | 4 + .../zidl/include/power_mode_callback_proxy.h | 38 ++ .../zidl/include/power_mode_callback_stub.h | 39 +++ .../include/power_shutdown_callback_proxy.h | 38 ++ .../include/power_shutdown_callback_stub.h | 39 +++ services/zidl/src/power_mgr_proxy.cpp | 99 +++++- services/zidl/src/power_mgr_stub.cpp | 54 ++- .../zidl/src/power_mode_callback_proxy.cpp | 47 +++ .../zidl/src/power_mode_callback_stub.cpp | 51 +++ .../src/power_shutdown_callback_proxy.cpp | 47 +++ .../zidl/src/power_shutdown_callback_stub.cpp | 51 +++ 63 files changed, 2339 insertions(+), 247 deletions(-) create mode 100644 hdi/BUILD.gn create mode 100644 hdi/api/include/power_hdf_client.h create mode 100644 hdi/api/include/power_hdf_info.h create mode 100644 hdi/client/BUILD.gn create mode 100644 hdi/client/src/power_hdf_client.cpp create mode 100644 hdi/service/BUILD.gn create mode 100644 hdi/service/include/power_hdf_service.h create mode 100644 hdi/service/src/power_hdf_service.cpp create mode 100644 interfaces/innerkits/native/include/ipower_mode_callback.h create mode 100644 services/native/include/power_mode_module.h create mode 100644 services/native/include/power_mode_policy.h create mode 100644 services/native/include/power_save_model.h create mode 100644 services/native/profile/BUILD.gn create mode 100644 services/native/profile/power_mode_config.xml create mode 100644 services/native/src/power_mode_module.cpp create mode 100644 services/native/src/power_mode_policy.cpp create mode 100644 services/native/src/power_save_model.cpp create mode 100644 services/zidl/include/power_mode_callback_proxy.h create mode 100644 services/zidl/include/power_mode_callback_stub.h create mode 100644 services/zidl/include/power_shutdown_callback_proxy.h create mode 100644 services/zidl/include/power_shutdown_callback_stub.h create mode 100644 services/zidl/src/power_mode_callback_proxy.cpp create mode 100644 services/zidl/src/power_mode_callback_stub.cpp create mode 100644 services/zidl/src/power_shutdown_callback_proxy.cpp create mode 100644 services/zidl/src/power_shutdown_callback_stub.cpp diff --git a/frameworks/include/power_napi_base.h b/frameworks/include/power_napi_base.h index cb41e1c5..71e872b6 100644 --- a/frameworks/include/power_napi_base.h +++ b/frameworks/include/power_napi_base.h @@ -34,21 +34,20 @@ using ExecuteFunc = std::function; public: PowerNapiContext(napi_env env, napi_value* args, uint32_t argc, - int32_t callbackArg, uint32_t cbParamCount, napi_value object = nullptr); + int32_t callbackArg, napi_value object = nullptr); virtual ~PowerNapiContext(); bool StartAsyncWork(const char* workName, ExecuteFunc exeFunc, FreeFunc freeFunc); napi_value GetPromise() { return promise_; } napi_env env_; napi_value outValue_; + napi_value outError_; protected: static void ExecuteAsyncWork(napi_env env, void *data); static void CompleteAsyncWork(napi_env env, napi_status status, void *data); virtual void Init(napi_value* args, uint32_t argc); - virtual napi_value GetPromiseValue(); //default function is for Promise - virtual napi_value GetError(); //default function is always return undefined - //default function is for AsyncCallback - virtual void GetCallbackValues(napi_value* values, uint32_t size); + virtual napi_value GetValue(); // default function is for Promise + virtual napi_value GetError(); // default function is always return undefined uint32_t cbParamCount_; napi_value object_; diff --git a/frameworks/include/running_lock_napi.h b/frameworks/include/running_lock_napi.h index 5e4aac15..7630e8cd 100644 --- a/frameworks/include/running_lock_napi.h +++ b/frameworks/include/running_lock_napi.h @@ -34,7 +34,8 @@ public: class RunningLockNapi { public: static napi_value InitRunningLockClass(napi_env env, napi_value exports); - static bool CreateRunningLock(napi_env env, napi_callback_info info, napi_value* result); + static bool CreateRunningLock(napi_env env, napi_callback_info info, + napi_value* result, napi_value* error); private: RunningLockNapi() = default; ~RunningLockNapi() = default; diff --git a/frameworks/napi/power_manager_napi.cpp b/frameworks/napi/power_manager_napi.cpp index 00654cab..16476f82 100644 --- a/frameworks/napi/power_manager_napi.cpp +++ b/frameworks/napi/power_manager_napi.cpp @@ -85,7 +85,7 @@ napi_value PowerManagerNapi::IsRunningLockTypeSupported(napi_env env, napi_callb napi_get_value_uint32(env, args[ARG_0], &result); - PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_2 - 1, ARG_1); + PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_2 - 1); napi_value promise = context->GetPromise(); context->StartAsyncWork("Power::IsRunningLockTypeSupported", @@ -126,12 +126,13 @@ napi_value PowerManagerNapi::CreateRunningLock(napi_env env, napi_callback_info NAPI_ASSERT(env, lockType < static_cast(RunningLockType::RUNNINGLOCK_BUTT), "RunningLock Type is not supported"); - PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_3 - 1, ARG_1); + PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_3 - 1); napi_value promise = context->GetPromise(); context->StartAsyncWork("Power::CreateRunningLock", [env, info, context] { - return RunningLockNapi::CreateRunningLock(env, info, &context->outValue_); + return RunningLockNapi::CreateRunningLock(env, info, + &context->outValue_, &context->outError_); }, [](PowerNapiContext* object) { delete object; } ); @@ -155,7 +156,7 @@ napi_value PowerManagerNapi::ShutdownDevice(napi_env env, napi_callback_info inf NAPI_CALL(env, napi_typeof(env, args[ARG_0], &type)); NAPI_ASSERT(env, type == napi_string, "Wrong argument type. string expected."); - ShutdownContext* context = new ShutdownContext(env, args, argc, ARG_2 - 1, ARG_0); + ShutdownContext* context = new ShutdownContext(env, args, argc, ARG_2 - 1); napi_value promise = context->GetPromise(); context->StartAsyncWork("Power::ShutdownDevice", @@ -185,7 +186,7 @@ napi_value PowerManagerNapi::RebootDevice(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_typeof(env, args[0], &type)); NAPI_ASSERT(env, type == napi_string, "Wrong argument type. string expected."); - ShutdownContext* context = new ShutdownContext(env, args, argc, ARG_2 - 1, ARG_0); + ShutdownContext* context = new ShutdownContext(env, args, argc, ARG_2 - 1); napi_value promise = context->GetPromise(); context->StartAsyncWork("Power::RebootDevice", @@ -211,7 +212,7 @@ napi_value PowerManagerNapi::IsScreenOn(napi_env env, napi_callback_info info) napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); NAPI_ASSERT(env, (status == napi_ok) && (argc >= 0), "Bad parameters"); - PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_1 - 1, ARG_1); + PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_1 - 1); napi_value promise = context->GetPromise(); context->StartAsyncWork("Power::IsScreenOn", @@ -238,7 +239,7 @@ napi_value PowerManagerNapi::GetState(napi_env env, napi_callback_info info) napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); NAPI_ASSERT(env, (status == napi_ok) && (argc >= 0), "Bad parameters"); - PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_1 - 1, ARG_1); + PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_1 - 1); napi_value promise = context->GetPromise(); context->StartAsyncWork("Power::GetState", @@ -261,22 +262,18 @@ napi_value PowerManagerNapi::GetMode(napi_env env, napi_callback_info info) napi_value args[ARG_1] = { 0 }; napi_value jsthis; void *data = nullptr; - napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); NAPI_ASSERT(env, (status == napi_ok) && (argc >= 0), "Bad parameters"); - - PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_1 - 1, ARG_1); - + PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_1 - 1); napi_value promise = context->GetPromise(); context->StartAsyncWork("Power::GetState", [context] { - const char* error = "GetMode is unsupported"; - napi_create_string_utf8(context->env_, error, strlen(error), &context->outValue_); - return false; + uint32_t mode = PowerMgrClient::GetInstance().GetDeviceMode(); + napi_create_uint32(context->env_, mode, &context->outValue_); + return true; }, [context](PowerNapiContext* object) { delete context; } ); - POWER_HILOGD(MODULE_JS_NAPI, "return"); return promise; } diff --git a/frameworks/napi/power_napi_base.cpp b/frameworks/napi/power_napi_base.cpp index a7f3089d..eeb5f7ef 100644 --- a/frameworks/napi/power_napi_base.cpp +++ b/frameworks/napi/power_napi_base.cpp @@ -19,9 +19,13 @@ using namespace OHOS::PowerMgr; +#define CALLBACK_ARG_0 (0) +#define CALLBACK_ARG_1 (1) +#define CALLBACK_ARGS_COUNT (2) + PowerNapiContext::PowerNapiContext(napi_env env, napi_value* args, uint32_t argc, - int32_t callbackArg, uint32_t cbParamCount, napi_value object) - : env_(env), cbParamCount_(cbParamCount), object_(object), + int32_t callbackArg, napi_value object) + : env_(env), object_(object), deferred_(nullptr), callbackRef_(nullptr), asyncWork_(nullptr), status_(AsyncStatus::PENDING) { POWER_HILOGE(MODULE_INNERKIT, "%{public}s called.", __func__); @@ -41,13 +45,14 @@ PowerNapiContext::PowerNapiContext(napi_env env, napi_value* args, uint32_t argc napi_get_global(env, &object_); } napi_get_undefined(env_, &outValue_); + napi_get_undefined(env_, &outError_); Init(args, argc); } PowerNapiContext::~PowerNapiContext() { if (deferred_) { - napi_reject_deferred(env_, deferred_, GetError()); + deferred_ = NULL; } if (callbackRef_) { napi_delete_reference(env_, callbackRef_); @@ -77,10 +82,11 @@ void PowerNapiContext::ExecuteAsyncWork(napi_env env, void *data) void PowerNapiContext::CompleteAsyncWork(napi_env env, napi_status status, void *data) { PowerNapiContext* context = (PowerNapiContext*)data; + if (context->deferred_) { if (context->status_ == AsyncStatus::RESOLVED) { POWER_HILOGI(MODULE_JS_NAPI, "work complete: resolved"); - napi_resolve_deferred(env, context->deferred_, context->GetPromiseValue()); + napi_resolve_deferred(env, context->deferred_, context->GetValue()); } else { POWER_HILOGI(MODULE_JS_NAPI, "work complete: rejected"); napi_reject_deferred(env, context->deferred_, context->GetError()); @@ -91,22 +97,13 @@ void PowerNapiContext::CompleteAsyncWork(napi_env env, napi_status status, void napi_value result = 0; napi_value callback = nullptr; napi_get_reference_value(env, context->callbackRef_, &callback); - napi_value* values = nullptr; - uint32_t count = context->cbParamCount_; - if (count > 0) { - values = new napi_value[context->cbParamCount_]; - context->GetCallbackValues(values, count); - } else { - count = 1; - values = new napi_value[1]; - napi_get_undefined(env, &values[0]); - } + napi_value values[CALLBACK_ARGS_COUNT]; + + values[CALLBACK_ARG_0] = context->GetError(); + values[CALLBACK_ARG_1] = context->GetValue(); napi_call_function(env, context->object_, callback, context->cbParamCount_, values, &result); napi_delete_reference(env, context->callbackRef_); - if (values != nullptr) { - delete values; - } context->callbackRef_ = nullptr; } else { POWER_HILOGE(MODULE_JS_NAPI, "work complete: nothing"); @@ -151,21 +148,12 @@ void PowerNapiContext::Init(napi_value* args, uint32_t argc) // do nothing in base class } -napi_value PowerNapiContext::GetPromiseValue() +napi_value PowerNapiContext::GetValue() { return outValue_; } napi_value PowerNapiContext::GetError() { - return outValue_; -} - -void PowerNapiContext::GetCallbackValues(napi_value* values, uint32_t size) -{ - if (size == 0) { - return; - } - values[0] = GetPromiseValue(); - return; -} + return outError_; +} \ No newline at end of file diff --git a/frameworks/napi/running_lock_napi.cpp b/frameworks/napi/running_lock_napi.cpp index 510ca647..a90f1186 100644 --- a/frameworks/napi/running_lock_napi.cpp +++ b/frameworks/napi/running_lock_napi.cpp @@ -20,7 +20,6 @@ #include #include "power_common.h" - using namespace OHOS::PowerMgr; static const uint8_t ARG_0 = 0; @@ -48,7 +47,8 @@ napi_value RunningLockNapi::InitRunningLockClass(napi_env env, napi_value export return exports; } -bool RunningLockNapi::CreateRunningLock(napi_env env, napi_callback_info info, napi_value* result) +bool RunningLockNapi::CreateRunningLock(napi_env env, napi_callback_info info, + napi_value* result, napi_value* error) { POWER_HILOGD(MODULE_JS_NAPI, "enter"); @@ -66,6 +66,8 @@ bool RunningLockNapi::CreateRunningLock(napi_env env, napi_callback_info info, n napi_get_reference_value(env, runningLockConstructor_, &constructor); status = napi_new_instance(env, constructor, argc, args, result); if (status != napi_ok) { + const char* errMsg = "Can't create JS instance"; + napi_create_string_utf8(env, errMsg, strlen(errMsg), error); return false; } @@ -78,8 +80,10 @@ bool RunningLockNapi::CreateRunningLock(napi_env env, napi_callback_info info, n napi_get_value_uint32(env, args[ARG_1], &type); std::shared_ptr lock = PowerMgrClient::GetInstance() - .CreateRunningLock(nameStr, static_cast(type), false); + .CreateRunningLock(nameStr, static_cast(type)); if (lock == nullptr) { + const char* errMsg = "Can't create running lock from service"; + napi_create_string_utf8(env, errMsg, strlen(errMsg), error); return false; } @@ -87,6 +91,8 @@ bool RunningLockNapi::CreateRunningLock(napi_env env, napi_callback_info info, n status = napi_wrap(env, *result, reinterpret_cast(wrapper), RemoveRunningLock, nullptr, nullptr); if (status != napi_ok) { + const char* errMsg = "Can't wrap native lock"; + napi_create_string_utf8(env, errMsg, strlen(errMsg), error); delete wrapper; return false; } @@ -115,21 +121,27 @@ napi_value RunningLockNapi::Lock(napi_env env, napi_callback_info info) NAPI_CALL(env, napi_typeof(env, args[0], &type)); if (type == napi_number) { napi_get_value_uint32(env, args[0], &timeout); - context = new PowerNapiContext(env, args, argc, ARG_2 - 1, ARG_0, jsthis); + context = new PowerNapiContext(env, args, argc, ARG_2 - 1, jsthis); } else if (type == napi_function) { - context = new PowerNapiContext(env, args, argc, ARG_1 - 1, ARG_0, jsthis); + context = new PowerNapiContext(env, args, argc, ARG_1 - 1, jsthis); } else { - context = new PowerNapiContext(env, args, argc, -1, ARG_0, jsthis); + context = new PowerNapiContext(env, args, argc, -1, jsthis); } } else { - context = new PowerNapiContext(env, args, argc, -1, ARG_0, jsthis); + context = new PowerNapiContext(env, args, argc, -1, jsthis); } napi_value promise = context->GetPromise(); context->StartAsyncWork("RunningLock::Lock", - [wrapper, timeout] { + [context, env, wrapper, timeout] { ErrCode ret = wrapper->lock_ptr->Lock(timeout); - return ret == ERR_OK ? true : false; + if (ret != ERR_OK) { + const char* errMsg = "Native lock failed"; + napi_create_string_utf8(env, errMsg, strlen(errMsg), &context->outError_); + return false; + } else { + return true; + } }, [](PowerNapiContext* object) { delete object; } ); @@ -151,7 +163,7 @@ napi_value RunningLockNapi::IsUsed(napi_env env, napi_callback_info info) bool success = GetNativeLock(env, jsthis, &wrapper); NAPI_ASSERT(env, success == true, "This object is not created by PowerManager"); - PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_0, ARG_0, jsthis); + PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_0, jsthis); napi_value promise = context->GetPromise(); context->StartAsyncWork("RunningLock::IsUsed", @@ -180,13 +192,19 @@ napi_value RunningLockNapi::Unlock(napi_env env, napi_callback_info info) bool success = GetNativeLock(env, jsthis, &wrapper); NAPI_ASSERT(env, success == true, "This object is not created by PowerManager"); - PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_0, ARG_0, jsthis); + PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_0, jsthis); napi_value promise = context->GetPromise(); context->StartAsyncWork("RunningLock::Unlock", - [wrapper] { + [context, env, wrapper] { ErrCode ret = wrapper->lock_ptr->UnLock(); - return ret == ERR_OK ? true : false; + if (ret != ERR_OK) { + const char* errMsg = "Native unlock failed"; + napi_create_string_utf8(env, errMsg, strlen(errMsg), &context->outError_); + return false; + } else { + return true; + } }, [](PowerNapiContext* object) { delete object; } ); @@ -239,4 +257,3 @@ bool RunningLockNapi::GetNativeLock(napi_env env, napi_value object, RunningLock *lock = reinterpret_cast(result); return true; } - diff --git a/frameworks/native/power_mgr_client.cpp b/frameworks/native/power_mgr_client.cpp index 758b107a..5103750c 100644 --- a/frameworks/native/power_mgr_client.cpp +++ b/frameworks/native/power_mgr_client.cpp @@ -28,7 +28,7 @@ namespace OHOS { namespace PowerMgr { namespace { -constexpr int APP_FIRST_UID = 10000; +constexpr int APP_FIRST_UID = APP_FIRST_UID_VALUE; } PowerMgrClient::PowerMgrClient() {} @@ -112,40 +112,28 @@ void PowerMgrClient::ShutDownDevice(const std::string& reason) proxy_->ShutDownDevice(reason); } -void PowerMgrClient::SuspendDevice(SuspendDeviceType reason, bool suspendImmed) +void PowerMgrClient::SuspendDevice(SuspendDeviceType reason) { RETURN_IF(Connect() != ERR_OK); - proxy_->SuspendDevice(GetTickCount(), reason, suspendImmed); + proxy_->SuspendDevice(GetTickCount(), reason, false); POWER_HILOGI(MODULE_INNERKIT, " Calling SuspendDevice success."); } -void PowerMgrClient::WakeupDevice(WakeupDeviceType reason, const std::string& details) +void PowerMgrClient::WakeupDevice(WakeupDeviceType reason) { RETURN_IF(Connect() != ERR_OK); - // Param details's length must > 0 - if (details.empty()) { - POWER_HILOGE(MODULE_INNERKIT, "%{public}s : detail length is 0, Wakeup failed!", __func__); - return; - } + std::string detail = "Client"; - std::string subDetails; - if (details.length() > MAX_STRING_LENGTH) { - POWER_HILOGI(MODULE_INNERKIT, "%{public}s : detail = %{public}s, length is larger than %{public}d, \ - do substring!", __func__, details.c_str(), MAX_STRING_LENGTH); - subDetails = details.substr(0, MAX_STRING_LENGTH); - } else { - subDetails = details; - } - proxy_->WakeupDevice(GetTickCount(), reason, subDetails); + proxy_->WakeupDevice(GetTickCount(), reason, detail); POWER_HILOGI(MODULE_INNERKIT, " Calling WakeupDevice success."); } -void PowerMgrClient::RefreshActivity(UserActivityType type, bool needChangeBacklight) +void PowerMgrClient::RefreshActivity(UserActivityType type) { RETURN_IF_WITH_LOG(type == UserActivityType::USER_ACTIVITY_TYPE_ATTENTION, " is not supported!"); RETURN_IF(Connect() != ERR_OK); - proxy_->RefreshActivity(GetTickCount(), type, needChangeBacklight); + proxy_->RefreshActivity(GetTickCount(), type, true); POWER_HILOGI(MODULE_INNERKIT, " Calling RefreshActivity Success!"); } @@ -182,8 +170,7 @@ PowerState PowerMgrClient::GetState() return proxy_->GetState(); } -std::shared_ptr PowerMgrClient::CreateRunningLock(const std::string& name, RunningLockType type, - const int screenOnFlag) +std::shared_ptr PowerMgrClient::CreateRunningLock(const std::string& name, RunningLockType type) { auto uid = IPCSkeleton::GetCallingUid(); if (uid >= APP_FIRST_UID && !Permission::CheckSelfPermission("ohos.permission.RUNNING_LOCK")) { @@ -192,15 +179,6 @@ std::shared_ptr PowerMgrClient::CreateRunningLock(const std::string } RETURN_IF_WITH_RET(Connect() != ERR_OK, nullptr); - if (screenOnFlag == RunningLock::CREATE_WITH_SCREEN_ON) { - if (type != RunningLockType::RUNNINGLOCK_SCREEN) { - POWER_HILOGE(MODULE_INNERKIT, "%{public}s failed to create RunningLock due to screenOnFlag error", - __func__); - return nullptr; - } else { - WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, "RunningLockWakeUpScreen"); - } - } int nameLen = (name.size() > RunningLock::MAX_NAME_LEN) ? RunningLock::MAX_NAME_LEN : name.size(); std::shared_ptr runningLock = std::make_shared(proxy_, name.substr(0, nameLen), type); @@ -216,14 +194,6 @@ std::shared_ptr PowerMgrClient::CreateRunningLock(const std::string return runningLock; } -void PowerMgrClient::ProxyRunningLock(bool proxyLock, pid_t uid, pid_t pid) -{ - RETURN_IF(Connect() != ERR_OK); - POWER_HILOGI(MODULE_INNERKIT, "%{public}s :proxyLock = %d, uid = %d, pid = %d", __func__, - proxyLock, uid, pid); - proxy_->ProxyRunningLock(proxyLock, uid, pid); -} - void PowerMgrClient::RegisterPowerStateCallback(const sptr& callback) { RETURN_IF((callback == nullptr) || (Connect() != ERR_OK)); @@ -241,13 +211,44 @@ void PowerMgrClient::UnRegisterPowerStateCallback(const sptr& callback) { RETURN_IF((callback == nullptr) || (Connect() != ERR_OK)); + POWER_HILOGI(MODULE_INNERKIT, "%{public}s.", __func__); proxy_->RegisterShutdownCallback(callback); } void PowerMgrClient::UnRegisterShutdownCallback(const sptr& callback) { RETURN_IF((callback == nullptr) || (Connect() != ERR_OK)); + POWER_HILOGI(MODULE_INNERKIT, "%{public}s.", __func__); proxy_->UnRegisterShutdownCallback(callback); } + +void PowerMgrClient::RegisterPowerModeCallback(const sptr& callback) +{ + RETURN_IF((callback == nullptr) || (Connect() != ERR_OK)); + POWER_HILOGI(MODULE_INNERKIT, "%{public}s.", __func__); + proxy_->RegisterPowerModeCallback(callback); +} + +void PowerMgrClient::UnRegisterPowerModeCallback(const sptr& callback) +{ + RETURN_IF((callback == nullptr) || (Connect() != ERR_OK)); + POWER_HILOGI(MODULE_INNERKIT, "%{public}s.", __func__); + proxy_->UnRegisterPowerModeCallback(callback); +} + +void PowerMgrClient::SetDeviceMode(const uint32_t mode) +{ + RETURN_IF(Connect() != ERR_OK); + POWER_HILOGE(MODULE_INNERKIT, "%{public}s called.", __func__); + proxy_->SetDeviceMode(mode); +} + +uint32_t PowerMgrClient::GetDeviceMode() +{ + RETURN_IF_WITH_RET(Connect() != ERR_OK, 0); + POWER_HILOGE(MODULE_INNERKIT, "%{public}s called.", __func__); + return proxy_->GetDeviceMode(); +} + } // namespace PowerMgr } // namespace OHOS diff --git a/hdi/BUILD.gn b/hdi/BUILD.gn new file mode 100644 index 00000000..bf24099d --- /dev/null +++ b/hdi/BUILD.gn @@ -0,0 +1,21 @@ +# Copyright (c) 2021 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. + +import("//build/ohos.gni") + +group("hdi_group") { + deps = [ + "client:power_hdf_client", + "service:power_hdf_service", + ] +} \ No newline at end of file diff --git a/hdi/api/include/power_hdf_client.h b/hdi/api/include/power_hdf_client.h new file mode 100644 index 00000000..da2c7e4b --- /dev/null +++ b/hdi/api/include/power_hdf_client.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2021 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 POWER_HDF_CLIENT_H +#define POWER_HDF_CLIENT_H + +#include +#include "ipc_object_proxy.h" +#include "power_hdf_info.h" + +namespace OHOS { +namespace PowerMgr { +class PowerHdfClient { +public: + PowerHdfClient() = default; + ~PowerHdfClient() = default; + ErrCode Suspend(); + ErrCode ReadWakeCount(std::string& count); + ErrCode WriteWakeCount(const std::string& count); + ErrCode WakeLock(const std::string& name); + ErrCode WakeUnlock(const std::string& name); +private: + ErrCode Dispatch(uint32_t cmd, MessageParcel &data, MessageParcel &reply); + sptr GetService(); +}; +} // namespace PowerMgr +} // namespace OHOS + +#endif // POWER_HDF_CLIENT_H \ No newline at end of file diff --git a/hdi/api/include/power_hdf_info.h b/hdi/api/include/power_hdf_info.h new file mode 100644 index 00000000..8499eb26 --- /dev/null +++ b/hdi/api/include/power_hdf_info.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2021 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 POWER_HDF_INFO_H +#define POWER_HDF_INFO_H + +enum PowerHdfCmd { + CMD_SUSPEND = 0, + CMD_READ_WAKE_COUNT, + CMD_WRITE_WAKE_COUNT, + CMD_WAKE_LOCK, + CMD_WAKE_UNLOCK, +}; + +enum PowerHdfState { + AWAKE = 0, + INACTIVE, + SLEEP, +}; + +#endif // POWER_HDF_INFO_H \ No newline at end of file diff --git a/hdi/client/BUILD.gn b/hdi/client/BUILD.gn new file mode 100644 index 00000000..5931bee4 --- /dev/null +++ b/hdi/client/BUILD.gn @@ -0,0 +1,47 @@ +# Copyright (c) 2021 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. + +import("//base/powermgr/power_manager/powermgr.gni") +import("//build/ohos.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +config("power_client_public_config") { + include_dirs = [ + "include", + "${powermgr_root_path}/hdi/api/include", + ] +} + +ohos_shared_library("power_hdf_client") { + sources = [ + "src/power_hdf_client.cpp", + ] + + configs = [ "${powermgr_utils_path}:utils_config" ] + + public_configs = [ ":power_client_public_config" ] + + deps = [ + "${hdf_uhdf_path}/hdi:libhdi", + "${hdf_uhdf_path}/host:libhdf_host", + "${hdf_uhdf_path}/osal:libhdf_utils", + "//utils/native/base:utils", + ] + + external_deps = [ + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] + + part_name = "power_manager_native" +} diff --git a/hdi/client/src/power_hdf_client.cpp b/hdi/client/src/power_hdf_client.cpp new file mode 100644 index 00000000..1d80c0db --- /dev/null +++ b/hdi/client/src/power_hdf_client.cpp @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2021 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 "power_hdf_client.h" + +#include "iservmgr_hdi.h" +#include "power_common.h" + +namespace OHOS { +namespace PowerMgr { + +namespace { +const std::string POWER_HDF_SERVICE = "power_hdf"; +} + +using OHOS::HDI::ServiceManager::V1_0::IServiceManager; + +ErrCode PowerHdfClient::Suspend() +{ + MessageParcel data; + MessageParcel reply; + return Dispatch(CMD_SUSPEND, data, reply); +} + +ErrCode PowerHdfClient::ReadWakeCount(std::string& count) +{ + MessageParcel data; + MessageParcel reply; + ErrCode ret = Dispatch(CMD_READ_WAKE_COUNT, data, reply); + if (ret != ERR_OK) { + return ret; + } + count = reply.ReadString(); + return ERR_OK; +} + +ErrCode PowerHdfClient::WriteWakeCount(const std::string& count) +{ + MessageParcel data; + MessageParcel reply; + data.WriteString(count); + ErrCode ret = Dispatch(CMD_WRITE_WAKE_COUNT, data, reply); + if (ret != ERR_OK) { + return ret; + } + return ERR_OK; +} + +ErrCode PowerHdfClient::WakeLock(const std::string& name) +{ + MessageParcel data; + MessageParcel reply; + data.WriteString(name); + return Dispatch(CMD_WAKE_LOCK, data, reply); +} + +ErrCode PowerHdfClient::WakeUnlock(const std::string& name) +{ + MessageParcel data; + MessageParcel reply; + data.WriteString(name); + return Dispatch(CMD_WAKE_UNLOCK, data, reply); +} + +sptr PowerHdfClient::GetService() +{ + auto serviceManager = IServiceManager::Get(); + if (serviceManager == nullptr) { + POWER_HILOGW(MODULE_SERVICE, "service manager is nullptr"); + return nullptr; + } + auto service = serviceManager->GetService(POWER_HDF_SERVICE.c_str()); + if (service == nullptr) { + POWER_HILOGW(MODULE_SERVICE, "power_hdf service is nullptr"); + return nullptr; + } + return service; +} + +ErrCode PowerHdfClient::Dispatch(uint32_t cmd, MessageParcel &data, MessageParcel &reply) +{ + POWER_HILOGD(MODULE_SERVICE, "Start to dispatch cmd: %{public}d", cmd); + auto service = GetService(); + if (service == nullptr) { + return ERR_NO_INIT; + } + + MessageOption option; + auto ret = service->SendRequest(cmd, data, reply, option); + if (ret != ERR_OK) { + POWER_HILOGE(MODULE_SERVICE, "failed to send request, cmd: %{public}d, ret: %{public}d", cmd, ret); + return ret; + } else { + ret = reply.ReadInt32(); + } + + return ret; +} + +} // namespace PowerMgr +} // namespace OHOS \ No newline at end of file diff --git a/hdi/service/BUILD.gn b/hdi/service/BUILD.gn new file mode 100644 index 00000000..2921adc3 --- /dev/null +++ b/hdi/service/BUILD.gn @@ -0,0 +1,55 @@ +# Copyright (c) 2021 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. + +import("//base/powermgr/power_manager/powermgr.gni") +import("//build/ohos.gni") +import("//drivers/adapter/uhdf2/uhdf.gni") + +config("power_hdf_private_config") { + include_dirs = [ + "//drivers/ability/sbuf/include", + "//drivers/framework/include", + "//drivers/framework/include/core", + ] +} + +config("power_hdf_public_config") { + include_dirs = [ + "include", + "${powermgr_root_path}/hdi/api/include", + ] +} + +ohos_shared_library("power_hdf_service") { + sources = [ + "src/power_hdf_service.cpp", + ] + + configs = [ + "${powermgr_utils_path}:utils_config", + ":power_hdf_private_config", + ] + + public_configs = [ ":power_hdf_public_config" ] + + deps = [ + "${hdf_uhdf_path}/host:libhdf_host", + "${hdf_uhdf_path}/ipc:libhdf_ipc_adapter", + "${hdf_uhdf_path}/osal:libhdf_utils", + "//utils/native/base:utils", + ] + + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + + part_name = "power_manager_native" +} \ No newline at end of file diff --git a/hdi/service/include/power_hdf_service.h b/hdi/service/include/power_hdf_service.h new file mode 100644 index 00000000..1e3d83de --- /dev/null +++ b/hdi/service/include/power_hdf_service.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2021 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 POWER_HDF_SERVICE_H +#define POWER_HDF_SERVICE_H + +#include +#include +#include "errors.h" +#include "hdf_device_desc.h" + +namespace OHOS { +namespace PowerMgr { +class PowerHdfService { +public: + PowerHdfService() = default; + ~PowerHdfService() = default; + static int32_t Bind(struct HdfDeviceObject *device); + static int32_t Init(struct HdfDeviceObject *device); + static void Release(struct HdfDeviceObject *device); + + static int32_t Dispatch(struct HdfDeviceIoClient *client, + int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply); + static int32_t Suspend(); + static int32_t ReadWakeCount(struct HdfSBuf *reply); + static int32_t WriteWakeCount(struct HdfSBuf *data); + static int32_t WakeLock(struct HdfSBuf *data); + static int32_t WakeUnlock(struct HdfSBuf *data); + + struct IDeviceIoService ioService; + struct HdfDeviceObject *device; +private: + static constexpr const char * const SUSPEND_STATE = "mem"; + static constexpr const char * const SUSPEND_STATE_PATH = "/sys/power/state"; + static constexpr const char * const LOCK_PATH = "/sys/power/wake_lock"; + static constexpr const char * const UNLOCK_PATH = "/sys/power/wake_unlock"; + static constexpr const char * const WAKEUP_COUNT_PATH = "/sys/power/wakeup_count"; + static std::mutex mutex_; +}; +} // namespace PowerMgr +} // namespace OHOS + +#endif // POWER_HDF_SERVICE_H \ No newline at end of file diff --git a/hdi/service/src/power_hdf_service.cpp b/hdi/service/src/power_hdf_service.cpp new file mode 100644 index 00000000..e20db284 --- /dev/null +++ b/hdi/service/src/power_hdf_service.cpp @@ -0,0 +1,237 @@ +/* + * Copyright (c) 2021 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 "power_hdf_service.h" + +#include +#include +#include "errors.h" +#include "hdf_sbuf.h" +#include "power_hdf_info.h" +#include "pubdef.h" +#include "unique_fd.h" +#include "utils/hdf_log.h" + +namespace OHOS { +namespace PowerMgr { + +std::mutex PowerHdfService::mutex_; + +int32_t PowerHdfService::Bind(struct HdfDeviceObject *device) +{ + HDF_LOGD("%{public}s enter", __func__); + if (device == NULL) { + HDF_LOGE("%{public}s device is NULL", __func__); + return HDF_ERR_INVALID_OBJECT; + } + PowerHdfService* service = new PowerHdfService(); + service->device = device; + service->ioService.Open = nullptr; + service->ioService.Dispatch = PowerHdfService::Dispatch; + service->ioService.Release = nullptr; + + device->service = &(service->ioService); + device->priv = reinterpret_cast(service); + + return HDF_SUCCESS; +} + +int32_t PowerHdfService::Init(struct HdfDeviceObject *device) +{ + HDF_LOGD("%{public}s enter", __func__); + if (device == NULL) { + HDF_LOGE("%{public}s device is NULL", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + PowerHdfService* service = reinterpret_cast(device->priv); + if (service == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + return HDF_SUCCESS; +} + +void PowerHdfService::Release(struct HdfDeviceObject *device) +{ + HDF_LOGD("%{public}s enter", __func__); + if (device == NULL) { + return; + } + PowerHdfService* service = reinterpret_cast(device->priv); + if (service == NULL) { + return; + } + delete service; +} + +int32_t PowerHdfService::Dispatch(struct HdfDeviceIoClient *client, + int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGD("%{public}s enter", __func__); + if (client == NULL || client->device == NULL) { + HDF_LOGE("%{public}s: client or client->device is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + int ret = HDF_ERR_NOT_SUPPORT; + switch (cmdId) { + case CMD_SUSPEND: { + ret = PowerHdfService::Suspend(); + break; + } + case CMD_READ_WAKE_COUNT: { + ret = PowerHdfService::ReadWakeCount(reply); + break; + } + case CMD_WRITE_WAKE_COUNT: { + ret = PowerHdfService::WriteWakeCount(data); + break; + } + case CMD_WAKE_LOCK: { + ret = PowerHdfService::WakeLock(data); + break; + } + case CMD_WAKE_UNLOCK: { + ret = PowerHdfService::WakeUnlock(data); + break; + } + default: + break; + } + if (ret == HDF_SUCCESS) { + HdfSbufWriteInt32(reply, ERR_OK); + } else if (ret == HDF_FAILURE) { + HdfSbufWriteInt32(reply, ERR_INVALID_OPERATION); + } + return ret; +} + +int32_t PowerHdfService::Suspend() +{ + HDF_LOGD("%{public}s enter", __func__); + std::lock_guard lock(mutex_); + UniqueFd suspendStateFd(TEMP_FAILURE_RETRY(open(SUSPEND_STATE_PATH, O_RDWR | O_CLOEXEC))); + if (suspendStateFd < 0) { + HDF_LOGD("Failed to open the suspending state fd!"); + return HDF_FAILURE; + } + bool ret = SaveStringToFd(suspendStateFd, SUSPEND_STATE); + if (!ret) { + HDF_LOGE("Failed to write the suspend state!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t PowerHdfService::ReadWakeCount(struct HdfSBuf *reply) +{ + HDF_LOGD("%{public}s enter", __func__); + std::lock_guard lock(mutex_); + UniqueFd fd(TEMP_FAILURE_RETRY(open(WAKEUP_COUNT_PATH, O_RDWR | O_CLOEXEC))); + if (fd < 0) { + HDF_LOGD("Failed to open the suspending state fd!"); + return HDF_FAILURE; + } + std::string count; + bool ret = LoadStringFromFd(fd, count); + if (!ret) { + HDF_LOGE("Failed to read wake count from kernel!"); + return HDF_FAILURE; + } + HdfSbufWriteString(reply, count.c_str()); + return HDF_SUCCESS; +} + +int32_t PowerHdfService::WriteWakeCount(struct HdfSBuf *data) +{ + HDF_LOGD("%{public}s enter", __func__); + std::lock_guard lock(mutex_); + if (data == nullptr) { + return HDF_ERR_INVALID_PARAM; + } + const char* count = HdfSbufReadString(data); + if (count == nullptr) { + return HDF_ERR_INVALID_PARAM; + } + UniqueFd fd(TEMP_FAILURE_RETRY(open(WAKEUP_COUNT_PATH, O_RDWR | O_CLOEXEC))); + bool ret = SaveStringToFd(fd, count); + if (!ret) { + HDF_LOGE("Failed to write the lock to kernel!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t PowerHdfService::WakeLock(struct HdfSBuf *data) +{ + HDF_LOGD("%{public}s enter", __func__); + std::lock_guard lock(mutex_); + if (data == nullptr) { + return HDF_ERR_INVALID_PARAM; + } + const char* name = HdfSbufReadString(data); + if (name == nullptr) { + return HDF_ERR_INVALID_PARAM; + } + UniqueFd fd(TEMP_FAILURE_RETRY(open(LOCK_PATH, O_RDWR | O_CLOEXEC))); + bool ret = SaveStringToFd(fd, name); + if (!ret) { + HDF_LOGE("Failed to write the lock to kernel!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t PowerHdfService::WakeUnlock(struct HdfSBuf *data) +{ + HDF_LOGD("%{public}s enter", __func__); + std::lock_guard lock(mutex_); + if (data == nullptr) { + return HDF_ERR_INVALID_PARAM; + } + const char* name = HdfSbufReadString(data); + if (name == nullptr) { + return HDF_ERR_INVALID_PARAM; + } + UniqueFd fd(TEMP_FAILURE_RETRY(open(UNLOCK_PATH, O_RDWR | O_CLOEXEC))); + bool ret = SaveStringToFd(fd, name); + if (!ret) { + HDF_LOGE("Failed to write the lock to kernel!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +struct HdfDriverEntry g_powerHdfEntry = { + .moduleVersion = 1, + .moduleName = "power_hdf", + .Bind = PowerHdfService::Bind, + .Init = PowerHdfService::Init, + .Release = PowerHdfService::Release, +}; + +} // namespace PowerMgr +} // namespace OHOS + +#ifndef __cplusplus +extern "C" { +#endif + +HDF_INIT(OHOS::PowerMgr::g_powerHdfEntry); + +#ifndef __cplusplus +} +#endif + diff --git a/interfaces/innerkits/BUILD.gn b/interfaces/innerkits/BUILD.gn index b9ff6f65..101687c1 100644 --- a/interfaces/innerkits/BUILD.gn +++ b/interfaces/innerkits/BUILD.gn @@ -28,6 +28,8 @@ ohos_shared_library("powermgr_client") { sources = [ "${powermgr_service_path}/zidl/src/power_mgr_proxy.cpp", "${powermgr_service_path}/zidl/src/power_state_callback_proxy.cpp", + "${powermgr_service_path}/zidl/src/power_shutdown_callback_proxy.cpp", + "${powermgr_service_path}/zidl/src/power_mode_callback_proxy.cpp", "${powermgr_framework_path}/native/power_mgr_client.cpp", "${powermgr_framework_path}/native/running_lock.cpp", "${powermgr_framework_path}/native/running_lock_info.cpp", diff --git a/interfaces/innerkits/native/include/ipower_mgr.h b/interfaces/innerkits/native/include/ipower_mgr.h index b4ebed61..698b54aa 100644 --- a/interfaces/innerkits/native/include/ipower_mgr.h +++ b/interfaces/innerkits/native/include/ipower_mgr.h @@ -23,6 +23,7 @@ #include "ipower_state_callback.h" #include "ishutdown_callback.h" +#include "ipower_mode_callback.h" #include "power_state_machine_info.h" #include "running_lock_info.h" @@ -50,7 +51,11 @@ public: REG_POWER_STATE_CALLBACK, UNREG_POWER_STATE_CALLBACK, REG_SHUTDOWN_CALLBACK, - UNREG_SHUTDOWN_CALLBACK + UNREG_SHUTDOWN_CALLBACK, + REG_POWER_MODE_CALLBACK, + UNREG_POWER_MODE_CALLBACK, + SETMODE_DEVICE, + GETMODE_DEVICE }; virtual void CreateRunningLock(const sptr& token, const RunningLockInfo& runningLockInfo) = 0; @@ -79,6 +84,13 @@ public: virtual void RegisterShutdownCallback(const sptr& callback) = 0; virtual void UnRegisterShutdownCallback(const sptr& callback) = 0; + // Used for callback registration upon power mode. + virtual void RegisterPowerModeCallback(const sptr& callback) = 0; + virtual void UnRegisterPowerModeCallback(const sptr& callback) = 0; + + virtual void SetDeviceMode(const uint32_t& mode) = 0; + virtual uint32_t GetDeviceMode() = 0; + DECLARE_INTERFACE_DESCRIPTOR(u"ohos.powermgr.IPowerMgr"); }; } // namespace PowerMgr diff --git a/interfaces/innerkits/native/include/ipower_mode_callback.h b/interfaces/innerkits/native/include/ipower_mode_callback.h new file mode 100644 index 00000000..ba987e79 --- /dev/null +++ b/interfaces/innerkits/native/include/ipower_mode_callback.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2021 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 IPOWER_MGR_CHANGE_MODE_CALLBACK_H +#define IPOWER_MGR_CHANGE_MODE_CALLBACK_H + +#include +#include +#include +#include + +namespace OHOS { +namespace PowerMgr { +class IPowerModeCallback : public IRemoteBroker { +public: + enum { + POWER_MODE_CHANGED = 0, + }; + + virtual void PowerModeCallback() = 0; + + DECLARE_INTERFACE_DESCRIPTOR(u"ohos.powermgr.IPowerModeCallback"); +}; +} // namespace PowerMgr +} // namespace OHOS +#endif // IPOWER_MGR_CHANGE_MODE_CALLBACK_H diff --git a/interfaces/innerkits/native/include/ishutdown_callback.h b/interfaces/innerkits/native/include/ishutdown_callback.h index 25922383..e4765c2c 100644 --- a/interfaces/innerkits/native/include/ishutdown_callback.h +++ b/interfaces/innerkits/native/include/ishutdown_callback.h @@ -18,15 +18,22 @@ #include #include +#include +#include namespace OHOS { namespace PowerMgr { class IShutdownCallback : public IRemoteBroker { public: + enum { + POWER_SHUTDOWN_CHANGED = 0, + }; + virtual void ShutdownCallback() = 0; DECLARE_INTERFACE_DESCRIPTOR(u"ohos.powermgr.IShutdownCallback"); }; + } // namespace PowerMgr } // namespace OHOS -#endif // IPOWER_MGR_SHUTDOWN_CALLBACK_H \ No newline at end of file +#endif // IPOWER_MGR_SHUTDOWN_CALLBACK_H diff --git a/interfaces/innerkits/native/include/power_mgr_client.h b/interfaces/innerkits/native/include/power_mgr_client.h index e920c69e..64803388 100644 --- a/interfaces/innerkits/native/include/power_mgr_client.h +++ b/interfaces/innerkits/native/include/power_mgr_client.h @@ -23,6 +23,8 @@ #include "power_state_machine_info.h" #include "running_lock.h" +#define APP_FIRST_UID_VALUE 10000 + namespace OHOS { namespace PowerMgr { class PowerMgrClient final : public DelayedRefSingleton { @@ -49,19 +51,15 @@ public: * Suspend device and set screen off. * * @param reason The reason why will you suspend the device, such as timeout/powerkey/forcesuspend and so on. - * @param suspendImmed The flag indicating whether the system will go to sleep immediately. */ - void SuspendDevice(SuspendDeviceType reason = SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, - bool suspendImmed = true); + void SuspendDevice(SuspendDeviceType reason = SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION); /** * Wake up the device and set the screen on. * * @param reason The reason for waking up the device, such as powerkey/plugin/application. - * @param details Details of the wakeup reason. */ - void WakeupDevice(WakeupDeviceType reason = WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, - const std::string& details = "SoftWare Wakeup"); + void WakeupDevice(WakeupDeviceType reason = WakeupDeviceType::WAKEUP_DEVICE_APPLICATION); /** * Refresh the screentimeout time, and keep the screen on. RefreshActivity works only when the screen is on. @@ -70,8 +68,8 @@ public: * @param needChangeBacklight Whether to change the backlight state, for example, from DIM to BRIGHT. * Set it to false if you don't want to change the backlight state. */ - void RefreshActivity(UserActivityType type = UserActivityType::USER_ACTIVITY_TYPE_OTHER, - bool needChangeBacklight = true); + void RefreshActivity(UserActivityType type = UserActivityType::USER_ACTIVITY_TYPE_OTHER); + /** * Check whether the device screen is on. The result may be true or false, depending on the system state. */ @@ -92,16 +90,26 @@ public: */ bool IsRunningLockTypeSupported(uint32_t type); + /* Set the device mode. + * + * @param set The mode the device. + */ + void SetDeviceMode(const uint32_t mode); + /** - * Create a running lock + * Get the device mode. + * + * @param Get The mode the device. */ - std::shared_ptr CreateRunningLock(const std::string& name, RunningLockType type, - const int screenOnFlag = 0); - void ProxyRunningLock(bool proxyLock, pid_t uid, pid_t pid = INVALID_PID); + uint32_t GetDeviceMode(); + + std::shared_ptr CreateRunningLock(const std::string& name, RunningLockType type); void RegisterPowerStateCallback(const sptr& callback); void UnRegisterPowerStateCallback(const sptr& callback); void RegisterShutdownCallback(const sptr& callback); void UnRegisterShutdownCallback(const sptr& callback); + void RegisterPowerModeCallback(const sptr& callback); + void UnRegisterPowerModeCallback(const sptr& callback); private: class PowerMgrDeathRecipient : public IRemoteObject::DeathRecipient { diff --git a/interfaces/kits/js/@ohos.power.d.ts b/interfaces/kits/js/@ohos.power.d.ts index a2204f2e..68aa0f2d 100644 --- a/interfaces/kits/js/@ohos.power.d.ts +++ b/interfaces/kits/js/@ohos.power.d.ts @@ -72,16 +72,24 @@ declare namespace power { export enum PowerMode { /** - * Normal power mode + * Indicates extream power save mode */ - NORMAL = 0, + EXTREAM_MODE = 601, /** - * Power save mode + * Indicates normal mode */ - POWER_SAVE, + NORMAL_MODE, + /** + * Indicates sleep mode + */ + SAVE_MODE, + /** + * Indicates low power mode + */ + LOWPOWER_MODE } - class RunningLock { + export class RunningLock { /** * Prevents the system from hibernating and sets the lock duration. * @@ -145,7 +153,7 @@ declare namespace power { * @param reason Indicates the shutdown reason. * @since 6 */ - function shutownDevice(callback: AsyncCallback): void; + function shutownDevice(reason: string, callback: AsyncCallback): void; function shutownDevice(reason: string): Promise; /** @@ -157,7 +165,7 @@ declare namespace power { * after the restart. If the parameter is not specified, the system enters the normal mode after the restart. * @since 6 */ - function rebootDevice(callback: AsyncCallback): void; + function rebootDevice(reason: string, callback: AsyncCallback): void; function rebootDevice(reason: string): Promise; /** @@ -184,8 +192,7 @@ declare namespace power { * @return Returns current power mode name. * @since 6 */ - function getMode(callback: AsyncCallback): void; + function getMode(callback: AsyncCallback):void function getMode(): Promise; } export default power; - diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn index 6035d19c..89e162ea 100644 --- a/interfaces/kits/js/BUILD.gn +++ b/interfaces/kits/js/BUILD.gn @@ -28,7 +28,7 @@ config("powermgr_public_config") { } js_declaration("power_js") { - part_name = "power_manager" + part_name = "${powermgr_native_part_name}" sources = [ "./@ohos.power.d.ts", ] @@ -69,7 +69,7 @@ ohos_shared_library("power") { "hiviewdfx_hilog_native:libhilog", ] - relative_install_dir = "module/power_manager" - part_name = "power_manager" + relative_install_dir = "module" + part_name = "${powermgr_native_part_name}" subsystem_name = "powermgr" } diff --git a/ohos.build b/ohos.build index 1ca753a1..b8324d4e 100644 --- a/ohos.build +++ b/ohos.build @@ -4,10 +4,12 @@ "power_manager_native": { "module_list": [ "//base/powermgr/power_manager/interfaces/innerkits:powermgr_client", + "//base/powermgr/power_manager/interfaces/kits/js:power", + "//base/powermgr/power_manager/interfaces/kits/js:power_js", "//base/powermgr/power_manager/sa_profile:powermgr_sa_profile", "//base/powermgr/power_manager/services:powermgrservice", - "//base/powermgr/power_manager/interfaces/kits/js:power", - "//base/powermgr/power_manager/interfaces/kits/js:power_js" + "//base/powermgr/power_manager/hdi:hdi_group", + "//base/powermgr/power_manager/services:power_service" ], "inner_kits": [ { diff --git a/powermgr.gni b/powermgr.gni index 5236f4e3..6064d028 100644 --- a/powermgr.gni +++ b/powermgr.gni @@ -21,6 +21,8 @@ powermgr_service_path = "${powermgr_root_path}/services" powermgr_framework_path = "${powermgr_root_path}/frameworks" +powermgr_hdi_path = "${powermgr_root_path}/hdi" + powermgr_interfaces_path = "${powermgr_root_path}/interfaces" powermgr_native_innerkits_path = "${powermgr_interfaces_path}/innerkits" diff --git a/services/BUILD.gn b/services/BUILD.gn index 6d240a24..0992420b 100644 --- a/services/BUILD.gn +++ b/services/BUILD.gn @@ -38,6 +38,11 @@ ohos_shared_library("powermgrservice") { "native/src/shutdown_service.cpp", "zidl/src/power_mgr_stub.cpp", "zidl/src/power_state_callback_stub.cpp", + "zidl/src/power_shutdown_callback_stub.cpp", + "zidl/src/power_mode_callback_stub.cpp", + "native/src/power_mode_policy.cpp", + "native/src/power_mode_module.cpp", + "native/src/power_save_model.cpp", ] configs = [ @@ -52,6 +57,7 @@ ohos_shared_library("powermgrservice") { "${powermgr_utils_path}:powermgr_utils", "native/src/actions:powermgr_actions", "//utils/native/base:utils", + "//drivers/peripheral/display/hal:hdi_display_device", ] external_deps = [ @@ -69,3 +75,9 @@ ohos_shared_library("powermgrservice") { part_name = "${powermgr_native_part_name}" } + +group("power_service") { + deps = [ + "native/profile:power_mode_config" + ] +} diff --git a/services/native/include/actions/idevice_state_action.h b/services/native/include/actions/idevice_state_action.h index ceb437ee..0debe620 100644 --- a/services/native/include/actions/idevice_state_action.h +++ b/services/native/include/actions/idevice_state_action.h @@ -40,7 +40,7 @@ public: virtual void RefreshActivity(int64_t callTimeMs, UserActivityType type, uint32_t flags) = 0; virtual DisplayState GetDisplayState() = 0; virtual uint32_t SetDisplayState(DisplayState state) = 0; - virtual uint32_t GoToSleep() = 0; + virtual uint32_t GoToSleep(std::function onSuspend, std::function onWakeup, bool force) = 0; }; } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/include/power_mgr_service.h b/services/native/include/power_mgr_service.h index c5254a1b..2166b4eb 100644 --- a/services/native/include/power_mgr_service.h +++ b/services/native/include/power_mgr_service.h @@ -28,6 +28,10 @@ #include "running_lock_mgr.h" #include "shutdown_service.h" #include "sp_singleton.h" +#include "power_mode_module.h" +#include "power_save_model.h" + +#define APP_FIRST_UID_VALUE 10000 namespace OHOS { namespace PowerMgr { @@ -61,6 +65,10 @@ public: void UnRegisterPowerStateCallback(const sptr& callback) override; void RegisterShutdownCallback(const sptr& callback) override; void UnRegisterShutdownCallback(const sptr& callback) override; + void RegisterPowerModeCallback(const sptr& callback) override; + void UnRegisterPowerModeCallback(const sptr& callback) override; + virtual void SetDeviceMode(const uint32_t& mode) override; + virtual uint32_t GetDeviceMode() override; std::shared_ptr GetHandler() const { @@ -100,6 +108,7 @@ private: std::shared_ptr powerStateMachine_; std::shared_ptr powerMgrNotify_; ShutdownService shutdownService_; + PowerModeModule powerModeModule_; }; } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/include/power_mode_module.h b/services/native/include/power_mode_module.h new file mode 100644 index 00000000..93eacbb3 --- /dev/null +++ b/services/native/include/power_mode_module.h @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2021 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 "ipower_mode_callback.h" + +#ifndef POWER_MODE_THREAD_H +#define POWER_MODE_THREAD_H + +#define FLAG_FALSE -1 +#define LAST_MODE_FLAG 0 +#define SETTINGS_PRIVIDER_VALUE_LCD_BRIGHTNESS 99 +#define SETTINGS_PRIVIDER_VALUE_VIBRATION 1 +#define SETTINGS_PRIVIDER_VALUE_ROTATION 1 + +namespace OHOS { +namespace PowerMgr { +class PowerModeModule { +public: + enum { + EXTREAM_MODE = 601, + NORMAL_MODE, + SAVE_MODE, + LOWPOWER_MODE + }; + PowerModeModule(); + ~PowerModeModule() = default; + void SetModeItem(uint32_t mode); + uint32_t GetModeItem(); + void EnableMode(uint32_t mode); + void AddPowerModeCallback(const sptr& callback); + void DelPowerModeCallback(const sptr& callback); + +private: + using IntentWant = OHOS::AAFwk::Want; + + class CallbackManager : public IRemoteObject::DeathRecipient { + public: + void OnRemoteDied(const wptr& remote) override; + void AddCallback(const sptr& callback); + void RemoveCallback(const sptr& callback); + void WaitingCallback(); + + private: + std::mutex mutex_; + std::set> callbacks_; + }; + + uint32_t mode_; + uint32_t lastMode_; + + void Prepare(); + void PublishPowerModeEvent(); + + CallbackManager callbackMgr_; + void UpdateModepolicy(); + void RunAction(); + void SetLcdBrightness(); + void SetVibration(); + void OnOffRotation(); + + std::atomic started_; + std::map recoverValue; + std::map::iterator recoverValueiter; + std::mutex mutex_; + +}; +} // namespace PowerMgr +} // namespace OHOS +#endif //POWER_MODE_THREAD_H diff --git a/services/native/include/power_mode_policy.h b/services/native/include/power_mode_policy.h new file mode 100644 index 00000000..d5399893 --- /dev/null +++ b/services/native/include/power_mode_policy.h @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2021 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 POWER_MODE_POLICY_H +#define POWER_MODE_POLICY_H + +#include +#include +#include +#include "power_save_model.h" + +#define INIT_VALUE_FALSE -1 +#define LAST_MODE_FLAG 0 + +namespace OHOS { +namespace PowerMgr { +class PowerModePolicy { +public: + class ServiceType{ + public: + static const uint32_t autoWindownRoration = 107; + static const uint32_t smartBacklight = 115; + static const uint32_t vibratorsState = 120; + }; + + ~PowerModePolicy() = default; + int32_t GetPowerModeValuePolicy(uint32_t type); + int32_t GetPowerModeRecoverPolicy(uint32_t type); + void SetPowerModePolicy(uint32_t mode, uint32_t lastMode); + void ListenSetting(); + +private: + std::list openPolicy; + std::list closePolicy; + std::list recoverPolicy; + + std::map valueModePolicy; + std::map recoverModePolicy; + std::map::iterator valueiter; + std::map::iterator recoveriter; + + std::list::iterator openlit; + std::list::iterator closelit; + std::list::iterator recoverlit; + void ReadOpenPolicy(uint32_t mode); + void ReadRecoverPolicy(uint32_t lastMode); + void CompareModeItem(uint32_t mode, uint32_t lastMode); + int32_t GetPolicyFromMap(uint32_t type); + int32_t GetRecoverPolicyFromMap(uint32_t type); +}; + +} // namespace PowerMgr +} // namespace OHOS +#endif // POWER_MODE_POLICY_H diff --git a/services/native/include/power_save_model.h b/services/native/include/power_save_model.h new file mode 100644 index 00000000..3d0834ac --- /dev/null +++ b/services/native/include/power_save_model.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2021 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 POWERMGR_POWER_MGR_PowerSaveMode_H +#define POWERMGR_POWER_MGR_PowerSaveMode_H + +#include +#include +#include + +#include +#include "sp_singleton.h" +#include "ipc_object_stub.h" + +#define RETURN_FLAG_FALSE -1 +#define SLEEP_FILTER_VALUE 124 + +namespace OHOS { +namespace PowerMgr { + +struct ModePolicy { + int32_t id; + int32_t value; + int32_t recover_flag; +}; +enum ValueProp{ + value, + recover +}; + +class PowerSaveMode :public RefBase{ +public: + PowerSaveMode(); + ~PowerSaveMode()=default; + bool GetValuePolicy(std::list &openPolicy, int32_t mode); + bool GetRecoverPolicy(std::list &recoverPolicy, int32_t mode); + bool GetFilterPolicy(std::list &policy, int32_t mode, int32_t value); + int32_t GetSleepTime(int32_t mode); + std::list GetLastMode(); + std::list SetLastMode(std::list &policy); + +private: + std::map> policyCache_; + bool StartXMlParse(std::string path); +}; +} // namespace PowerMgr +} // namespace OHOS +#endif // POWERMGR_POWER_MGR_PowerSaveMode_H diff --git a/services/native/include/power_state_machine.h b/services/native/include/power_state_machine.h index 4764d7d0..86d3a4c8 100644 --- a/services/native/include/power_state_machine.h +++ b/services/native/include/power_state_machine.h @@ -80,6 +80,8 @@ public: void ResetSleepTimer(); void HandleDelayTimer(int32_t event); bool SetState(PowerState state, StateChangeReason reason, bool force = false); + static void onSuspend(); + static void onWakeup(); // only use for test int64_t GetLastSuspendDeviceTime() const { @@ -136,6 +138,7 @@ private: void HandleActivityTimeout(); void HandleActivityOffTimeout(); void HandleActivitySleepTimeout(); + void HandleSystemWakeup(); StateChangeReason GetReasonByUserActivity(UserActivityType type); StateChangeReason GetReasonByWakeType(WakeupDeviceType type); StateChangeReason GetReasionBySuspendType(SuspendDeviceType type); diff --git a/services/native/include/powerms_event_handler.h b/services/native/include/powerms_event_handler.h index ee8cd3d3..5bad9de9 100644 --- a/services/native/include/powerms_event_handler.h +++ b/services/native/include/powerms_event_handler.h @@ -30,6 +30,7 @@ public: CHECK_USER_ACTIVITY_TIMEOUT_MSG = 2, CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG = 3, CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG = 4, + SYSTEM_WAKE_UP_MSG = 5, }; PowermsEventHandler(const std::shared_ptr& runner, diff --git a/services/native/profile/BUILD.gn b/services/native/profile/BUILD.gn new file mode 100644 index 00000000..10210304 --- /dev/null +++ b/services/native/profile/BUILD.gn @@ -0,0 +1,22 @@ +# Copyright (C) 2021 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. +import("//base/powermgr/power_manager/powermgr.gni") +import("//build/ohos.gni") + +## Install power_mode_config.xml to /system/etc/power_config/power_mode_config.xml +ohos_prebuilt_etc("power_mode_config") { + source = "power_mode_config.xml" + relative_install_dir = "power_config" + part_name = "${powermgr_native_part_name}" + subsystem_name = "powermgr" +} \ No newline at end of file diff --git a/services/native/profile/power_mode_config.xml b/services/native/profile/power_mode_config.xml new file mode 100644 index 00000000..443701f3 --- /dev/null +++ b/services/native/profile/power_mode_config.xml @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/services/native/src/actions/default/BUILD.gn b/services/native/src/actions/default/BUILD.gn index 0ee29eff..9a8cfe25 100644 --- a/services/native/src/actions/default/BUILD.gn +++ b/services/native/src/actions/default/BUILD.gn @@ -15,7 +15,11 @@ import("//base/powermgr/power_manager/powermgr.gni") import("../actions.gni") config("powermgr_actions_impl_public_config") { - include_dirs = [ "." ] + include_dirs = [ + ".", + "${powermgr_hdi_path}/api/include", + "//base/startup/syspara_lite/adapter/native/syspara/include", + ] } ohos_source_set("${powermgr_actions_default_target}") { @@ -33,6 +37,8 @@ ohos_source_set("${powermgr_actions_default_target}") { deps = [ "../:powermgr_actions_common", "//utils/native/base:utils", + "${powermgr_hdi_path}/client:power_hdf_client", + "//base/startup/syspara_lite/interfaces/innerkits/native/syspara:syspara", ] external_deps = [ diff --git a/services/native/src/actions/default/device_power_action.cpp b/services/native/src/actions/default/device_power_action.cpp index 73df9097..3d83e1fa 100644 --- a/services/native/src/actions/default/device_power_action.cpp +++ b/services/native/src/actions/default/device_power_action.cpp @@ -19,6 +19,8 @@ #include #include #include +#include "parameters.h" +#include "securec.h" #include "hilog_wrapper.h" @@ -26,14 +28,20 @@ namespace OHOS { namespace PowerMgr { void DevicePowerAction::Reboot(const std::string& reason) { + int32_t propertyMaxSize = PROPERTY_MAX_SIZE; + char updateCmd[propertyMaxSize]; + void(snprintf_s(updateCmd, propertyMaxSize, propertyMaxSize - 1, "reboot,%s",reason.c_str())); POWER_HILOGI(MODULE_SERVICE, "Reboot executing."); - syscall(__NR_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, reason.c_str()); + OHOS::system::SetParameter("sys.powerctl", updateCmd); } void DevicePowerAction::Shutdown(const std::string& reason) { + int32_t propertyMaxSize = PROPERTY_MAX_SIZE; + char updateCmd[propertyMaxSize]; + void(snprintf_s(updateCmd, propertyMaxSize, propertyMaxSize - 1, "shutdown,%s",reason.c_str())); POWER_HILOGI(MODULE_SERVICE, "Shutdown executing."); - syscall(__NR_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_POWER_OFF, reason.c_str()); + OHOS::system::SetParameter("sys.powerctl", updateCmd); } } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/src/actions/default/device_power_action.h b/services/native/src/actions/default/device_power_action.h index df2808ab..98b87d7b 100644 --- a/services/native/src/actions/default/device_power_action.h +++ b/services/native/src/actions/default/device_power_action.h @@ -20,6 +20,8 @@ #include "actions/idevice_power_action.h" +#define PROPERTY_MAX_SIZE 92 + namespace OHOS { namespace PowerMgr { class DevicePowerAction : public IDevicePowerAction { diff --git a/services/native/src/actions/default/device_state_action.cpp b/services/native/src/actions/default/device_state_action.cpp index b1ca8c21..680c83fa 100644 --- a/services/native/src/actions/default/device_state_action.cpp +++ b/services/native/src/actions/default/device_state_action.cpp @@ -28,21 +28,20 @@ using namespace DisplayPowerMgr; void DeviceStateAction::Suspend(int64_t callTimeMs, SuspendDeviceType type, uint32_t flags) { - DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayPowerMgr::DisplayState::DISPLAY_OFF); - SystemSuspendController::GetInstance().EnableSuspend(); + // Display is controlled by PowerStateMachine + // Don't suspend until GoToSleep is called } void DeviceStateAction::ForceSuspend() { - DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayPowerMgr::DisplayState::DISPLAY_OFF); - SystemSuspendController::GetInstance().ForceSuspend(); + GoToSleep(nullptr, nullptr, true); } void DeviceStateAction::Wakeup(int64_t callTimeMs, WakeupDeviceType type, const string& details, const string& pkgName) { - DisplayPowerMgrClient::GetInstance().SetDisplayState(DisplayPowerMgr::DisplayState::DISPLAY_ON); - SystemSuspendController::GetInstance().DisableSuspend(); + // Display is controlled by PowerStateMachine + // No need to wake up because cpu already awake when it's called } DisplayState DeviceStateAction::GetDisplayState() @@ -92,9 +91,9 @@ uint32_t DeviceStateAction::SetDisplayState(DisplayState state) return ret ? ActionResult::SUCCESS : ActionResult::FAILED; } -uint32_t DeviceStateAction::GoToSleep() +uint32_t DeviceStateAction::GoToSleep(std::function onSuspend, std::function onWakeup, bool force) { - SystemSuspendController::GetInstance().ForceSuspend(); + SystemSuspendController::GetInstance().Suspend(onSuspend, onWakeup, force); return ActionResult::SUCCESS; } diff --git a/services/native/src/actions/default/device_state_action.h b/services/native/src/actions/default/device_state_action.h index 7d5f5f60..6e56a0df 100644 --- a/services/native/src/actions/default/device_state_action.h +++ b/services/native/src/actions/default/device_state_action.h @@ -30,7 +30,7 @@ public: uint32_t flags __unused) override {} DisplayState GetDisplayState() override; uint32_t SetDisplayState(DisplayState state) override; - uint32_t GoToSleep() override; + uint32_t GoToSleep(std::function onSuspend, std::function onWakeup, bool force) override; }; } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/src/actions/default/suspend/isuspend_controller.h b/services/native/src/actions/default/suspend/isuspend_controller.h index 4653e93d..863b51a6 100644 --- a/services/native/src/actions/default/suspend/isuspend_controller.h +++ b/services/native/src/actions/default/suspend/isuspend_controller.h @@ -21,11 +21,11 @@ namespace PowerMgr { namespace Suspend { class ISuspendController { public: + using SuspendCallback = std::function; ISuspendController() = default; virtual ~ISuspendController() = default; - virtual void EnableSuspend() = 0; - virtual void ForceSuspend() = 0; + virtual void Suspend(SuspendCallback onSuspend, SuspendCallback onWakeup, bool force) = 0; virtual void IncSuspendBlockCounter() = 0; virtual void DecSuspendBlockCounter() = 0; }; diff --git a/services/native/src/actions/default/suspend/suspend_controller.cpp b/services/native/src/actions/default/suspend/suspend_controller.cpp index 7aaca14a..0f612387 100644 --- a/services/native/src/actions/default/suspend/suspend_controller.cpp +++ b/services/native/src/actions/default/suspend/suspend_controller.cpp @@ -44,19 +44,29 @@ void SuspendController::AutoSuspend::AutoSuspendLoop() if (!WriteWakeupCount(wakeupCount)) { continue; } + if (onSuspend_ != nullptr) { + onSuspend_(); + } bool success = SuspendEnter(); if (!success) { POWER_HILOGE(MODULE_SERVICE, "Start suspend failed!"); } + if (onWakeup_ != nullptr) { + onWakeup_(); + } + break; } } -void SuspendController::AutoSuspend::Start() +void SuspendController::AutoSuspend::Start(SuspendCallback onSuspend, SuspendCallback onWakeup) { static bool started = false; if (started) { return; } + onSuspend_ = onSuspend; + onWakeup_ = onWakeup; + client_ = std::make_unique(); daemon_ = std::make_unique(&AutoSuspend::AutoSuspendLoop, this); daemon_->detach(); started = true; @@ -64,6 +74,12 @@ void SuspendController::AutoSuspend::Start() bool SuspendController::AutoSuspend::SuspendEnter() { +#ifndef POWER_SUSPEND_NO_HDI + POWER_HILOGE(MODULE_SERVICE, "Before suspend!"); + ErrCode ret = client_->Suspend(); + POWER_HILOGE(MODULE_SERVICE, "After suspend!"); + return ret == ERR_OK ? true : false; +#else static bool inited = false; static UniqueFd suspendStateFd(TEMP_FAILURE_RETRY(open(SUSPEND_STATE_PATH, O_RDWR | O_CLOEXEC))); if (!inited) { @@ -73,15 +89,23 @@ bool SuspendController::AutoSuspend::SuspendEnter() } inited = true; } + POWER_HILOGE(MODULE_SERVICE, "Before suspend!"); bool ret = SaveStringToFd(suspendStateFd, SUSPEND_STATE); + POWER_HILOGE(MODULE_SERVICE, "After suspend!"); if (!ret) { POWER_HILOGE(MODULE_SERVICE, "Failed to write the suspending state!"); } return ret; +#endif } std::string SuspendController::AutoSuspend::WaitWakeupCount() { +#ifndef POWER_SUSPEND_NO_HDI + std::string count; + client_->ReadWakeCount(count); + return count; +#else if (wakeupCountFd < 0) { wakeupCountFd = UniqueFd(TEMP_FAILURE_RETRY(open(WAKEUP_COUNT_PATH, O_RDWR | O_CLOEXEC))); } @@ -92,10 +116,15 @@ std::string SuspendController::AutoSuspend::WaitWakeupCount() return std::string(); } return wakeupCount; +#endif } bool SuspendController::AutoSuspend::WriteWakeupCount(std::string wakeupCount) { +#ifndef POWER_SUSPEND_NO_HDI + ErrCode ret = client_->ReadWakeCount(wakeupCount); + return ret == ERR_OK ? true : false; +#else if (wakeupCountFd < 0) { return false; } @@ -104,19 +133,24 @@ bool SuspendController::AutoSuspend::WriteWakeupCount(std::string wakeupCount) POWER_HILOGE(MODULE_SERVICE, "Failed to write the wakeup count!"); } return ret; +#endif } -void SuspendController::EnableSuspend() -{ - suspend_->Start(); - POWER_HILOGI(MODULE_SERVICE, "AutoSuspend enabled"); -} - -void SuspendController::ForceSuspend() +void SuspendController::Suspend(SuspendCallback onSuspend, SuspendCallback onWakeup, bool force) { - std::lock_guard lock(suspendMutex_); - bool success = suspend_->SuspendEnter(); - POWER_HILOGI(MODULE_SERVICE, "Forced suspend %{public}s", success ? "succeeded." : "failed!"); + if (force) { + POWER_HILOGI(MODULE_SERVICE, "SuspendController Suspend: force"); + if (onSuspend != nullptr) { + onSuspend(); + } + suspend_->SuspendEnter(); + if (onWakeup != nullptr) { + onWakeup(); + } + } else { + POWER_HILOGI(MODULE_SERVICE, "SuspendController Suspend: not force"); + suspend_->Start(onSuspend, onWakeup); + } } void SuspendController::IncSuspendBlockCounter() diff --git a/services/native/src/actions/default/suspend/suspend_controller.h b/services/native/src/actions/default/suspend/suspend_controller.h index 72e19c94..2094a82e 100644 --- a/services/native/src/actions/default/suspend/suspend_controller.h +++ b/services/native/src/actions/default/suspend/suspend_controller.h @@ -16,14 +16,20 @@ #ifndef POWERMGR_SUSPEND_CONTROLLER_H #define POWERMGR_SUSPEND_CONTROLLER_H +#define POWER_SUSPEND_NO_HDI + #include #include #include #include #include +#include "power_hdf_client.h" #include "suspend/isuspend_controller.h" + +#ifdef POWER_SUSPEND_NO_HDI #include "unique_fd.h" +#endif namespace OHOS { namespace PowerMgr { @@ -35,8 +41,7 @@ public: SuspendController(); ~SuspendController() = default; - void EnableSuspend() override; - void ForceSuspend() override; + void Suspend(SuspendCallback onSuspend, SuspendCallback onWakeup, bool force) override; void IncSuspendBlockCounter() override; void DecSuspendBlockCounter() override; @@ -48,21 +53,26 @@ private: ~AutoSuspend() = default; void AutoSuspendLoop(); - void Start(); + void Start(SuspendCallback onSuspend, SuspendCallback onWakeup); bool SuspendEnter(); private: std::string WaitWakeupCount(); bool WriteWakeupCount(std::string wakeupCount); +#ifdef POWER_SUSPEND_NO_HDI static constexpr const char * const SUSPEND_STATE = "mem"; static constexpr const char * const SUSPEND_STATE_PATH = "/sys/power/state"; static constexpr const char * const WAKEUP_COUNT_PATH = "/sys/power/wakeup_count"; - UniqueFd wakeupCountFd {-1}; +#endif + std::chrono::milliseconds waitTime_ {100ms}; std::unique_ptr daemon_; WaitingSuspendConditionFunc waitingFunc_; + SuspendCallback onSuspend_; + SuspendCallback onWakeup_; + std::unique_ptr client_; }; bool SuspendConditionSatisfied(); diff --git a/services/native/src/actions/default/system_suspend_controller.cpp b/services/native/src/actions/default/system_suspend_controller.cpp index bdc9deaa..3ec0a548 100644 --- a/services/native/src/actions/default/system_suspend_controller.cpp +++ b/services/native/src/actions/default/system_suspend_controller.cpp @@ -23,44 +23,24 @@ namespace PowerMgr { SystemSuspendController::SystemSuspendController() { sc_ = std::make_shared(); - rlh_ = std::make_unique(sc_); - rlh_->Acquire(WAKEUP_HOLDER); + client_ = std::make_unique(); } SystemSuspendController::~SystemSuspendController() = default; -void SystemSuspendController::EnableSuspend() +void SystemSuspendController::Suspend(std::function onSuspend, std::function onWakeup, bool force) { - std::lock_guard lock(mutex_); - sc_->EnableSuspend(); - if (!suspendEnabled_) { - rlh_->Release(WAKEUP_HOLDER); - suspendEnabled_ = true; - } -} - -void SystemSuspendController::ForceSuspend() -{ - sc_->ForceSuspend(); -} - -void SystemSuspendController::DisableSuspend() -{ - std::lock_guard lock(mutex_); - if (suspendEnabled_) { - rlh_->Acquire(WAKEUP_HOLDER); - suspendEnabled_ = false; - } + sc_->Suspend(onSuspend, onWakeup, force); } void SystemSuspendController::AcquireRunningLock(const std::string& name) { - rlh_->Acquire(name); + client_->WakeLock(name); } void SystemSuspendController::ReleaseRunningLock(const std::string& name) { - rlh_->Release(name); + client_->WakeUnlock(name); } } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/src/actions/default/system_suspend_controller.h b/services/native/src/actions/default/system_suspend_controller.h index 42784b78..6a9199c0 100644 --- a/services/native/src/actions/default/system_suspend_controller.h +++ b/services/native/src/actions/default/system_suspend_controller.h @@ -21,6 +21,7 @@ #include +#include "power_hdf_client.h" #include "suspend/irunning_lock_hub.h" #include "suspend/isuspend_controller.h" @@ -28,9 +29,7 @@ namespace OHOS { namespace PowerMgr { class SystemSuspendController : public DelayedRefSingleton { public: - void EnableSuspend(); - void ForceSuspend(); - void DisableSuspend(); + void Suspend(std::function onSuspend, std::function onWakeup, bool force); void AcquireRunningLock(const std::string& name); void ReleaseRunningLock(const std::string& name); @@ -38,10 +37,9 @@ private: DECLARE_DELAYED_REF_SINGLETON(SystemSuspendController); inline static const std::string WAKEUP_HOLDER = "OHOSPowerMgr.WakeupHolder"; - bool suspendEnabled_ {false}; std::mutex mutex_; - std::unique_ptr rlh_; std::shared_ptr sc_; + std::unique_ptr client_; }; } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/src/power_mgr_service.cpp b/services/native/src/power_mgr_service.cpp index ca73385f..da13cd3a 100644 --- a/services/native/src/power_mgr_service.cpp +++ b/services/native/src/power_mgr_service.cpp @@ -33,7 +33,7 @@ namespace PowerMgr { namespace { const std::string POWERMGR_SERVICE_NAME = "PowerMgrService"; const std::string TASK_RUNNINGLOCK_UNLOCK = "RunningLock_UnLock"; -constexpr int APP_FIRST_UID = 10000; +constexpr int APP_FIRST_UID = APP_FIRST_UID_VALUE; auto pms = DelayedSpSingleton::GetInstance(); const bool G_REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(pms.GetRefPtr()); } @@ -88,6 +88,9 @@ bool PowerMgrService::Init() if (!PowerStateMachineInit()) { POWER_HILOGE(MODULE_SERVICE, "power state machine init fail!"); } + if (!DelayedSpSingleton::GetInstance()) { + POWER_HILOGE(MODULE_SERVICE, "power mode init fail!"); + } POWER_HILOGI(MODULE_SERVICE, "Init success"); return true; } @@ -157,7 +160,7 @@ void PowerMgrService::ShutDownDevice(const std::string& reason) { pid_t pid = IPCSkeleton::GetCallingPid(); auto uid = IPCSkeleton::GetCallingUid(); - if ((uid >= APP_FIRST_UID) && !Permission::CheckCallingPermission("ohos.permission.REBOOT")) { + if ((uid >= APP_FIRST_UID) && !Permission::CheckCallingPermission("ohos.permission.SHUTDOWN")) { POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, %{public}d permission check fail", __func__, pid); return; } @@ -378,5 +381,41 @@ void PowerMgrService::UnRegisterShutdownCallback(const sptr& POWER_HILOGE(MODULE_SERVICE, "UnRegister shutdown callback: %{public}d", uid); shutdownService_.DelShutdownCallback(callback); } + +void PowerMgrService::RegisterPowerModeCallback(const sptr& callback) +{ + auto uid = IPCSkeleton::GetCallingUid(); + if (uid >= APP_FIRST_UID) { + POWER_HILOGE(MODULE_SERVICE, "Register failed, %{public}d fail", uid); + return; + } + POWER_HILOGE(MODULE_SERVICE, "Register power mode callback: %{public}d", uid); + powerModeModule_.AddPowerModeCallback(callback); +} + +void PowerMgrService::UnRegisterPowerModeCallback(const sptr& callback) +{ + auto uid = IPCSkeleton::GetCallingUid(); + if (uid >= APP_FIRST_UID) { + POWER_HILOGE(MODULE_SERVICE, "UnRegister failed, %{public}d fail", uid); + return; + } + POWER_HILOGE(MODULE_SERVICE, "UnRegister power mode callback: %{public}d", uid); + powerModeModule_.DelPowerModeCallback(callback); +} + +void PowerMgrService::SetDeviceMode(const uint32_t& mode) +{ + pid_t pid = IPCSkeleton::GetCallingPid(); + POWER_HILOGI(MODULE_SERVICE, "PID: %{public}d Call %{public}s !", pid, __func__); + powerModeModule_.SetModeItem(mode); +} + +uint32_t PowerMgrService::GetDeviceMode() +{ + pid_t pid = IPCSkeleton::GetCallingPid(); + POWER_HILOGI(MODULE_SERVICE, "PID: %{public}d Call %{public}s !", pid, __func__); + return powerModeModule_.GetModeItem(); +} } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/src/power_mode_module.cpp b/services/native/src/power_mode_module.cpp new file mode 100644 index 00000000..0f55994c --- /dev/null +++ b/services/native/src/power_mode_module.cpp @@ -0,0 +1,330 @@ +/* + * Copyright (c) 2021 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 + +#include +#include +#include +#include + +#include + +#include "power_mode_module.h" +#include "power_mode_policy.h" +#include "power_save_model.h" +#include "hilog_wrapper.h" +#include "power_mgr_factory.h" +#include "singleton.h" + +using namespace OHOS::AAFwk; +using namespace OHOS::EventFwk; + +using namespace std; + +using namespace OHOS; + +namespace OHOS { +namespace PowerMgr { +PowerModeModule::PowerModeModule() : started_(false) {} + +void PowerModeModule::SetModeItem(uint32_t mode) +{ + POWER_HILOGD(MODULE_SERVICE, "Set Mode Item : %{public}u",mode); + + /* Same as the previous mode */ + if(this->mode_ == mode){ + return; + } + + /* If it's a valid mode */ + switch(mode) { + case PowerModeModule::EXTREAM_MODE: + case PowerModeModule::NORMAL_MODE: + case PowerModeModule::SAVE_MODE: + case PowerModeModule::LOWPOWER_MODE: + break; + default: + POWER_HILOGE(MODULE_SERVICE, "Unknow mode"); + return; + } + + /* start set mode thread */ + EnableMode(mode); +} + +uint32_t PowerModeModule::GetModeItem() +{ + POWER_HILOGD(MODULE_SERVICE, "Get Mode Item : %{public}u",mode_); + /* get power mode */ + return mode_; +} + +void PowerModeModule::EnableMode(uint32_t mode) +{ + if (started_) { + POWER_HILOGE(MODULE_SERVICE, "Power Mode is already running."); + return; + } + + started_ = true; + mode_ = mode; + + /* Update power mode policy */ + UpdateModepolicy(); + + /* Send state change */ + Prepare(); + + /* Set action */ + RunAction(); + + this->lastMode_ = mode; + started_ = false; +} + +void PowerModeModule::UpdateModepolicy() +{ + /* update policy */ + DelayedSingleton::GetInstance()->SetPowerModePolicy(this->mode_, this->lastMode_); +} + +void PowerModeModule::AddPowerModeCallback(const sptr& callback) +{ + callbackMgr_.AddCallback(callback); +} + +void PowerModeModule::DelPowerModeCallback(const sptr& callback) +{ + callbackMgr_.RemoveCallback(callback); +} + +void PowerModeModule::Prepare() +{ + PublishPowerModeEvent(); + callbackMgr_.WaitingCallback(); +} + +void PowerModeModule::CallbackManager::AddCallback(const sptr& callback) +{ + unique_lock lock(mutex_); + RETURN_IF((callback == nullptr) || (callback->AsObject() == nullptr)); + auto object = callback->AsObject(); + auto retIt = callbacks_.insert(object); + if (retIt.second) { + object->AddDeathRecipient(this); + } + POWER_HILOGI(MODULE_SERVICE, "object = %{public}p, callback = %{public}p, callbacks.size = %{public}zu," + " insertOk = %{public}d", object.GetRefPtr(), + callback.GetRefPtr(), callbacks_.size(), retIt.second); +} + +void PowerModeModule::CallbackManager::RemoveCallback(const sptr& callback) +{ + unique_lock lock(mutex_); + RETURN_IF((callback == nullptr) || (callback->AsObject() == nullptr)); + auto object = callback->AsObject(); + auto it = find(callbacks_.begin(), callbacks_.end(), object); + if (it != callbacks_.end()) { + callbacks_.erase(it); + object->RemoveDeathRecipient(this); + } + POWER_HILOGI(MODULE_SERVICE, "object = %{public}p, callback = %{public}p, callbacks.size = %{public}zu,", + object.GetRefPtr(), callback.GetRefPtr(), callbacks_.size()); +} + +void PowerModeModule::CallbackManager::OnRemoteDied(const wptr& remote) +{ + POWER_HILOGI(MODULE_SERVICE,"OnRemoteDied"); + RETURN_IF(remote.promote() == nullptr); + RemoveCallback(iface_cast(remote.promote())); +} + +void PowerModeModule::CallbackManager::WaitingCallback() +{ + POWER_HILOGD(MODULE_SERVICE, "mode callback started."); + unique_lock lock(mutex_); + for (auto &obj : callbacks_) { + sptr callback = iface_cast(obj); + if (callback != nullptr) { + POWER_HILOGD(MODULE_SERVICE, "callback->PowerModeCallback()"); + callback->PowerModeCallback(); + } + } +} + +void PowerModeModule::PublishPowerModeEvent() +{ + POWER_HILOGD(MODULE_SERVICE, "Start of publishing mode event"); + /* send event */ + CommonEventPublishInfo publishInfo; + publishInfo.SetOrdered(false); + IntentWant setModeWant; + CommonEventData event(setModeWant); + switch(mode_) { + case PowerModeModule::EXTREAM_MODE: + setModeWant.SetAction(CommonEventSupport::COMMON_EVENT_DEVICE_IDLE_MODE_CHANGED); + event.SetCode(PowerModeModule::EXTREAM_MODE); + break; + case PowerModeModule::NORMAL_MODE: + setModeWant.SetAction(CommonEventSupport::COMMON_EVENT_DEVICE_IDLE_MODE_CHANGED); + event.SetCode(PowerModeModule::NORMAL_MODE); + break; + case PowerModeModule::SAVE_MODE: + setModeWant.SetAction(CommonEventSupport::COMMON_EVENT_POWER_SAVE_MODE_CHANGED); + event.SetCode(PowerModeModule::SAVE_MODE); + break; + case PowerModeModule::LOWPOWER_MODE: + setModeWant.SetAction(CommonEventSupport::COMMON_EVENT_POWER_SAVE_MODE_CHANGED); + event.SetCode(PowerModeModule::LOWPOWER_MODE); + break; + default: + POWER_HILOGE(MODULE_SERVICE, "Unknow mode"); + return; + } + if (!CommonEventManager::PublishCommonEvent(event, publishInfo, nullptr)) { + POWER_HILOGE(MODULE_SERVICE, "Failed to publish the mode event!"); + return; + } + POWER_HILOGD(MODULE_SERVICE, "End of publishing mode event"); +} + +void PowerModeModule::RunAction() +{ + //set lcd brightness + PowerModeModule::SetLcdBrightness(); + //set vibration + PowerModeModule::SetVibration(); + // On/Off rotation + PowerModeModule::OnOffRotation(); + + return; +} + +void PowerModeModule::SetLcdBrightness() +{ + POWER_HILOGD(MODULE_SERVICE, "set lcd brightness"); + int32_t lcdBrightness = DelayedSingleton::GetInstance() + ->GetPowerModeValuePolicy(PowerModePolicy::ServiceType::smartBacklight); + POWER_HILOGD(MODULE_SERVICE, "GetPowerModeValuePolicy lcdBrightness=%{public}d", lcdBrightness); + if (lcdBrightness != FLAG_FALSE) { + //set lastmode value to recoverValue + if (lastMode_ == LAST_MODE_FLAG) { + POWER_HILOGD(MODULE_SERVICE, "first set lcdBrightness=%{public}d",lcdBrightness); + recoverValue[PowerModePolicy::ServiceType::smartBacklight] = lcdBrightness; + } else { + //get value from setting privider value + POWER_HILOGD(MODULE_SERVICE, "Setting lcdBrightness=%{public}d", SETTINGS_PRIVIDER_VALUE_LCD_BRIGHTNESS); + recoverValue[PowerModePolicy::ServiceType::smartBacklight] = SETTINGS_PRIVIDER_VALUE_LCD_BRIGHTNESS; + } + //set lcd brightness + POWER_HILOGD(MODULE_SERVICE, "please set lcdBrightness"); + } else { + lcdBrightness = DelayedSingleton::GetInstance() + ->GetPowerModeRecoverPolicy(PowerModePolicy::ServiceType::smartBacklight); + POWER_HILOGD(MODULE_SERVICE, "GetPowerModeRecoverPolicy lcdBrightness=%{public}d", lcdBrightness); + if (lcdBrightness != FLAG_FALSE) { + //get recoverValue + std::lock_guard lock(mutex_); + recoverValueiter = recoverValue.find(PowerModePolicy::ServiceType::smartBacklight); + if (recoverValueiter != recoverValue.end()) { + lcdBrightness = recoverValueiter->second; + POWER_HILOGD(MODULE_SERVICE, "Get recovervalue lcdBrightness=%{public}d",lcdBrightness); + //delete map + recoverValue.erase(recoverValueiter); + } + POWER_HILOGD(MODULE_SERVICE, "please set lcdBrightness"); + } + } + return; +} + +void PowerModeModule::SetVibration() +{ + POWER_HILOGD(MODULE_SERVICE, "set vibration"); + int32_t vibration = DelayedSingleton::GetInstance() + ->GetPowerModeValuePolicy(PowerModePolicy::ServiceType::vibratorsState); + POWER_HILOGD(MODULE_SERVICE, "GetPowerModeValuePolicy vibrate=%{public}d", vibration); + if (vibration != FLAG_FALSE) { + //set lastmode value to recoverValue + if (lastMode_ == LAST_MODE_FLAG) { + POWER_HILOGD(MODULE_SERVICE, "first set vibration=%{public}d",vibration); + recoverValue[PowerModePolicy::ServiceType::vibratorsState] = vibration; + } else { + //get value from setting privider value + POWER_HILOGD(MODULE_SERVICE, "Setting vibration=%{public}d", SETTINGS_PRIVIDER_VALUE_VIBRATION); + recoverValue[PowerModePolicy::ServiceType::vibratorsState] = SETTINGS_PRIVIDER_VALUE_VIBRATION; + } + //set vibration + POWER_HILOGD(MODULE_SERVICE, "please set vibration"); + } else { + vibration = DelayedSingleton::GetInstance() + ->GetPowerModeRecoverPolicy(PowerModePolicy::ServiceType::vibratorsState); + POWER_HILOGD(MODULE_SERVICE, "GetPowerModeRecoverPolicy vibration=%{public}d", vibration); + if (vibration != FLAG_FALSE) { + //get recoverValue + std::lock_guard lock(mutex_); + recoverValueiter = recoverValue.find(PowerModePolicy::ServiceType::vibratorsState); + if (recoverValueiter != recoverValue.end()) { + vibration = recoverValueiter->second; + POWER_HILOGD(MODULE_SERVICE, "Get recovervalue vibration=%{public}d",vibration); + //delete map + recoverValue.erase(recoverValueiter); + } + POWER_HILOGD(MODULE_SERVICE, "please set vibration"); + } + } + return; +} + +void PowerModeModule::OnOffRotation() +{ + POWER_HILOGD(MODULE_SERVICE, "on or off rotation"); + int32_t rotation = DelayedSingleton::GetInstance() + ->GetPowerModeValuePolicy(PowerModePolicy::ServiceType::autoWindownRoration); + POWER_HILOGD(MODULE_SERVICE, "GetPowerModeValuePolicy rotation=%{public}d", rotation); + if (rotation != FLAG_FALSE) { + //set lastmode value to recoverValue + if (lastMode_ == LAST_MODE_FLAG) { + POWER_HILOGD(MODULE_SERVICE, "first set rotation=%{public}d",rotation); + recoverValue[PowerModePolicy::ServiceType::autoWindownRoration] = rotation; + } else { + //get value from setting privider value + POWER_HILOGD(MODULE_SERVICE, "Setting rotation=%{public}d", SETTINGS_PRIVIDER_VALUE_ROTATION); + recoverValue[PowerModePolicy::ServiceType::autoWindownRoration] = SETTINGS_PRIVIDER_VALUE_ROTATION; + } + //set lcd vibrate + POWER_HILOGD(MODULE_SERVICE, "please on or off rotation"); + } else { + rotation = DelayedSingleton::GetInstance() + ->GetPowerModeRecoverPolicy(PowerModePolicy::ServiceType::autoWindownRoration); + POWER_HILOGD(MODULE_SERVICE, "GetPowerModeRecoverPolicy rotation=%{public}d", rotation); + if (rotation != FLAG_FALSE) { + //get recoverValue + std::lock_guard lock(mutex_); + recoverValueiter = recoverValue.find(PowerModePolicy::ServiceType::vibratorsState); + if (recoverValueiter != recoverValue.end()) { + rotation = recoverValueiter->second; + POWER_HILOGD(MODULE_SERVICE, "Get recovervalue rotation=%{public}d",rotation); + //delete map + recoverValue.erase(recoverValueiter); + } + POWER_HILOGD(MODULE_SERVICE, "please on or off rotation"); + } + } + return; +} +} // namespace PowerMgr +} // namespace OHOS diff --git a/services/native/src/power_mode_policy.cpp b/services/native/src/power_mode_policy.cpp new file mode 100644 index 00000000..cf87b676 --- /dev/null +++ b/services/native/src/power_mode_policy.cpp @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2021 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 "power_mode_policy.h" +#include "power_save_model.h" +#include "singleton.h" +#include "hilog_wrapper.h" + +using namespace std; + +namespace OHOS { +namespace PowerMgr { + +int32_t PowerModePolicy::GetPowerModeValuePolicy(uint32_t type) +{ + int32_t ret = INIT_VALUE_FALSE; + switch (type) { + case PowerModePolicy::ServiceType::autoWindownRoration: + case PowerModePolicy::ServiceType::smartBacklight: + case PowerModePolicy::ServiceType::vibratorsState: + ret = GetPolicyFromMap(type); + break; + default: + break; + } + return ret; +} + +int32_t PowerModePolicy::GetPolicyFromMap(uint32_t type) +{ + int32_t ret = INIT_VALUE_FALSE; + valueiter = valueModePolicy.find(type); + if(valueiter != valueModePolicy.end()){ + ret = valueiter->second; + return ret; + }else{ + return ret; + } +} + +int32_t PowerModePolicy::GetRecoverPolicyFromMap(uint32_t type) +{ + int32_t ret = INIT_VALUE_FALSE; + recoveriter = recoverModePolicy.find(type); + if(recoveriter != recoverModePolicy.end()) { + ret = recoveriter->second; + POWER_HILOGD(MODULE_SERVICE, "recover value=%{public}d",ret); + } + return ret; +} + +int32_t PowerModePolicy::GetPowerModeRecoverPolicy(uint32_t type) +{ + int32_t ret = INIT_VALUE_FALSE; + switch (type) { + case PowerModePolicy::ServiceType::autoWindownRoration: + case PowerModePolicy::ServiceType::smartBacklight: + case PowerModePolicy::ServiceType::vibratorsState: + ret = GetRecoverPolicyFromMap(type); + break; + default: + break; + } + return ret; +} + +void PowerModePolicy::SetPowerModePolicy(uint32_t mode, uint32_t lastMode) +{ + POWER_HILOGD(MODULE_SERVICE, "mode=%{public}d, lastMode=%{public}d",mode,lastMode); + if(lastMode != LAST_MODE_FLAG){ + ReadRecoverPolicy(lastMode); + } + + ReadOpenPolicy(mode); + + CompareModeItem(mode, lastMode); +} + +void PowerModePolicy::ReadOpenPolicy(uint32_t mode) +{ + DelayedSpSingleton::GetInstance()->GetValuePolicy(openPolicy, mode); +} + +void PowerModePolicy::ReadRecoverPolicy(uint32_t mode) +{ + DelayedSpSingleton::GetInstance()->GetRecoverPolicy(recoverPolicy, mode); +} + +void PowerModePolicy::CompareModeItem(uint32_t mode, uint32_t lastMode) +{ + recoverModePolicy.clear(); + valueModePolicy.clear(); + + for(auto openlit = openPolicy.begin() ; openlit != openPolicy.end(); openlit++){ + valueModePolicy[(*openlit).id] = (*openlit).value; + } + + for(recoverlit = recoverPolicy.begin() ; recoverlit != recoverPolicy.end(); recoverlit++){ + recoverModePolicy[(*recoverlit).id] = (*recoverlit).value; + POWER_HILOGD(MODULE_SERVICE, "(*recoverlit).id=%{public}d, (*recoverlit).value=%{public}d",(*recoverlit).id,(*recoverlit).value); + } + + openPolicy.clear(); + recoverPolicy.clear(); +} +} // namespace PowerMgr +} // namespace OHOS diff --git a/services/native/src/power_save_model.cpp b/services/native/src/power_save_model.cpp new file mode 100644 index 00000000..de62b514 --- /dev/null +++ b/services/native/src/power_save_model.cpp @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2021 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 "power_save_model.h" +#include "libxml/parser.h" +#include "libxml/tree.h" +#include "hilog_wrapper.h" + +#include + +namespace OHOS { +namespace PowerMgr { +constexpr auto TAG_ROOT_ = "switch_policy"; +constexpr uint32_t SLEEP_FILTER = SLEEP_FILTER_VALUE; + +PowerSaveMode::PowerSaveMode() +{ + POWER_HILOGD(MODULE_SERVICE, "Start powersave.xml parse"); + StartXMlParse("/system/etc/power_config/power_mode_config.xml"); +} + +bool IsNodeLegal(const xmlNodePtr nodePtr, const char* tagName) +{ + return nodePtr != nullptr && nodePtr->type != XML_COMMENT_NODE && nodePtr->name != nullptr && + xmlStrEqual(nodePtr->name, BAD_CAST(tagName)) == 0; +} + +bool PowerSaveMode::StartXMlParse(std::string path) +{ + std::unique_ptr docPtr( + xmlReadFile(path.c_str(), nullptr, XML_PARSE_NOBLANKS), xmlFreeDoc); + if (docPtr == nullptr) { + POWER_HILOGE(MODULE_SERVICE, "Parse failed, read file failed."); + return false; + } + + auto rootPtr = xmlDocGetRootElement(docPtr.get()); + if (!IsNodeLegal(rootPtr, TAG_ROOT_)) { + POWER_HILOGE(MODULE_SERVICE, "Parse failed, root node is illegal."); + return false; + } + + for (auto nodePtr = rootPtr->xmlChildrenNode; nodePtr != nullptr; nodePtr = nodePtr->next) { + int32_t policyId = atoi((char *)xmlGetProp(nodePtr, BAD_CAST("id"))); + std::list listPolicy; + for (auto policyNodePtr = nodePtr->xmlChildrenNode; policyNodePtr != nullptr; policyNodePtr = policyNodePtr->next){ + ModePolicy pmp; + pmp.id = atoi((char *)xmlGetProp(policyNodePtr, BAD_CAST("id"))); + pmp.recover_flag = atoi((char *)xmlGetProp(policyNodePtr, BAD_CAST("recover_flag"))); + pmp.value = atoi((char *)xmlGetProp(policyNodePtr, BAD_CAST("value"))); + listPolicy.push_back(pmp); + POWER_HILOGE(MODULE_SERVICE, "id=%{public}d", pmp.id); + POWER_HILOGE(MODULE_SERVICE, "value=%{public}d", pmp.value); + POWER_HILOGE(MODULE_SERVICE, "recover_flag=%{public}d", pmp.recover_flag); + } + this->policyCache_.insert({policyId, listPolicy}); + POWER_HILOGI(MODULE_SERVICE, "policyId = %{public}d.", policyId); + } + return true; +} + +bool PowerSaveMode::GetValuePolicy(std::list &openPolicy, int32_t mode) +{ + bool result = GetFilterPolicy(openPolicy, mode, ValueProp::value); + return result; +} + +bool PowerSaveMode::GetRecoverPolicy(std::list &recoverPolicy, int32_t mode) +{ + bool result = GetFilterPolicy(recoverPolicy, mode, ValueProp::recover); + return result; +} + +bool PowerSaveMode::GetFilterPolicy(std::list &policyList, int32_t mode, int32_t value) +{ + if (this->policyCache_.size() == 0) { + return false; + } + for (ModePolicy modePolicy :this->policyCache_[mode]) { + policyList.push_back(modePolicy); + } + if (ValueProp::recover == value) { + policyList.remove_if([&](ModePolicy mp) {return mp.recover_flag != ValueProp::recover;}); + } + return true; +} + +int32_t PowerSaveMode::GetSleepTime(int32_t mode) +{ + if (this->policyCache_.size() == 0) { + return RETURN_FLAG_FALSE; + } + std::list modePolicyList = this->policyCache_[mode]; + for (auto modePolicy:modePolicyList) { + if (modePolicy.id == SLEEP_FILTER) { + return modePolicy.value; + } + } + return RETURN_FLAG_FALSE; +} +} // namespace PowerMgr +} // namespace OHOS diff --git a/services/native/src/power_state_machine.cpp b/services/native/src/power_state_machine.cpp index 052aa674..5420ea79 100644 --- a/services/native/src/power_state_machine.cpp +++ b/services/native/src/power_state_machine.cpp @@ -116,7 +116,7 @@ void PowerStateMachine::InitStateMap() POWER_HILOGE(MODULE_SERVICE, "Failed to go to SLEEP, Display Err"); return TransitResult::HDI_ERR; } - ret = stateAction_->GoToSleep(); + ret = stateAction_->GoToSleep(onSuspend, onWakeup, false); if (ret != ActionResult::SUCCESS) { POWER_HILOGE(MODULE_SERVICE, "Failed to go to SLEEP, Sleep Err"); return TransitResult::HDI_ERR; @@ -127,6 +127,26 @@ void PowerStateMachine::InitStateMap() ); } +void PowerStateMachine::onSuspend() +{ + POWER_HILOGI(MODULE_SERVICE, "System is suspending"); +} + +void PowerStateMachine::onWakeup() +{ + POWER_HILOGI(MODULE_SERVICE, "System is awake"); + auto pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + return; + } + auto handler = pms->GetHandler(); + if (handler == nullptr) { + POWER_HILOGE(MODULE_SERVICE, "SetDelayTimer handler is null"); + return; + } + handler->SendEvent(PowermsEventHandler::SYSTEM_WAKE_UP_MSG, 0, 0); +} + void PowerStateMachine::SuspendDeviceInner(pid_t pid, int64_t callTimeMs, SuspendDeviceType type, bool suspendImmed, bool ignoreScreenState) { @@ -194,16 +214,11 @@ bool PowerStateMachine::ForceSuspendDeviceInner(pid_t pid, int64_t callTimeMs) { POWER_HILOGI(MODULE_SERVICE, "ForceSuspendDeviceInner: fun is Start!"); if (stateAction_ != nullptr) { - stateAction_->ForceSuspend(); + stateAction_->GoToSleep(onSuspend, onWakeup, true); } - bool ret = SetState(PowerState::SLEEP, StateChangeReason::STATE_CHANGE_REASON_SYSTEM, true); - if (!ret) { - // if can't go to sleep, turn to inactive - SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_SYSTEM, true); - } POWER_HILOGI(MODULE_SERVICE, "ForceSuspendDeviceInner: fun is End!"); - return ret; + return true; } bool PowerStateMachine::IsScreenOn() @@ -400,6 +415,9 @@ void PowerStateMachine::HandleDelayTimer(int32_t event) case PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG: HandleActivitySleepTimeout(); break; + case PowermsEventHandler::SYSTEM_WAKE_UP_MSG: + HandleSystemWakeup(); + break; default: break; } @@ -435,6 +453,16 @@ void PowerStateMachine::HandleActivitySleepTimeout() POWER_HILOGI(MODULE_SERVICE, "HandleActivitySleepTimeout: fun is End!"); } +void PowerStateMachine::HandleSystemWakeup() +{ + POWER_HILOGI(MODULE_SERVICE, "HandleSystemWakeup (%{public}d)", stateAction_->GetDisplayState()); + if (IsScreenOn()) { + SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_SYSTEM, true); + } else { + SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_SYSTEM, true); + } +} + bool PowerStateMachine::CheckRunningLock(PowerState state) { POWER_HILOGI(MODULE_SERVICE, "CheckRunningLock: fun is Start!"); diff --git a/services/native/src/powerms_event_handler.cpp b/services/native/src/powerms_event_handler.cpp index 22fbf3e2..0ee31b92 100644 --- a/services/native/src/powerms_event_handler.cpp +++ b/services/native/src/powerms_event_handler.cpp @@ -46,7 +46,8 @@ void PowermsEventHandler::ProcessEvent([[maybe_unused]] const AppExecFwk::InnerE } case CHECK_USER_ACTIVITY_TIMEOUT_MSG: // fallthrough case CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG: // fallthrough - case CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG: { + case CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG: // fallthrough + case SYSTEM_WAKE_UP_MSG: { auto powerStateMachine = pmsptr->GetPowerStateMachine(); if (powerStateMachine == nullptr) { return; diff --git a/services/native/test/unittest/src/power_state_machine_test.cpp b/services/native/test/unittest/src/power_state_machine_test.cpp index 92736628..acb984bb 100644 --- a/services/native/test/unittest/src/power_state_machine_test.cpp +++ b/services/native/test/unittest/src/power_state_machine_test.cpp @@ -176,9 +176,7 @@ HWTEST_F (PowerStateMachineTest, PowerStateMachine006, TestSize.Level0) // Check illegal para details GTEST_LOG_(INFO) << "PowerStateMachine006: Check illegal para details Begin!"; - powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, - string("Software Wakeup test!Software Wakeup test! Software Wakeup test! Software Wakeup test! " \ - "Software Wakeup test!Software Wakeup test! Software Wakeup test!")); + powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION); sleep(SLEEP_WAIT_TIME_S); EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerStateMachine006: Check details test Fail, Screen is Off."; @@ -189,7 +187,7 @@ HWTEST_F (PowerStateMachineTest, PowerStateMachine006, TestSize.Level0) EXPECT_EQ(powerMgrClient.IsScreenOn(), false) << "PowerStateMachine006: Real test tprepare Fail, Screen is On."; GTEST_LOG_(INFO) << "PowerStateMachine006: Screen is Off, Begin to Real Wakeup Device!"; - powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, string("Software Wakeup")); + powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION); sleep(SLEEP_WAIT_TIME_S); EXPECT_EQ(powerMgrClient.IsScreenOn(), true) << "PowerStateMachine006: Real Wakeup Device Fail, Screen is Off"; diff --git a/services/native/test/unittest/src/running_lock_test.cpp b/services/native/test/unittest/src/running_lock_test.cpp index 690125cb..2763c618 100644 --- a/services/native/test/unittest/src/running_lock_test.cpp +++ b/services/native/test/unittest/src/running_lock_test.cpp @@ -256,45 +256,6 @@ HWTEST_F (RunningLockTest, RunningLockInnerKit004, TestSize.Level1) } } -/** - * @tc.name: RunningLockInnerKit005 - * @tc.desc: Test RunningLockInnerKit function, dfx. - * @tc.type: FUNC - */ -HWTEST_F (RunningLockTest, RunningLockInnerKit005, TestSize.Level2) -{ - auto& powerMgrClient = PowerMgrClient::GetInstance(); - auto runningLock1 = powerMgrClient.CreateRunningLock("runninglock1", RunningLockType::RUNNINGLOCK_SCREEN); - ASSERT_TRUE(runningLock1 != nullptr); - runningLock1->Lock(); - DumpRunningLockInfo(); - auto runningLock2 = powerMgrClient.CreateRunningLock("runninglock2", RunningLockType::RUNNINGLOCK_BACKGROUND); - ASSERT_TRUE(runningLock2 != nullptr); - runningLock2->Lock(); - DumpRunningLockInfo(); - powerMgrClient.ProxyRunningLock(true, getuid(), getpid()); - DumpRunningLockInfo(); - powerMgrClient.ProxyRunningLock(false, getuid(), getpid()); - DumpRunningLockInfo(); - runningLock1->UnLock(); - DumpRunningLockInfo(); - runningLock1->Lock(); - std::shared_ptr worker1 = std::make_shared(1, "worker1"); - std::shared_ptr worker2 = std::make_shared(2, "worker2", 20); - std::shared_ptr worker3 = std::make_shared(3, "worker3", 30); - std::shared_ptr worker4 = std::make_shared(); - WorkTriggerList worklist; - worklist.push_back(worker1); - worklist.push_back(worker2); - worklist.push_back(worker3); - worklist.push_back(worker4); - runningLock1->SetWorkTriggerList(worklist); - DumpRunningLockInfo(); - sleep(70); - DumpRunningLockInfo(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnitTest::RunningLockInnerKit006."); -} - /** * @tc.name: RunningLockMgr001 * @tc.desc: Test RunningLockMgr function, connect PowerMgrService and call member function. diff --git a/services/zidl/include/power_mgr_proxy.h b/services/zidl/include/power_mgr_proxy.h index 0d4e2415..9f5a2369 100644 --- a/services/zidl/include/power_mgr_proxy.h +++ b/services/zidl/include/power_mgr_proxy.h @@ -53,6 +53,10 @@ public: virtual void UnRegisterPowerStateCallback(const sptr& callback) override; virtual void RegisterShutdownCallback(const sptr& callback) override; virtual void UnRegisterShutdownCallback(const sptr& callback) override; + virtual void RegisterPowerModeCallback(const sptr& callback) override; + virtual void UnRegisterPowerModeCallback(const sptr& callback) override; + virtual void SetDeviceMode(const uint32_t& mode) override; + virtual uint32_t GetDeviceMode() override; private: static inline BrokerDelegator delegator_; }; diff --git a/services/zidl/include/power_mgr_stub.h b/services/zidl/include/power_mgr_stub.h index 354f2376..2f883c2e 100644 --- a/services/zidl/include/power_mgr_stub.h +++ b/services/zidl/include/power_mgr_stub.h @@ -51,6 +51,10 @@ private: int32_t UnRegisterPowerStateCallbackStub(MessageParcel& data); int32_t RegisterShutdownCallbackStub(MessageParcel& data); int32_t UnRegisterShutdownCallbackStub(MessageParcel& data); + int32_t RegisterPowerModeCallbackStub(MessageParcel& data); + int32_t UnRegisterPowerModeCallbackStub(MessageParcel& data); + int32_t SetDeviceModeStub(MessageParcel& data); + int32_t GetDeviceModeStub(MessageParcel& reply); }; } // namespace PowerMgr } // namespace OHOS diff --git a/services/zidl/include/power_mode_callback_proxy.h b/services/zidl/include/power_mode_callback_proxy.h new file mode 100644 index 00000000..b4cc5cb6 --- /dev/null +++ b/services/zidl/include/power_mode_callback_proxy.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2021 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 POWERMGR_SERVICES_MODE_STATE_CALLBACK_PROXY_H +#define POWERMGR_SERVICES_MODE_STATE_CALLBACK_PROXY_H + +#include +#include + +#include "ipower_mode_callback.h" + +namespace OHOS { +namespace PowerMgr { +class PowerModeCallbackProxy : public IRemoteProxy { +public: + explicit PowerModeCallbackProxy(const sptr& impl) + : IRemoteProxy(impl) {} + virtual ~PowerModeCallbackProxy() = default; + virtual void PowerModeCallback() override; + +private: + static inline BrokerDelegator delegator_; +}; +} // namespace PowerMgr +} // namespace OHOS +#endif // POWERMGR_SERVICES_MODE_STATE_CALLBACK_PROXY_H diff --git a/services/zidl/include/power_mode_callback_stub.h b/services/zidl/include/power_mode_callback_stub.h new file mode 100644 index 00000000..b9727f8b --- /dev/null +++ b/services/zidl/include/power_mode_callback_stub.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2021 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 POWERMGR_SERVICES_IPOWER_MODE_CALLBACK_STUB_H +#define POWERMGR_SERVICES_IPOWER_MODE_CALLBACK_STUB_H + +#include +#include + +#include "ipower_mode_callback.h" + +namespace OHOS { +namespace PowerMgr { +class PowerModeCallbackStub : public IRemoteStub { +public: + DISALLOW_COPY_AND_MOVE(PowerModeCallbackStub); + PowerModeCallbackStub() = default; + virtual ~PowerModeCallbackStub() = default; + int OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override; + void PowerModeCallback() override{}; + +private: + int32_t OnPowerModeCallbackStub(); +}; +} // namespace PowerMgr +} // namespace OHOS +#endif // POWERMGR_SERVICES_IPOWER_MODE_CALLBACK_STUB_H diff --git a/services/zidl/include/power_shutdown_callback_proxy.h b/services/zidl/include/power_shutdown_callback_proxy.h new file mode 100644 index 00000000..02a22133 --- /dev/null +++ b/services/zidl/include/power_shutdown_callback_proxy.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2021 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 POWERMGR_SERVICES_SHUTDOWN_STATE_CALLBACK_PROXY_H +#define POWERMGR_SERVICES_SHUTDOWN_STATE_CALLBACK_PROXY_H + +#include +#include + +#include "ishutdown_callback.h" + +namespace OHOS { +namespace PowerMgr { +class PowerShutdownCallbackProxy : public IRemoteProxy { +public: + explicit PowerShutdownCallbackProxy(const sptr& impl) + : IRemoteProxy(impl) {} + virtual ~PowerShutdownCallbackProxy() = default; + virtual void ShutdownCallback() override; + +private: + static inline BrokerDelegator delegator_; +}; +} // namespace PowerMgr +} // namespace OHOS +#endif // POWERMGR_SERVICES_SHUTDOWN_STATE_CALLBACK_PROXY_H diff --git a/services/zidl/include/power_shutdown_callback_stub.h b/services/zidl/include/power_shutdown_callback_stub.h new file mode 100644 index 00000000..6f7c3a41 --- /dev/null +++ b/services/zidl/include/power_shutdown_callback_stub.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2021 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 POWERMGR_SERVICES_IPOWER_SHUTDOWN_CALLBACK_STUB_H +#define POWERMGR_SERVICES_IPOWER_SHUTDOWN_CALLBACK_STUB_H + +#include +#include + +#include "ishutdown_callback.h" + +namespace OHOS { +namespace PowerMgr { +class PowerShutdownCallbackStub : public IRemoteStub { +public: + DISALLOW_COPY_AND_MOVE(PowerShutdownCallbackStub); + PowerShutdownCallbackStub() = default; + virtual ~PowerShutdownCallbackStub() = default; + int OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override; + void ShutdownCallback() override{}; + +private: + int32_t OnPowerShutdownCallbackStub(); +}; +} // namespace PowerMgr +} // namespace OHOS +#endif // POWERMGR_SERVICES_IPOWER_STATE_CALLBACK_STUB_H diff --git a/services/zidl/src/power_mgr_proxy.cpp b/services/zidl/src/power_mgr_proxy.cpp index 30256077..a0762216 100644 --- a/services/zidl/src/power_mgr_proxy.cpp +++ b/services/zidl/src/power_mgr_proxy.cpp @@ -388,7 +388,7 @@ PowerState PowerMgrProxy::GetState() return PowerState::UNKNOWN; } - int ret = remote->SendRequest(static_cast(IPowerMgr::IS_SCREEN_ON), data, reply, option); + int ret = remote->SendRequest(static_cast(IPowerMgr::GET_STATE), data, reply, option); if (ret != ERR_OK) { POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s SendRequest is failed, error code: %d", __func__, ret); return PowerState::UNKNOWN; @@ -519,5 +519,102 @@ void PowerMgrProxy::UnRegisterShutdownCallback(const sptr& ca return; } } + +void PowerMgrProxy::RegisterPowerModeCallback(const sptr& callback) +{ + sptr remote = Remote(); + RETURN_IF((remote == nullptr) || (callback == nullptr)); + + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) { + POWER_HILOGE(MODULE_INNERKIT, "Write descriptor failed!"); + return; + } + + WRITE_PARCEL_NO_RET(data, RemoteObject, callback->AsObject()); + + int ret = remote->SendRequest(static_cast(IPowerMgr::REG_POWER_MODE_CALLBACK), data, reply, option); + if (ret != ERR_OK) { + POWER_HILOGE(MODULE_INNERKIT, "SendRequest is failed, error code: %{public}d", ret); + return; + } +} + +void PowerMgrProxy::UnRegisterPowerModeCallback(const sptr& callback) +{ + sptr remote = Remote(); + RETURN_IF((remote == nullptr) || (callback == nullptr)); + + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) { + POWER_HILOGE(MODULE_INNERKIT, "Write descriptor failed!"); + return; + } + + WRITE_PARCEL_NO_RET(data, RemoteObject, callback->AsObject()); + + int ret = remote->SendRequest(static_cast(IPowerMgr::UNREG_POWER_MODE_CALLBACK), data, reply, option); + if (ret != ERR_OK) { + POWER_HILOGE(MODULE_INNERKIT, "SendRequest is failed, error code: %{public}d", ret); + return; + } +} + +void PowerMgrProxy::SetDeviceMode(const uint32_t& mode) +{ + sptr remote = Remote(); + RETURN_IF(remote == nullptr); + + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s write descriptor failed!", __func__); + return; + } + + WRITE_PARCEL_NO_RET(data, Uint32, mode); + + int ret = remote->SendRequest(static_cast(IPowerMgr::SETMODE_DEVICE), data, reply, option); + if (ret != ERR_OK) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s Transact is failed, error code: %d", __func__, ret); + } +} + +uint32_t PowerMgrProxy::GetDeviceMode() +{ + sptr remote = Remote(); + RETURN_IF_WITH_RET(remote == nullptr, false); + + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s write descriptor failed!", __func__); + return 0; + } + + int ret = remote->SendRequest(static_cast(IPowerMgr::GETMODE_DEVICE), + data, reply, option); + if (ret != ERR_OK) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s SendRequest is failed, error code: %{public}d", __func__, ret); + return 0; + } + + uint32_t used = 0; + if (!reply.ReadUint32(used)) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s Readback fail!", __func__); + } + POWER_HILOGD(MODULE_SERVICE, "PowerMgrStub::GetDeviceMode, cmd = %{public}u.", used); + return used; +} } // namespace PowerMgr } // namespace OHOS diff --git a/services/zidl/src/power_mgr_stub.cpp b/services/zidl/src/power_mgr_stub.cpp index dcab4ce7..283773b5 100644 --- a/services/zidl/src/power_mgr_stub.cpp +++ b/services/zidl/src/power_mgr_stub.cpp @@ -27,7 +27,7 @@ namespace OHOS { namespace PowerMgr { int PowerMgrStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { - POWER_HILOGD(MODULE_SERVICE, "PowerMgrStub::OnRemoteRequest, cmd = %u, flags= %d", code, option.GetFlags()); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrStub::OnRemoteRequest, cmd = %{public}u, flags= %{public}d", code, option.GetFlags()); std::u16string descripter = PowerMgrStub::GetDescriptor(); std::u16string remoteDescripter = data.ReadInterfaceToken(); if (descripter != remoteDescripter) { @@ -96,6 +96,18 @@ int PowerMgrStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessagePar case static_cast(IPowerMgr::UNREG_SHUTDOWN_CALLBACK): { return UnRegisterShutdownCallbackStub(data); } + case static_cast(IPowerMgr::REG_POWER_MODE_CALLBACK): { + return RegisterPowerModeCallbackStub(data); + } + case static_cast(IPowerMgr::UNREG_POWER_MODE_CALLBACK): { + return UnRegisterPowerModeCallbackStub(data); + } + case static_cast(IPowerMgr::SETMODE_DEVICE): { + return SetDeviceModeStub(data); + } + case static_cast(IPowerMgr::GETMODE_DEVICE): { + return GetDeviceModeStub(reply); + } default: { return IPCObjectStub::OnRemoteRequest(code, data, reply, option); } @@ -310,5 +322,45 @@ int32_t PowerMgrStub::UnRegisterShutdownCallbackStub(MessageParcel& data) UnRegisterShutdownCallback(callback); return ERR_OK; } + +int32_t PowerMgrStub::RegisterPowerModeCallbackStub(MessageParcel& data) +{ + sptr obj = data.ReadRemoteObject(); + 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); + RegisterPowerModeCallback(callback); + return ERR_OK; +} + +int32_t PowerMgrStub::UnRegisterPowerModeCallbackStub(MessageParcel& data) +{ + sptr obj = data.ReadRemoteObject(); + 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); + UnRegisterPowerModeCallback(callback); + return ERR_OK; +} + +int32_t PowerMgrStub::SetDeviceModeStub(MessageParcel& data) +{ + uint32_t mode = 0; + READ_PARCEL_WITH_RET(data, Uint32, mode, E_READ_PARCEL_ERROR); + SetDeviceMode(mode); + return ERR_OK; +} + +int32_t PowerMgrStub::GetDeviceModeStub(MessageParcel& reply) +{ + uint32_t ret = 0; + ret = GetDeviceMode(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrStub::GetDeviceModeStub, cmd = %{public}u.", ret); + if (!reply.WriteUint32(static_cast(ret))) { + POWER_HILOGE(MODULE_SERVICE, "PowerMgrStub:: Get device mode Fail!"); + return E_WRITE_PARCEL_ERROR; + } + return ERR_OK; +} } // namespace PowerMgr } // namespace OHOS diff --git a/services/zidl/src/power_mode_callback_proxy.cpp b/services/zidl/src/power_mode_callback_proxy.cpp new file mode 100644 index 00000000..9d51f92f --- /dev/null +++ b/services/zidl/src/power_mode_callback_proxy.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2021 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 "power_mode_callback_proxy.h" + +#include +#include + +#include "power_common.h" +#include "power_mode_callback_stub.h" + +namespace OHOS { +namespace PowerMgr { +void PowerModeCallbackProxy::PowerModeCallback() +{ + sptr remote = Remote(); + RETURN_IF(remote == nullptr); + + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!data.WriteInterfaceToken(PowerModeCallbackProxy::GetDescriptor())) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s write descriptor failed!", __func__); + return; + } + + int ret = remote->SendRequest(static_cast(IPowerModeCallback::POWER_MODE_CHANGED), + data, reply, option); + if (ret != ERR_OK) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s SendRequest is failed, error code: %{private}d", __func__, ret); + } +} +} // namespace PowerMgr +} // namespace OHOS diff --git a/services/zidl/src/power_mode_callback_stub.cpp b/services/zidl/src/power_mode_callback_stub.cpp new file mode 100644 index 00000000..2a082157 --- /dev/null +++ b/services/zidl/src/power_mode_callback_stub.cpp @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2021 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 "power_mode_callback_stub.h" + +#include + +#include "power_common.h" +#include "power_mode_callback_proxy.h" + +namespace OHOS { +namespace PowerMgr { +int PowerModeCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, + MessageOption &option){ + POWER_HILOGD(MODULE_SERVICE, "PowerMgrStub::OnRemoteRequest, cmd = %d, flags= %d", code, option.GetFlags()); + std::u16string descripter = PowerModeCallbackStub::GetDescriptor(); + std::u16string remoteDescripter = data.ReadInterfaceToken(); + if (descripter != remoteDescripter) { + POWER_HILOGE(MODULE_SERVICE, "PowerMgrStub::OnRemoteRequest failed, descriptor is not matched!"); + return E_GET_POWER_SERVICE_FAILED; + } + + switch (code) { + case static_cast(IPowerModeCallback::POWER_MODE_CHANGED): { + return OnPowerModeCallbackStub(); + } + default: + return IPCObjectStub::OnRemoteRequest(code, data, reply, option); + } + return ERR_OK; +} + +int32_t PowerModeCallbackStub::OnPowerModeCallbackStub() +{ + PowerModeCallback(); + return ERR_OK; +} +} // namespace PowerMgr +} // namespace OHOS diff --git a/services/zidl/src/power_shutdown_callback_proxy.cpp b/services/zidl/src/power_shutdown_callback_proxy.cpp new file mode 100644 index 00000000..69315709 --- /dev/null +++ b/services/zidl/src/power_shutdown_callback_proxy.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2021 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 "power_shutdown_callback_proxy.h" + +#include +#include + +#include "power_common.h" +#include "power_shutdown_callback_stub.h" + +namespace OHOS { +namespace PowerMgr { +void PowerShutdownCallbackProxy::ShutdownCallback() +{ + sptr remote = Remote(); + RETURN_IF(remote == nullptr); + + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!data.WriteInterfaceToken(PowerShutdownCallbackProxy::GetDescriptor())) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s write descriptor failed!", __func__); + return; + } + + int ret = remote->SendRequest(static_cast(IShutdownCallback::POWER_SHUTDOWN_CHANGED), + data, reply, option); + if (ret != ERR_OK) { + POWER_HILOGE(MODULE_INNERKIT, "PowerMgrProxy::%{public}s SendRequest is failed, error code: %{private}d", __func__, ret); + } +} +} // namespace PowerMgr +} // namespace OHOS diff --git a/services/zidl/src/power_shutdown_callback_stub.cpp b/services/zidl/src/power_shutdown_callback_stub.cpp new file mode 100644 index 00000000..17ff1fa3 --- /dev/null +++ b/services/zidl/src/power_shutdown_callback_stub.cpp @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2021 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 "power_shutdown_callback_stub.h" + +#include + +#include "power_common.h" +#include "power_shutdown_callback_proxy.h" + +namespace OHOS { +namespace PowerMgr { +int PowerShutdownCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, +MessageOption &option){ + POWER_HILOGD(MODULE_SERVICE, "PowerMgrStub::OnRemoteRequest, cmd = %d, flags= %d", code, option.GetFlags()); + std::u16string descripter = PowerShutdownCallbackStub::GetDescriptor(); + std::u16string remoteDescripter = data.ReadInterfaceToken(); + if (descripter != remoteDescripter) { + POWER_HILOGE(MODULE_SERVICE, "PowerMgrStub::OnRemoteRequest failed, descriptor is not matched!"); + return E_GET_POWER_SERVICE_FAILED; + } + + switch (code) { + case static_cast(IShutdownCallback::POWER_SHUTDOWN_CHANGED): { + return OnPowerShutdownCallbackStub(); + } + default: + return IPCObjectStub::OnRemoteRequest(code, data, reply, option); + } + return ERR_OK; +} + +int32_t PowerShutdownCallbackStub::OnPowerShutdownCallbackStub() +{ + ShutdownCallback(); + return ERR_OK; +} +} // namespace PowerMgr +} // namespace OHOS -- Gitee From ae3ce87a2507fe833620064aa12b56fcd0da3111 Mon Sep 17 00:00:00 2001 From: Du Jiang Date: Fri, 3 Sep 2021 17:03:46 +0800 Subject: [PATCH 07/11] Add automatic test cases and fix bugs The automatic test cases are added based on GTest and GMock. Current platform is not stable so we use mock test for all the cases of service. We fixed bugs based on the result of test. But also failed cases need to fix. Bug fixing is ongoing. We also improve dump function for debug. The JavaScript APIs are reverted as STD definition. JS test is ongoing, and bugs are not fixed yet. Change-Id: I23c357ba6e403b32e7bfe051291c9bfe12b1adad --- .../js => frameworks/napi/power}/BUILD.gn | 76 +- frameworks/napi/power/power.cpp | 191 + frameworks/napi/power_manager_napi.cpp | 418 --- frameworks/napi/power_napi_base.cpp | 159 - frameworks/napi/running_lock_napi.cpp | 259 -- frameworks/napi/runninglock/BUILD.gn | 49 + frameworks/napi/runninglock/runninglock.cpp | 462 +++ .../napi/test/power_manager_unit.test.js | 210 ++ hdi/api/include/power_hdf_client.h | 1 + hdi/api/include/power_hdf_info.h | 1 + hdi/client/src/power_hdf_client.cpp | 13 +- hdi/service/include/power_hdf_service.h | 1 + hdi/service/src/power_hdf_service.cpp | 33 + .../native/include/power_state_machine_info.h | 3 + interfaces/kits/js/@ohos.power.d.ts | 206 +- interfaces/kits/js/@ohos.runninglock.d.ts | 107 + ohos.build | 7 +- .../include/actions/irunning_lock_action.h | 4 +- services/native/include/power_mgr_service.h | 25 + services/native/include/power_state_machine.h | 22 +- services/native/include/running_lock_mgr.h | 20 +- services/native/include/shutdown_service.h | 6 +- .../default/system_suspend_controller.cpp | 5 + .../default/system_suspend_controller.h | 1 + services/native/src/power_mgr_dumper.cpp | 31 +- services/native/src/power_mgr_service.cpp | 146 +- services/native/src/power_state_machine.cpp | 365 +- services/native/src/running_lock_mgr.cpp | 405 ++- services/native/test/unittest/BUILD.gn | 28 + .../unittest/include/power_mgr_mock_test.h | 48 + .../test/unittest/mock/mock_lock_action.h | 37 + .../test/unittest/mock/mock_power_action.h | 34 + .../test/unittest/mock/mock_state_action.h | 40 + .../test/unittest/src/power_mgr_mock_test.cpp | 3090 +++++++++++++++++ test/BUILD.gn | 20 + test/systemtest/BUILD.gn | 74 + .../include/power_mgr_st_mock_test.h | 48 + test/systemtest/mock/mock_lock_action.h | 37 + test/systemtest/mock/mock_power_action.h | 34 + test/systemtest/mock/mock_state_action.h | 40 + .../systemtest/src/power_mgr_st_mock_test.cpp | 2623 ++++++++++++++ 41 files changed, 8098 insertions(+), 1281 deletions(-) rename {interfaces/kits/js => frameworks/napi/power}/BUILD.gn (34%) create mode 100644 frameworks/napi/power/power.cpp delete mode 100644 frameworks/napi/power_manager_napi.cpp delete mode 100644 frameworks/napi/power_napi_base.cpp delete mode 100644 frameworks/napi/running_lock_napi.cpp create mode 100644 frameworks/napi/runninglock/BUILD.gn create mode 100644 frameworks/napi/runninglock/runninglock.cpp create mode 100644 frameworks/napi/test/power_manager_unit.test.js create mode 100644 interfaces/kits/js/@ohos.runninglock.d.ts create mode 100644 services/native/test/unittest/include/power_mgr_mock_test.h create mode 100644 services/native/test/unittest/mock/mock_lock_action.h create mode 100644 services/native/test/unittest/mock/mock_power_action.h create mode 100644 services/native/test/unittest/mock/mock_state_action.h create mode 100644 services/native/test/unittest/src/power_mgr_mock_test.cpp create mode 100644 test/BUILD.gn create mode 100644 test/systemtest/BUILD.gn create mode 100644 test/systemtest/include/power_mgr_st_mock_test.h create mode 100644 test/systemtest/mock/mock_lock_action.h create mode 100644 test/systemtest/mock/mock_power_action.h create mode 100644 test/systemtest/mock/mock_state_action.h create mode 100644 test/systemtest/src/power_mgr_st_mock_test.cpp diff --git a/interfaces/kits/js/BUILD.gn b/frameworks/napi/power/BUILD.gn similarity index 34% rename from interfaces/kits/js/BUILD.gn rename to frameworks/napi/power/BUILD.gn index 89e162ea..25179a37 100644 --- a/interfaces/kits/js/BUILD.gn +++ b/frameworks/napi/power/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (C) 2021 Huawei Device Co., Ltd. +# Copyright (c) 2021 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 @@ -11,65 +11,39 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/ohos.gni") -import("//build/ohos/ace/ace.gni") import("//base/powermgr/power_manager/powermgr.gni") -config("powermgr_private_config") { +config("power_manager_napi_private_config") { include_dirs = [ - "${powermgr_root_path}/frameworks/include", - "${powermgr_service_path}/zidl/include", + "//foundation/ace/napi/native_engine", + "//foundation/ace/napi/interfaces/kits", "//utils/system/safwk/native/include", + "//third_party/node/src", + "//base/powermgr/power_manager/interfaces/innerkits/native/include", + "//foundation/communication/ipc/interfaces/innerkits/ipc_core/include", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + "//foundation/distributedschedule/samgr/adapter/interfaces/innerkits/include", ] } -config("powermgr_public_config") { - include_dirs = [ "native/include" ] -} - -js_declaration("power_js") { - part_name = "${powermgr_native_part_name}" - sources = [ - "./@ohos.power.d.ts", +ohos_shared_library("power") { + sources = [ "power.cpp" ] + configs = [ + "${powermgr_utils_path}:utils_config", + ":power_manager_napi_private_config", ] -} - -ohos_copy("power_declaration") { - sources = [ - "./@ohos.power.d.ts", + deps = [ + "//base/powermgr/power_manager/interfaces/innerkits:powermgr_client", + "//foundation/ace/napi:ace_napi", ] - outputs = [ target_out_dir + "/$target_name/" ] - module_source_dir = target_out_dir + "/$target_name" - module_install_name = "" -} + if (!build_public_version) { + external_deps = [ "hilog_native:libhilog" ] + } else { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } -ohos_shared_library("power") { - configs = [ - "${powermgr_utils_path}:utils_config", - ":powermgr_private_config", - ] - - public_configs = [ ":powermgr_public_config" ] - - sources = [ - "//base/powermgr/power_manager/frameworks/napi/power_napi_base.cpp", - "//base/powermgr/power_manager/frameworks/napi/power_manager_napi.cpp", - "//base/powermgr/power_manager/frameworks/napi/running_lock_napi.cpp", - ] + relative_install_dir = "module" - deps = [ - "//foundation/ace/napi:ace_napi", - "//base/powermgr/power_manager/interfaces/innerkits:powermgr_client", - "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog", - "//utils/native/base:utils" - ] - - external_deps = [ - "ipc:ipc_core", - "hiviewdfx_hilog_native:libhilog", - ] - - relative_install_dir = "module" - part_name = "${powermgr_native_part_name}" - subsystem_name = "powermgr" + subsystem_name = "powermgr" + part_name = "${powermgr_native_part_name}" } diff --git a/frameworks/napi/power/power.cpp b/frameworks/napi/power/power.cpp new file mode 100644 index 00000000..ea1da765 --- /dev/null +++ b/frameworks/napi/power/power.cpp @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2021 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 +#include +#include +#include "hilog_wrapper.h" +#include "napi/native_api.h" +#include "napi/native_node_api.h" +#include "power_mgr_client.h" + +using namespace OHOS::PowerMgr; + +namespace { +constexpr int REASON_MAX = 512; +constexpr int RESULT_SIZE = 2; +} + +struct PowerAsyncCallbackInfo { + napi_env env; + napi_async_work asyncWork = nullptr; + napi_ref callbackRef = nullptr; + napi_deferred deferred = nullptr; + bool screenOn = false; +}; + +static PowerMgrClient &g_powerMgrClient = PowerMgrClient::GetInstance(); + +static napi_value RebootOrShutdown(napi_env env, napi_callback_info info, bool isReboot) +{ + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter, %{public}s", __func__, isReboot ? "reboot" : "shutdown"); + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_value jsthis; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); + NAPI_ASSERT(env, (status == napi_ok) && (argc >= 1), "failed to get cb info"); + napi_valuetype type = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[0], &type)); + NAPI_ASSERT(env, type == napi_string, "wrong argument type. string expected."); + + char reason[REASON_MAX] = { 0 }; + size_t reasonLen = 0; + status = napi_get_value_string_utf8(env, args[0], reason, REASON_MAX - 1, &reasonLen); + if (status != napi_ok) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: get reason failed", __func__); + return nullptr; + } + if (isReboot) { + g_powerMgrClient.RebootDevice(std::string(reason)); + } else { + g_powerMgrClient.ShutDownDevice(std::string(reason)); + } + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: reason %{public}s, exit", __func__, reason); + return nullptr; +} + +static napi_value ShutdownDevice(napi_env env, napi_callback_info info) +{ + return RebootOrShutdown(env, info, false); +} + +static napi_value RebootDevice(napi_env env, napi_callback_info info) +{ + return RebootOrShutdown(env, info, true); +} + +static void IsScreenOnCallBack(napi_env env, PowerAsyncCallbackInfo *asyncCallbackInfo) +{ + napi_value resource = nullptr; + napi_create_string_utf8(env, "IsScreenOn", NAPI_AUTO_LENGTH, &resource); + napi_create_async_work( + env, + nullptr, + resource, + [](napi_env env, void *data) { + PowerAsyncCallbackInfo *asyncCallbackInfo = (PowerAsyncCallbackInfo *)data; + asyncCallbackInfo->screenOn = g_powerMgrClient.IsScreenOn(); + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: screen is %{public}s ", __func__, + asyncCallbackInfo->screenOn ? "on" : "off"); + }, + [](napi_env env, napi_status status, void *data) { + PowerAsyncCallbackInfo *asyncCallbackInfo = (PowerAsyncCallbackInfo *)data; + napi_value result[RESULT_SIZE] = { 0 }; + napi_get_boolean(env, asyncCallbackInfo->screenOn, &result[1]); + if (asyncCallbackInfo->deferred) { + napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]); + } else { + napi_value tmp = nullptr; + napi_value callback = nullptr; + napi_get_reference_value(env, asyncCallbackInfo->callbackRef, &callback); + napi_get_undefined(env, &result[0]); + napi_call_function(env, nullptr, callback, RESULT_SIZE, result, &tmp); + napi_delete_reference(env, asyncCallbackInfo->callbackRef); + } + napi_delete_async_work(env, asyncCallbackInfo->asyncWork); + delete asyncCallbackInfo; + }, + (void *)asyncCallbackInfo, + &asyncCallbackInfo->asyncWork); + napi_queue_async_work(env, asyncCallbackInfo->asyncWork); +} + +static napi_value IsScreenOn(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter", __func__); + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_value jsthis; + void *data = nullptr; + + auto asyncCallbackInfo = new PowerAsyncCallbackInfo(); + if (asyncCallbackInfo == nullptr) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: new asyncCallbackInfo failed", __func__); + return nullptr; + } + asyncCallbackInfo->env = env; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); + NAPI_ASSERT(env, (status == napi_ok), "IsScreenOn: failed to get cb info"); + napi_valuetype type; + if (argc == 1) { + NAPI_CALL(env, napi_typeof(env, args[0], &type)); + NAPI_ASSERT(env, type == napi_function, "IsScreenOn: wrong argument type. napi_function expected."); + napi_create_reference(env, args[0], 1, &asyncCallbackInfo->callbackRef); + } + napi_value result = nullptr; + if (asyncCallbackInfo->callbackRef == nullptr) { + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: callbackRef is null", __func__); + napi_create_promise(env, &asyncCallbackInfo->deferred, &result); + } else { + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: callbackRef is not null", __func__); + napi_get_undefined(env, &result); + } + IsScreenOnCallBack(env, asyncCallbackInfo); + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: exit", __func__); + return result; +} + +EXTERN_C_START +/* + * function for module exports + */ +static napi_value PowerInit(napi_env env, napi_value exports) +{ + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter", __func__); + napi_property_descriptor desc[] = { + DECLARE_NAPI_FUNCTION("shutdownDevice", ShutdownDevice), + DECLARE_NAPI_FUNCTION("rebootDevice", RebootDevice), + DECLARE_NAPI_FUNCTION("isScreenOn", IsScreenOn), + }; + NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: exit", __func__); + + return exports; +} +EXTERN_C_END + +/* + * Module definition + */ +static napi_module g_module = { + .nm_version = 1, + .nm_flags = 0, + .nm_filename = "power", + .nm_register_func = PowerInit, + .nm_modname = "power", + .nm_priv = ((void *)0), + .reserved = {0} +}; + +/* + * Module registration + */ +extern "C" __attribute__((constructor)) void RegisterPowerModule(void) +{ + napi_module_register(&g_module); +} \ No newline at end of file diff --git a/frameworks/napi/power_manager_napi.cpp b/frameworks/napi/power_manager_napi.cpp deleted file mode 100644 index 16476f82..00000000 --- a/frameworks/napi/power_manager_napi.cpp +++ /dev/null @@ -1,418 +0,0 @@ -/* - * Copyright (c) 2021 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 "power_manager_napi.h" - -#include -#include -#include -#include -#include "power_common.h" -#include "running_lock_napi.h" - -using namespace OHOS::PowerMgr; - -static const uint8_t ARG_0 = 0; -static const uint8_t ARG_1 = 1; -static const uint8_t ARG_2 = 2; -static const uint8_t ARG_3 = 3; -static const uint8_t REASON_STRING_MAX = 128; -static const uint8_t LOCK_NAME_STRING_MAX = 128; - -napi_ref PowerManagerNapi::runningLockTypeConstructor_ = nullptr; -napi_ref PowerManagerNapi::powerStateConstructor_ = nullptr; -napi_ref PowerManagerNapi::powerModeConstructor_ = nullptr; - -void ShutdownContext::Init(napi_value* args, uint32_t argc) -{ - if (argc < 1) { - return; - } - size_t out; - char reason[REASON_STRING_MAX]; - napi_get_value_string_latin1(env_, args[ARG_0], reason, REASON_STRING_MAX, &out); - reason_.copy(reason, strlen(reason), 0); -} - -napi_value PowerManagerNapi::Init(napi_env env, napi_value exports) -{ - napi_property_descriptor desc[] = { - DECLARE_NAPI_STATIC_FUNCTION("isRunningLockTypeSupported", IsRunningLockTypeSupported), - DECLARE_NAPI_STATIC_FUNCTION("createRunningLock", CreateRunningLock), - DECLARE_NAPI_STATIC_FUNCTION("shutownDevice", ShutdownDevice), - DECLARE_NAPI_STATIC_FUNCTION("rebootDevice", RebootDevice), - DECLARE_NAPI_STATIC_FUNCTION("isScreenOn", IsScreenOn), - DECLARE_NAPI_STATIC_FUNCTION("getState", GetState), - DECLARE_NAPI_STATIC_FUNCTION("getMode", GetMode), - }; - NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); - - RunningLockNapi::InitRunningLockClass(env, exports); - PowerManagerNapi::InitRunningLockType(env, exports); - PowerManagerNapi::InitPowerState(env, exports); - PowerManagerNapi::InitPowerMode(env, exports); - - return exports; -} - -napi_value PowerManagerNapi::IsRunningLockTypeSupported(napi_env env, napi_callback_info info) -{ - POWER_HILOGD(MODULE_JS_NAPI, "enter"); - size_t argc = ARG_2; - napi_value args[ARG_2] = { 0 }; - napi_value jsthis; - void *data = nullptr; - uint32_t result; - - napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - NAPI_ASSERT(env, (status == napi_ok) && (argc >= ARG_2 - 1), "Not enough parameters"); - - napi_valuetype type; - NAPI_CALL(env, napi_typeof(env, args[ARG_0], &type)); - NAPI_ASSERT(env, type == napi_number, "Wrong type of 1st parameter. number expected."); - - napi_get_value_uint32(env, args[ARG_0], &result); - - PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_2 - 1); - - napi_value promise = context->GetPromise(); - context->StartAsyncWork("Power::IsRunningLockTypeSupported", - [context, result] { - bool ret = PowerMgrClient::GetInstance().IsRunningLockTypeSupported(result); - napi_get_boolean(context->env_, ret, &context->outValue_); - return true; - }, - [](PowerNapiContext* object) { delete object; } - ); - - POWER_HILOGD(MODULE_JS_NAPI, "return"); - return promise; -} - -napi_value PowerManagerNapi::CreateRunningLock(napi_env env, napi_callback_info info) -{ - POWER_HILOGD(MODULE_JS_NAPI, "enter"); - size_t argc = ARG_3; - napi_value args[ARG_3] = { 0 }; - napi_value jsthis; - void *data = nullptr; - - napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - NAPI_ASSERT(env, (status == napi_ok) && (argc >= 2), "Not enough parameters"); - - napi_valuetype type; - NAPI_CALL(env, napi_typeof(env, args[ARG_0], &type)); - NAPI_ASSERT(env, type == napi_string, "Wrong type of 1st parameter. string expected."); - NAPI_CALL(env, napi_typeof(env, args[ARG_1], &type)); - NAPI_ASSERT(env, type == napi_number, "Wrong type of 2st parameter. number expected."); - - char name[LOCK_NAME_STRING_MAX]; - size_t size; - napi_get_value_string_latin1(env, args[ARG_0], name, LOCK_NAME_STRING_MAX, &size); - uint32_t lockType; - napi_get_value_uint32(env, args[1], &lockType); - NAPI_ASSERT(env, lockType < static_cast(RunningLockType::RUNNINGLOCK_BUTT), - "RunningLock Type is not supported"); - - PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_3 - 1); - - napi_value promise = context->GetPromise(); - context->StartAsyncWork("Power::CreateRunningLock", - [env, info, context] { - return RunningLockNapi::CreateRunningLock(env, info, - &context->outValue_, &context->outError_); - }, - [](PowerNapiContext* object) { delete object; } - ); - - POWER_HILOGD(MODULE_JS_NAPI, "return"); - return promise; -} - -napi_value PowerManagerNapi::ShutdownDevice(napi_env env, napi_callback_info info) -{ - POWER_HILOGD(MODULE_JS_NAPI, "enter"); - uint32_t argc = ARG_2; - napi_value args[ARG_2] = { 0 }; - napi_value jsthis; - void *data = nullptr; - - napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - NAPI_ASSERT(env, (status == napi_ok) && (argc >= ARG_1), "Not enough parameters"); - - napi_valuetype type; - NAPI_CALL(env, napi_typeof(env, args[ARG_0], &type)); - NAPI_ASSERT(env, type == napi_string, "Wrong argument type. string expected."); - - ShutdownContext* context = new ShutdownContext(env, args, argc, ARG_2 - 1); - - napi_value promise = context->GetPromise(); - context->StartAsyncWork("Power::ShutdownDevice", - [context] { - PowerMgrClient::GetInstance().ShutDownDevice(context->reason_); - return true; - }, - [](PowerNapiContext* object) { delete object; } - ); - - POWER_HILOGD(MODULE_JS_NAPI, "return"); - return promise; -} - -napi_value PowerManagerNapi::RebootDevice(napi_env env, napi_callback_info info) -{ - POWER_HILOGD(MODULE_JS_NAPI, "enter"); - uint32_t argc = ARG_2; - napi_value args[ARG_2] = { 0 }; - napi_value jsthis; - void *data = nullptr; - - napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - NAPI_ASSERT(env, (status == napi_ok) && (argc >= 1), "Not enough parameters"); - - napi_valuetype type; - NAPI_CALL(env, napi_typeof(env, args[0], &type)); - NAPI_ASSERT(env, type == napi_string, "Wrong argument type. string expected."); - - ShutdownContext* context = new ShutdownContext(env, args, argc, ARG_2 - 1); - - napi_value promise = context->GetPromise(); - context->StartAsyncWork("Power::RebootDevice", - [context] { - PowerMgrClient::GetInstance().RebootDevice(context->reason_); - return true; - }, - [](PowerNapiContext* object) { delete object; } - ); - - POWER_HILOGD(MODULE_JS_NAPI, "return"); - return promise; -} - -napi_value PowerManagerNapi::IsScreenOn(napi_env env, napi_callback_info info) -{ - POWER_HILOGD(MODULE_JS_NAPI, "enter"); - size_t argc = ARG_1; - napi_value args[ARG_1] = { 0 }; - napi_value jsthis; - void *data = nullptr; - - napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - NAPI_ASSERT(env, (status == napi_ok) && (argc >= 0), "Bad parameters"); - - PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_1 - 1); - - napi_value promise = context->GetPromise(); - context->StartAsyncWork("Power::IsScreenOn", - [context] { - bool ret = PowerMgrClient::GetInstance().IsScreenOn(); - napi_get_boolean(context->env_, ret, &context->outValue_); - return true; - }, - [](PowerNapiContext* object) { delete object; } - ); - - POWER_HILOGD(MODULE_JS_NAPI, "return"); - return promise; -} - -napi_value PowerManagerNapi::GetState(napi_env env, napi_callback_info info) -{ - POWER_HILOGD(MODULE_JS_NAPI, "enter"); - size_t argc = ARG_1; - napi_value args[ARG_1] = { 0 }; - napi_value jsthis; - void *data = nullptr; - - napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - NAPI_ASSERT(env, (status == napi_ok) && (argc >= 0), "Bad parameters"); - - PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_1 - 1); - - napi_value promise = context->GetPromise(); - context->StartAsyncWork("Power::GetState", - [context] { - PowerState state = PowerMgrClient::GetInstance().GetState(); - napi_create_uint32(context->env_, static_cast(state), &context->outValue_); - return true; - }, - [](PowerNapiContext* object) { delete object; } - ); - - POWER_HILOGD(MODULE_JS_NAPI, "return"); - return promise; -} - -napi_value PowerManagerNapi::GetMode(napi_env env, napi_callback_info info) -{ - POWER_HILOGD(MODULE_JS_NAPI, "enter"); - size_t argc = ARG_1; - napi_value args[ARG_1] = { 0 }; - napi_value jsthis; - void *data = nullptr; - napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - NAPI_ASSERT(env, (status == napi_ok) && (argc >= 0), "Bad parameters"); - PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_1 - 1); - napi_value promise = context->GetPromise(); - context->StartAsyncWork("Power::GetState", - [context] { - uint32_t mode = PowerMgrClient::GetInstance().GetDeviceMode(); - napi_create_uint32(context->env_, mode, &context->outValue_); - return true; - }, - [context](PowerNapiContext* object) { delete context; } - ); - POWER_HILOGD(MODULE_JS_NAPI, "return"); - return promise; -} - -napi_value PowerManagerNapi::InitRunningLockType(napi_env env, napi_value exports) -{ - napi_value background; - napi_value proximity; - int32_t refCount = 1; - - napi_create_uint32(env, static_cast(RunningLockType::RUNNINGLOCK_BACKGROUND), &background); - napi_create_uint32(env, static_cast(RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL), &proximity); - - napi_property_descriptor desc[] = { - DECLARE_NAPI_STATIC_PROPERTY("BACKGROUND", background), - DECLARE_NAPI_STATIC_PROPERTY("PROXIMITY_SCREEN_CONTROL", proximity), - }; - - napi_value result = nullptr; - napi_define_class(env, "RunningLockType", NAPI_AUTO_LENGTH, EnumRunningLockTypeConstructor, nullptr, - sizeof(desc) / sizeof(*desc), desc, &result); - napi_create_reference(env, result, refCount, &runningLockTypeConstructor_); - napi_set_named_property(env, exports, "RunningLockType", result); - - return exports; -} - -napi_value PowerManagerNapi::InitPowerState(napi_env env, napi_value exports) -{ - napi_value awake; - napi_value inactive; - napi_value sleep; - int32_t refCount = 1; - - napi_create_uint32(env, static_cast(PowerState::AWAKE), &awake); - napi_create_uint32(env, static_cast(PowerState::INACTIVE), &inactive); - napi_create_uint32(env, static_cast(PowerState::SLEEP), &sleep); - - napi_property_descriptor desc[] = { - DECLARE_NAPI_STATIC_PROPERTY("AWAKE", awake), - DECLARE_NAPI_STATIC_PROPERTY("INACTIVE", inactive), - DECLARE_NAPI_STATIC_PROPERTY("SLEEP", sleep), - }; - - napi_value result = nullptr; - napi_define_class(env, "PowerState", NAPI_AUTO_LENGTH, EnumPowerStateConstructor, nullptr, - sizeof(desc) / sizeof(*desc), desc, &result); - napi_create_reference(env, result, refCount, &powerStateConstructor_); - napi_set_named_property(env, exports, "PowerState", result); - - return exports; -} - -napi_value PowerManagerNapi::InitPowerMode(napi_env env, napi_value exports) -{ - napi_value normal; - napi_value power_save; - int32_t refCount = 1; - - napi_create_uint32(env, 0, &normal); - napi_create_uint32(env, 1, &power_save); - - napi_property_descriptor desc[] = { - DECLARE_NAPI_STATIC_PROPERTY("NORMAL", normal), - DECLARE_NAPI_STATIC_PROPERTY("POWER_SAVE", power_save), - }; - - napi_value result = nullptr; - napi_define_class(env, "PowerMode", NAPI_AUTO_LENGTH, EnumPowerModeConstructor, nullptr, - sizeof(desc) / sizeof(*desc), desc, &result); - napi_create_reference(env, result, refCount, &powerModeConstructor_); - napi_set_named_property(env, exports, "PowerMode", result); - - return exports; -} - -napi_value PowerManagerNapi::EnumRunningLockTypeConstructor(napi_env env, napi_callback_info info) -{ - napi_value thisArg = nullptr; - void *data = nullptr; - - napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data); - - return thisArg; -} - -napi_value PowerManagerNapi::EnumPowerStateConstructor(napi_env env, napi_callback_info info) -{ - napi_value thisArg = nullptr; - void *data = nullptr; - - napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data); - - return thisArg; -} - -napi_value PowerManagerNapi::EnumPowerModeConstructor(napi_env env, napi_callback_info info) -{ - napi_value thisArg = nullptr; - void *data = nullptr; - - napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data); - - return thisArg; -} - -EXTERN_C_START -/* - * function for module exports - */ -static napi_value PowerInit(napi_env env, napi_value exports) -{ - POWER_HILOGD(MODULE_JS_NAPI, "enter"); - - napi_value ret = PowerManagerNapi::Init(env, exports); - - POWER_HILOGD(MODULE_JS_NAPI, "return"); - - return ret; -} -EXTERN_C_END - -/* - * Module definition - */ -static napi_module g_module = { - .nm_version = 1, - .nm_flags = 0, - .nm_filename = "power", - .nm_register_func = PowerInit, - .nm_modname = "power", - .nm_priv = ((void *)0), - .reserved = {0} -}; - -/* - * Module registration - */ -extern "C" __attribute__((constructor)) void RegisterModule(void) -{ - napi_module_register(&g_module); -} diff --git a/frameworks/napi/power_napi_base.cpp b/frameworks/napi/power_napi_base.cpp deleted file mode 100644 index eeb5f7ef..00000000 --- a/frameworks/napi/power_napi_base.cpp +++ /dev/null @@ -1,159 +0,0 @@ -/* - * Copyright (c) 2021 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 "power_napi_base.h" - -#include "power_common.h" - -using namespace OHOS::PowerMgr; - -#define CALLBACK_ARG_0 (0) -#define CALLBACK_ARG_1 (1) -#define CALLBACK_ARGS_COUNT (2) - -PowerNapiContext::PowerNapiContext(napi_env env, napi_value* args, uint32_t argc, - int32_t callbackArg, napi_value object) - : env_(env), object_(object), - deferred_(nullptr), callbackRef_(nullptr), asyncWork_(nullptr), status_(AsyncStatus::PENDING) -{ - POWER_HILOGE(MODULE_INNERKIT, "%{public}s called.", __func__); - if (callbackArg >= 0 && callbackArg < static_cast(argc)) { - napi_valuetype valueType = napi_undefined; - napi_typeof(env, args[callbackArg], &valueType); - if (valueType == napi_function) { - napi_create_reference(env, args[callbackArg], 1, &callbackRef_); - } - } - if (callbackRef_ == nullptr) { - napi_create_promise(env, &deferred_, &promise_); - } else { - napi_get_undefined(env, &promise_); - } - if (object_ == nullptr) { - napi_get_global(env, &object_); - } - napi_get_undefined(env_, &outValue_); - napi_get_undefined(env_, &outError_); - Init(args, argc); -} - -PowerNapiContext::~PowerNapiContext() -{ - if (deferred_) { - deferred_ = NULL; - } - if (callbackRef_) { - napi_delete_reference(env_, callbackRef_); - } - if (asyncWork_) { - napi_delete_async_work(env_, asyncWork_); - } -} - -void PowerNapiContext::ExecuteAsyncWork(napi_env env, void *data) -{ - PowerNapiContext* context = (PowerNapiContext*)data; - if (context->exeFunc_) { - bool ret = context->exeFunc_(); - POWER_HILOGI(MODULE_JS_NAPI, "execute work: %d", ret); - if (ret) { - context->status_ = AsyncStatus::RESOLVED; - } else { - context->status_ = AsyncStatus::REJECTED; - } - } else { - POWER_HILOGW(MODULE_JS_NAPI, "execute work: no exeFunc"); - context->status_ = AsyncStatus::REJECTED; - } -} - -void PowerNapiContext::CompleteAsyncWork(napi_env env, napi_status status, void *data) -{ - PowerNapiContext* context = (PowerNapiContext*)data; - - if (context->deferred_) { - if (context->status_ == AsyncStatus::RESOLVED) { - POWER_HILOGI(MODULE_JS_NAPI, "work complete: resolved"); - napi_resolve_deferred(env, context->deferred_, context->GetValue()); - } else { - POWER_HILOGI(MODULE_JS_NAPI, "work complete: rejected"); - napi_reject_deferred(env, context->deferred_, context->GetError()); - } - context->deferred_ = nullptr; - } else if (context->callbackRef_) { - POWER_HILOGI(MODULE_JS_NAPI, "work complete: callback"); - napi_value result = 0; - napi_value callback = nullptr; - napi_get_reference_value(env, context->callbackRef_, &callback); - napi_value values[CALLBACK_ARGS_COUNT]; - - values[CALLBACK_ARG_0] = context->GetError(); - values[CALLBACK_ARG_1] = context->GetValue(); - - napi_call_function(env, context->object_, callback, context->cbParamCount_, values, &result); - napi_delete_reference(env, context->callbackRef_); - context->callbackRef_ = nullptr; - } else { - POWER_HILOGE(MODULE_JS_NAPI, "work complete: nothing"); - } - napi_delete_async_work(env, context->asyncWork_); - context->asyncWork_ = nullptr; - if (context->freeFunc_) { - context->freeFunc_(context); - } -} - -bool PowerNapiContext::StartAsyncWork(const char* workName, ExecuteFunc exeFunc, FreeFunc freeFunc) -{ - napi_status status; - - napi_value resourceName; - napi_create_string_latin1(this->env_, workName, NAPI_AUTO_LENGTH, &resourceName); - - exeFunc_ = exeFunc; - freeFunc_ = freeFunc; - - status = napi_create_async_work( - this->env_, - nullptr, - resourceName, - ExecuteAsyncWork, - CompleteAsyncWork, - (void *)this, - &asyncWork_); - - if (status != napi_ok) { - POWER_HILOGE(MODULE_JS_NAPI, "CreateAsyncWork failed: %d", status); - return false; - } - napi_queue_async_work(this->env_, asyncWork_); - - return true; -} - -void PowerNapiContext::Init(napi_value* args, uint32_t argc) -{ - // do nothing in base class -} - -napi_value PowerNapiContext::GetValue() -{ - return outValue_; -} - -napi_value PowerNapiContext::GetError() -{ - return outError_; -} \ No newline at end of file diff --git a/frameworks/napi/running_lock_napi.cpp b/frameworks/napi/running_lock_napi.cpp deleted file mode 100644 index a90f1186..00000000 --- a/frameworks/napi/running_lock_napi.cpp +++ /dev/null @@ -1,259 +0,0 @@ -/* - * Copyright (c) 2021 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 "running_lock_napi.h" - -#include -#include -#include -#include "power_common.h" - -using namespace OHOS::PowerMgr; - -static const uint8_t ARG_0 = 0; -static const uint8_t ARG_1 = 1; -static const uint8_t ARG_2 = 2; -static const uint8_t ARG_3 = 3; -static const uint8_t LOCK_NAME_STRING_MAX = 128; - -napi_ref RunningLockNapi::runningLockConstructor_ = nullptr; - -napi_value RunningLockNapi::InitRunningLockClass(napi_env env, napi_value exports) -{ - int32_t refCount = 1; - napi_property_descriptor desc[] = { - DECLARE_NAPI_FUNCTION("lock", Lock), - DECLARE_NAPI_FUNCTION("isUsed", IsUsed), - DECLARE_NAPI_FUNCTION("unlock", Unlock), - }; - napi_value result = nullptr; - napi_define_class(env, "RunningLock", NAPI_AUTO_LENGTH, ConstructRunningLockObject, nullptr, - sizeof(desc) / sizeof(*desc), desc, &result); - napi_create_reference(env, result, refCount, &runningLockConstructor_); - napi_set_named_property(env, exports, "RunningLock", result); - - return exports; -} - -bool RunningLockNapi::CreateRunningLock(napi_env env, napi_callback_info info, - napi_value* result, napi_value* error) -{ - POWER_HILOGD(MODULE_JS_NAPI, "enter"); - - napi_value constructor; - size_t argc = ARG_2; - napi_value args[ARG_2] = { 0 }; - napi_value jsthis = nullptr; - void *data = nullptr; - - napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - if (argc < ARG_2) { - return false; - } - - napi_get_reference_value(env, runningLockConstructor_, &constructor); - status = napi_new_instance(env, constructor, argc, args, result); - if (status != napi_ok) { - const char* errMsg = "Can't create JS instance"; - napi_create_string_utf8(env, errMsg, strlen(errMsg), error); - return false; - } - - char name[LOCK_NAME_STRING_MAX]; - size_t out; - napi_get_value_string_latin1(env, args[ARG_0], name, sizeof(LOCK_NAME_STRING_MAX), &out); - std::string nameStr = name; - - uint32_t type; - napi_get_value_uint32(env, args[ARG_1], &type); - - std::shared_ptr lock = PowerMgrClient::GetInstance() - .CreateRunningLock(nameStr, static_cast(type)); - if (lock == nullptr) { - const char* errMsg = "Can't create running lock from service"; - napi_create_string_utf8(env, errMsg, strlen(errMsg), error); - return false; - } - - RunningLockWrapper* wrapper = new RunningLockWrapper(lock); - status = napi_wrap(env, *result, reinterpret_cast(wrapper), - RemoveRunningLock, nullptr, nullptr); - if (status != napi_ok) { - const char* errMsg = "Can't wrap native lock"; - napi_create_string_utf8(env, errMsg, strlen(errMsg), error); - delete wrapper; - return false; - } - - return true; -} - -napi_value RunningLockNapi::Lock(napi_env env, napi_callback_info info) -{ - size_t argc = ARG_2; - napi_value args[ARG_2] = { 0 }; - napi_value jsthis; - void *data = nullptr; - uint32_t timeout = 0; - PowerNapiContext* context; - - napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - NAPI_ASSERT(env, status == napi_ok, "Failed to get parameters"); - - RunningLockWrapper* wrapper = nullptr; - bool success = GetNativeLock(env, jsthis, &wrapper); - NAPI_ASSERT(env, success == true, "This object is not created by PowerManager"); - - if (argc >= ARG_1) { - napi_valuetype type; - NAPI_CALL(env, napi_typeof(env, args[0], &type)); - if (type == napi_number) { - napi_get_value_uint32(env, args[0], &timeout); - context = new PowerNapiContext(env, args, argc, ARG_2 - 1, jsthis); - } else if (type == napi_function) { - context = new PowerNapiContext(env, args, argc, ARG_1 - 1, jsthis); - } else { - context = new PowerNapiContext(env, args, argc, -1, jsthis); - } - } else { - context = new PowerNapiContext(env, args, argc, -1, jsthis); - } - - napi_value promise = context->GetPromise(); - context->StartAsyncWork("RunningLock::Lock", - [context, env, wrapper, timeout] { - ErrCode ret = wrapper->lock_ptr->Lock(timeout); - if (ret != ERR_OK) { - const char* errMsg = "Native lock failed"; - napi_create_string_utf8(env, errMsg, strlen(errMsg), &context->outError_); - return false; - } else { - return true; - } - }, - [](PowerNapiContext* object) { delete object; } - ); - - return promise; -} - -napi_value RunningLockNapi::IsUsed(napi_env env, napi_callback_info info) -{ - size_t argc = ARG_1; - napi_value args[ARG_1] = { 0 }; - napi_value jsthis; - void *data = nullptr; - - napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - NAPI_ASSERT(env, status == napi_ok, "Failed to get parameters"); - - RunningLockWrapper* wrapper = nullptr; - bool success = GetNativeLock(env, jsthis, &wrapper); - NAPI_ASSERT(env, success == true, "This object is not created by PowerManager"); - - PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_0, jsthis); - - napi_value promise = context->GetPromise(); - context->StartAsyncWork("RunningLock::IsUsed", - [context, wrapper] { - bool ret = wrapper->lock_ptr->IsUsed(); - napi_get_boolean(context->env_, ret, &context->outValue_); - return true; - }, - [](PowerNapiContext* object) { delete object; } - ); - - return promise; -} - -napi_value RunningLockNapi::Unlock(napi_env env, napi_callback_info info) -{ - size_t argc = ARG_1; - napi_value args[ARG_1] = { 0 }; - napi_value jsthis; - void *data = nullptr; - - napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - NAPI_ASSERT(env, status == napi_ok, "Failed to get parameters"); - - RunningLockWrapper* wrapper = nullptr; - bool success = GetNativeLock(env, jsthis, &wrapper); - NAPI_ASSERT(env, success == true, "This object is not created by PowerManager"); - - PowerNapiContext* context = new PowerNapiContext(env, args, argc, ARG_0, jsthis); - - napi_value promise = context->GetPromise(); - context->StartAsyncWork("RunningLock::Unlock", - [context, env, wrapper] { - ErrCode ret = wrapper->lock_ptr->UnLock(); - if (ret != ERR_OK) { - const char* errMsg = "Native unlock failed"; - napi_create_string_utf8(env, errMsg, strlen(errMsg), &context->outError_); - return false; - } else { - return true; - } - }, - [](PowerNapiContext* object) { delete object; } - ); - - return promise; -} - -void RunningLockNapi::RemoveRunningLock(napi_env env, void* finalize_data, void* finalize_hint) -{ - RunningLockWrapper* wrapper = reinterpret_cast(finalize_data); - delete wrapper; -} - -napi_value RunningLockNapi::ConstructRunningLockObject(napi_env env, napi_callback_info info) -{ - size_t argc = 0; - napi_value args[ARG_3] = { 0 }; - napi_value jsthis = nullptr; - void *data = nullptr; - - napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data); - if (status != napi_ok) { - return nullptr; - } - - return jsthis; -} - -bool RunningLockNapi::GetNativeLock(napi_env env, napi_value object, RunningLockWrapper** lock) -{ - napi_value constructor = nullptr; - bool is_instance = false; - void* result = nullptr; - - napi_status status = napi_get_reference_value(env, runningLockConstructor_, &constructor); - if (status != napi_ok) { - return false; - } - - status = napi_instanceof(env, object, constructor, &is_instance); - if (status != napi_ok || !is_instance) { - return false; - } - - status = napi_unwrap(env, object, &result); - if (status != napi_ok) { - return false; - } - - *lock = reinterpret_cast(result); - return true; -} diff --git a/frameworks/napi/runninglock/BUILD.gn b/frameworks/napi/runninglock/BUILD.gn new file mode 100644 index 00000000..199ebb00 --- /dev/null +++ b/frameworks/napi/runninglock/BUILD.gn @@ -0,0 +1,49 @@ +# Copyright (c) 2021 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. + +import("//base/powermgr/power_manager/powermgr.gni") + +config("power_manager_napi_private_config") { + include_dirs = [ + "//foundation/ace/napi/native_engine", + "//foundation/ace/napi/interfaces/kits", + "//utils/system/safwk/native/include", + "//third_party/node/src", + "//base/powermgr/power_manager/interfaces/innerkits/native/include", + "//foundation/communication/ipc/interfaces/innerkits/ipc_core/include", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + "//foundation/distributedschedule/samgr/adapter/interfaces/innerkits/include", + ] +} + +ohos_shared_library("runninglock") { + sources = [ "runninglock.cpp" ] + configs = [ + "${powermgr_utils_path}:utils_config", + ":power_manager_napi_private_config", + ] + deps = [ + "//base/powermgr/power_manager/interfaces/innerkits:powermgr_client", + "//foundation/ace/napi:ace_napi", + ] + if (!build_public_version) { + external_deps = [ "hilog_native:libhilog" ] + } else { + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + } + + relative_install_dir = "module" + + subsystem_name = "powermgr" + part_name = "${powermgr_native_part_name}" +} diff --git a/frameworks/napi/runninglock/runninglock.cpp b/frameworks/napi/runninglock/runninglock.cpp new file mode 100644 index 00000000..52353b6b --- /dev/null +++ b/frameworks/napi/runninglock/runninglock.cpp @@ -0,0 +1,462 @@ +/* + * Copyright (c) 2021 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 +#include +#include +#include "hilog_wrapper.h" +#include "napi/native_api.h" +#include "napi/native_node_api.h" +#include "power_mgr_client.h" +#include "running_lock_info.h" + +using namespace OHOS::PowerMgr; + +namespace { +constexpr int RESULT_SIZE = 2; +constexpr int RUNNINGLOCK_NAME_MAX = 512; +constexpr int CREATRUNNINGLOCK_ARGC = 3; +constexpr int ISRUNNINGLOCKTYPESUPPORTED_ARGC = 2; +} + +struct RunningLockAsyncCallbackInfo { + napi_env env; + napi_async_work asyncWork = nullptr; + napi_ref callbackRef = nullptr; + napi_deferred deferred = nullptr; + char name[RUNNINGLOCK_NAME_MAX] = { 0 }; + size_t nameLen = 0; + RunningLockType type = RunningLockType::RUNNINGLOCK_BUTT; + bool isSupported = false; + std::shared_ptr runningLock = nullptr; +}; + +struct RunningLockEntity { + std::shared_ptr runningLock; +}; + +static napi_ref g_runningLockConstructor; +static PowerMgrClient &g_powerMgrClient = PowerMgrClient::GetInstance(); + +static napi_value Unlock(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter", __func__); + napi_value thisArg = nullptr; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data); + NAPI_ASSERT(env, (status == napi_ok), "Unlock: failed to get cb info"); + + RunningLockEntity *entity = nullptr; + status = napi_unwrap(env, thisArg, (void **)&entity); + if (status != napi_ok) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: cannot unwrap for pointer", __func__); + return nullptr; + } + if (entity == nullptr || entity->runningLock == nullptr) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: entity->runningLock is nullptr", __func__); + return nullptr; + } + entity->runningLock->UnLock(); + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: exit", __func__); + return nullptr; +} + +static napi_value IsUsed(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter", __func__); + napi_value thisArg = nullptr; + napi_value result = nullptr; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data); + NAPI_ASSERT(env, (status == napi_ok), "IsUsed: failed to get cb info"); + napi_get_boolean(env, false, &result); + RunningLockEntity *entity = nullptr; + status = napi_unwrap(env, thisArg, (void **)&entity); + if (status != napi_ok) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: cannot unwrap for pointer", __func__); + return result; + } + if (entity == nullptr || entity->runningLock == nullptr) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: entity->runningLock is nullptr", __func__); + return result; + } + bool isUsed = entity->runningLock->IsUsed(); + napi_get_boolean(env, isUsed, &result); + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: exit", __func__); + return result; +} + +static napi_value Lock(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter", __func__); + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_value thisArg = nullptr; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, args, &thisArg, &data); + NAPI_ASSERT(env, (status == napi_ok) && (argc >= 1), "Lock: failed to get cb info"); + napi_valuetype type = napi_undefined; + NAPI_CALL(env, napi_typeof(env, args[0], &type)); + NAPI_ASSERT(env, type == napi_number, "Lock: wrong argument type. number expected."); + + uint32_t timeOut; + status = napi_get_value_uint32(env, args[0], &timeOut); + if (status != napi_ok) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: napi_get_value_uint32 failed", __func__); + return nullptr; + } + RunningLockEntity *entity = nullptr; + status = napi_unwrap(env, thisArg, (void **)&entity); + if (status != napi_ok) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: cannot unwrap for pointer", __func__); + return nullptr; + } + if (entity == nullptr || entity->runningLock == nullptr) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: entity->runningLock is nullptr", __func__); + return nullptr; + } + entity->runningLock->Lock(timeOut); + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: exit", __func__); + return nullptr; +} + +static napi_value CreateInstanceForRunningLock(napi_env env, RunningLockAsyncCallbackInfo *asyncCallbackInfo) +{ + napi_value cons = nullptr; + napi_value instance = nullptr; + napi_status callBackStatus; + RunningLockEntity *entity = nullptr; + + if (asyncCallbackInfo->runningLock == nullptr) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: runningLock is nullptr", __func__); + return nullptr; + } + callBackStatus = napi_get_reference_value(env, g_runningLockConstructor, &cons); + if (callBackStatus != napi_ok) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: napi get reference value failed", __func__); + return nullptr; + } + callBackStatus = napi_new_instance(env, cons, 0, nullptr, &instance); + if (callBackStatus != napi_ok || instance == nullptr) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: napi new reference failed", __func__); + return nullptr; + } + callBackStatus = napi_unwrap(env, instance, (void **)&entity); + if (callBackStatus != napi_ok || entity == nullptr) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: cannot unwrap entity from instance", __func__); + return nullptr; + } + entity->runningLock = asyncCallbackInfo->runningLock; + return instance; +} + +static void CreateRunningLockCallBack(napi_env env, RunningLockAsyncCallbackInfo *asyncCallbackInfo) +{ + napi_value resource = nullptr; + napi_create_string_utf8(env, "createRunningLock", NAPI_AUTO_LENGTH, &resource); + napi_create_async_work( + env, + nullptr, + resource, + [](napi_env env, void *data) { + RunningLockAsyncCallbackInfo *asyncCallbackInfo = (RunningLockAsyncCallbackInfo *)data; + asyncCallbackInfo->runningLock = g_powerMgrClient.CreateRunningLock(std::string(asyncCallbackInfo->name), + asyncCallbackInfo->type); + }, + [](napi_env env, napi_status status, void *data) { + RunningLockAsyncCallbackInfo *asyncCallbackInfo = (RunningLockAsyncCallbackInfo *)data; + napi_value result[RESULT_SIZE] = { 0 }; + result[1] = CreateInstanceForRunningLock(env, asyncCallbackInfo); + if (result[1] == nullptr) { + napi_value message = nullptr; + napi_create_string_utf8(env, "runningLock create failed", NAPI_AUTO_LENGTH, &message); + napi_create_error(env, nullptr, message, &result[0]); + } + if (asyncCallbackInfo->deferred) { + if (result[1] != nullptr) { + napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]); + } else { + napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]); + } + } else { + napi_value tmp = nullptr; + napi_value callback = nullptr; + napi_get_undefined(env, &result[0]); + napi_get_reference_value(env, asyncCallbackInfo->callbackRef, &callback); + napi_call_function(env, nullptr, callback, RESULT_SIZE, result, &tmp); + napi_delete_reference(env, asyncCallbackInfo->callbackRef); + } + napi_delete_async_work(env, asyncCallbackInfo->asyncWork); + delete asyncCallbackInfo; + }, + (void *)asyncCallbackInfo, + &asyncCallbackInfo->asyncWork); + napi_queue_async_work(env, asyncCallbackInfo->asyncWork); +} + +static napi_value CreateRunningLock(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter", __func__); + size_t argc = CREATRUNNINGLOCK_ARGC; + napi_value argv[CREATRUNNINGLOCK_ARGC] = { 0 }; + napi_value thisArg = nullptr; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisArg, &data); + NAPI_ASSERT(env, (status == napi_ok) && (argc >= CREATRUNNINGLOCK_ARGC - 1), + "CreateRunningLock: failed to get cb info"); + + auto asyncCallbackInfo = new RunningLockAsyncCallbackInfo(); + if (asyncCallbackInfo == nullptr) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: asyncCallbackInfo is nullptr", __func__); + return nullptr; + } + asyncCallbackInfo->env = env; + + for (size_t i = 0; i < argc; i++) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[i], &valueType); + if ((i == 0) && (valueType == napi_string)) { + napi_get_value_string_utf8(env, argv[i], asyncCallbackInfo->name, RUNNINGLOCK_NAME_MAX - 1, + &asyncCallbackInfo->nameLen); + } + if (i == 1) { + int32_t type = static_cast(RunningLockType::RUNNINGLOCK_BUTT); + napi_get_value_int32(env, argv[i], &type); + asyncCallbackInfo->type = static_cast(type); + } + if (valueType == napi_function) { + napi_create_reference(env, argv[i], 1, &asyncCallbackInfo->callbackRef); + } + } + napi_value result = nullptr; + if (asyncCallbackInfo->callbackRef == nullptr) { + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: callbackRef is null", __func__); + napi_create_promise(env, &asyncCallbackInfo->deferred, &result); + } else { + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: callbackRef is not null", __func__); + napi_get_undefined(env, &result); + } + CreateRunningLockCallBack(env, asyncCallbackInfo); + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: exit", __func__); + return result; +} + +static void IsRunningLockTypeSupportedCallBack(napi_env env, + RunningLockAsyncCallbackInfo *asyncCallbackInfo) +{ + napi_value resource = nullptr; + napi_create_string_utf8(env, "isRunningLockTypeSupported", NAPI_AUTO_LENGTH, &resource); + napi_create_async_work( + env, + nullptr, + resource, + [](napi_env env, void *data) { + RunningLockAsyncCallbackInfo *asyncCallbackInfo = (RunningLockAsyncCallbackInfo *)data; + if (asyncCallbackInfo->type == RunningLockType::RUNNINGLOCK_BACKGROUND) { + asyncCallbackInfo->isSupported = true; + } + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: runningLock isSupported %{public}s", __func__, + asyncCallbackInfo->isSupported ? "true" : "false"); + }, + [](napi_env env, napi_status status, void *data) { + RunningLockAsyncCallbackInfo *asyncCallbackInfo = (RunningLockAsyncCallbackInfo *)data; + napi_value result[RESULT_SIZE] = { 0 }; + napi_get_boolean(env, asyncCallbackInfo->isSupported, &result[1]); + if (asyncCallbackInfo->deferred) { + napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]); + } else { + napi_value tmp = nullptr; + napi_value callback = nullptr; + napi_get_reference_value(env, asyncCallbackInfo->callbackRef, &callback); + napi_get_undefined(env, &result[0]); + napi_call_function(env, nullptr, callback, RESULT_SIZE, result, &tmp); + napi_delete_reference(env, asyncCallbackInfo->callbackRef); + } + napi_delete_async_work(env, asyncCallbackInfo->asyncWork); + delete asyncCallbackInfo; + }, + (void *)asyncCallbackInfo, + &asyncCallbackInfo->asyncWork); + napi_queue_async_work(env, asyncCallbackInfo->asyncWork); +} + +static napi_value IsRunningLockTypeSupported(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter", __func__); + size_t argc = ISRUNNINGLOCKTYPESUPPORTED_ARGC; + napi_value argv[ISRUNNINGLOCKTYPESUPPORTED_ARGC] = { 0 }; + napi_value thisArg = nullptr; + void *data = nullptr; + + napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisArg, &data); + NAPI_ASSERT(env, (status == napi_ok) && (argc >= 1), + "IsRunningLockTypeSupported: failed to get cb info"); + + auto asyncCallbackInfo = new RunningLockAsyncCallbackInfo(); + if (asyncCallbackInfo == nullptr) { + POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: asyncCallbackInfo is nullptr", __func__); + return nullptr; + } + asyncCallbackInfo->env = env; + + for (size_t i = 0; i < argc; i++) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[i], &valueType); + if (i == 0) { + int32_t type = static_cast(RunningLockType::RUNNINGLOCK_BUTT); + napi_get_value_int32(env, argv[i], &type); + asyncCallbackInfo->type = static_cast(type); + } + if (valueType == napi_function) { + napi_create_reference(env, argv[i], 1, &asyncCallbackInfo->callbackRef); + } + } + + napi_value result = nullptr; + if (asyncCallbackInfo->callbackRef == nullptr) { + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: callbackRef is null", __func__); + napi_create_promise(env, &asyncCallbackInfo->deferred, &result); + } else { + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: callbackRef is not null", __func__); + napi_get_undefined(env, &result); + } + IsRunningLockTypeSupportedCallBack(env, asyncCallbackInfo); + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: exit", __func__); + return result; +} + +static napi_value EnumRunningLockTypeConstructor(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter", __func__); + napi_value thisArg = nullptr; + void *data = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data); + napi_value global = nullptr; + napi_get_global(env, &global); + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: exit", __func__); + return thisArg; +} + +static napi_value CreateEnumRunningLockType(napi_env env, napi_value exports) +{ + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter", __func__); + napi_value background = nullptr; + napi_value proximityscreencontrol = nullptr; + + napi_create_int32(env, (int32_t)RunningLockType::RUNNINGLOCK_BACKGROUND, &background); + napi_create_int32(env, (int32_t)RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL, &proximityscreencontrol); + + napi_property_descriptor desc[] = { + DECLARE_NAPI_STATIC_PROPERTY("BACKGROUND", background), + DECLARE_NAPI_STATIC_PROPERTY("PROXIMITY_SCREEN_CONTROL", proximityscreencontrol), + }; + napi_value result = nullptr; + napi_define_class(env, "RunningLockType", NAPI_AUTO_LENGTH, EnumRunningLockTypeConstructor, nullptr, + sizeof(desc) / sizeof(*desc), desc, &result); + + napi_set_named_property(env, exports, "RunningLockType", result); + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: exit", __func__); + return exports; +} + +static napi_value RunningLockConstructor(napi_env env, napi_callback_info info) +{ + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter", __func__); + napi_value thisVar = nullptr; + void *data = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data); + + auto entity = new RunningLockEntity(); + napi_wrap( + env, thisVar, entity, + [](napi_env env, void *data, void *hint) { + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: Destructor", __func__); + auto entity = (RunningLockEntity*)data; + delete entity; + }, + nullptr, nullptr); + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: exit", __func__); + + return thisVar; +} + +static napi_value CreateRunningLockClass(napi_env env, napi_value exports) +{ + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter", __func__); + + napi_property_descriptor desc[] = { + DECLARE_NAPI_FUNCTION("unlock", Unlock), + DECLARE_NAPI_FUNCTION("isUsed", IsUsed), + DECLARE_NAPI_FUNCTION("lock", Lock), + }; + + napi_value result = nullptr; + napi_define_class(env, "RunningLock", NAPI_AUTO_LENGTH, RunningLockConstructor, nullptr, + sizeof(desc) / sizeof(*desc), desc, &result); + + napi_create_reference(env, result, 1, &g_runningLockConstructor); + napi_set_named_property(env, exports, "RunningLock", result); + + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: exit", __func__); + return exports; +} + +EXTERN_C_START +/* + * function for module exports + */ +static napi_value RunningLockInit(napi_env env, napi_value exports) +{ + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter", __func__); + + napi_property_descriptor desc[] = { + DECLARE_NAPI_FUNCTION("createRunningLock", CreateRunningLock), + DECLARE_NAPI_FUNCTION("isRunningLockTypeSupported", IsRunningLockTypeSupported), + }; + + NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); + + CreateRunningLockClass(env, exports); + CreateEnumRunningLockType(env, exports); + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: exit", __func__); + + return exports; +} +EXTERN_C_END + +/* + * Module definition + */ +static napi_module g_module = { + .nm_version = 1, + .nm_flags = 0, + .nm_filename = "runningLock", + .nm_register_func = RunningLockInit, + .nm_modname = "runningLock", + .nm_priv = ((void *)0), + .reserved = {0} +}; + +/* + * Module registration + */ +extern "C" __attribute__((constructor)) void RegisterRunninglockModule(void) +{ + napi_module_register(&g_module); +} \ No newline at end of file diff --git a/frameworks/napi/test/power_manager_unit.test.js b/frameworks/napi/test/power_manager_unit.test.js new file mode 100644 index 00000000..003ff798 --- /dev/null +++ b/frameworks/napi/test/power_manager_unit.test.js @@ -0,0 +1,210 @@ +/* + * Copyright (C) 2021 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. + */ + +import app from '@system.app' +import Context from '@ohos.napi_context' +import runningLock from '@ohos.runningLock'; +import power from '@ohos.power'; +import '@ohos.permission.RUNNING_LOCK' + +import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' + +describe('appInfoTest', function () { + console.log("*************Power Unit Test Begin*************"); + it('create_running_lock_promise_test', 0, async function (done) { + runningLock.createRunningLock("running_lock_test_1", runningLock.RunningLockType.BACKGROUND) + .then(runninglock => { + expect(runninglock !== null).assertTrue(); + console.info('create_running_lock_promise_test success'); + done(); + }) + .catch(error => { + console.log('create_running_lock_promise_test error: ' + error); + expect().assertFail(); + done(); + }) + }) + it('create_running_lock_callback_test', 0, async function (done) { + runningLock.createRunningLock("running_lock_test_2", runningLock.RunningLockType.BACKGROUND, (error, runninglock) => { + if (typeof error === "undefined") { + console.info('create_running_lock_callback_test: runningLock is ' + runninglock); + expect(runninglock !== null).assertTrue(); + var used = runninglock.isUsed(); + console.info('create_running_lock_callback_test is used: ' + used); + expect(used).assertFalse(); + runninglock.lock(500); + used = runninglock.isUsed(); + console.info('after lock create_running_lock_callback_test is used: ' + used); + expect(used).assertTrue(); + console.info('create_running_lock_callback_test success'); + done(); + } else { + console.log('create_running_lock_callback_test: ' + error); + expect().assertFail(); + done(); + } + }) + }) + it('running_lock_lock_test', 0, async function (done) { + runningLock.createRunningLock("running_lock_test_3", runningLock.RunningLockType.BACKGROUND) + .then(runninglock => { + expect(runninglock !== null).assertTrue(); + var used = runninglock.isUsed(); + console.info('running_lock_lock_test is used: ' + used); + expect(used).assertFalse(); + runninglock.lock(500); + used = runninglock.isUsed(); + console.info('after lock running_lock_lock_test is used: ' + used); + expect(used).assertTrue(); + console.info('running_lock_lock_test success'); + done(); + }) + .catch(error => { + console.log('running_lock_lock_test error: ' + error); + expect().assertFail(); + done(); + }) + }) + it('running_lock_isused_test', 0, async function (done) { + runningLock.createRunningLock("running_lock_test_4", runningLock.RunningLockType.BACKGROUND) + .then(runninglock => { + expect(runninglock !== null).assertTrue(); + var used = runninglock.isUsed(); + console.info('running_lock_isused_test used: ' + used); + expect(used).assertFalse(); + console.info('running_lock_isused_test success'); + done(); + }) + .catch(error => { + console.log('running_lock_isused_test error: ' + error); + expect().assertFail(); + done(); + }) + }) + it('running_lock_unlock_test', 0, async function (done) { + runningLock.createRunningLock("running_lock_test_5", runningLock.RunningLockType.BACKGROUND) + .then(runninglock => { + expect(runninglock !== null).assertTrue(); + var used = runninglock.isUsed(); + console.info('running_lock_unlock_test is used: ' + used); + expect(used).assertFalse(); + runninglock.lock(500); + used = runninglock.isUsed(); + console.info('after lock running_lock_unlock_test is used: ' + used); + expect(used).assertTrue(); + runninglock.unlock(); + used = runninglock.isUsed(); + console.info('after unlock running_lock_unlock_test is used: ' + used); + expect(used).assertFalse(); + console.info('running_lock_unlock_test success'); + done(); + }) + .catch(error => { + console.log('running_lock_unlock_test error: ' + error); + expect().assertFail(); + done(); + }) + }) + it('enum_runningLock_type_background_test', 0, function () { + var runningLockType = runningLock.RunningLockType.BACKGROUND; + console.info('runningLockType = ' + runningLockType); + expect(runningLockType == 1).assertTrue(); + console.info('enum_runningLock_type_background_test success'); + }) + it('enum_runningLock_type_proximityscreencontrol_test', 0, function () { + var runningLockType = runningLock.RunningLockType.PROXIMITY_SCREEN_CONTROL; + console.info('runningLockType = ' + runningLockType); + expect(runningLockType == 2).assertTrue(); + console.info('enum_runningLock_type_proximityscreencontrol_test success'); + }) + it('is_runninglock_type_supported_test_1', 0, async function (done) { + runningLock.isRunningLockTypeSupported(runningLock.RunningLockType.PROXIMITY_SCREEN_CONTROL) + .then(supported => { + console.info('is_runninglock_type_supported_test_1 PROXIMITY_SCREEN_CONTROL supported is ' + supported); + expect(supported).assertFalse(); + console.info('is_runninglock_type_supported_test_1 success'); + done(); + }) + .catch(error => { + console.log('is_runninglock_type_supported_test_1 error: ' + error); + expect().assertFail(); + done(); + }) + }) + it('is_runninglock_type_supported_promise_test_2', 0, async function (done) { + runningLock.isRunningLockTypeSupported(runningLock.RunningLockType.BACKGROUND) + .then(supported => { + console.info('is_runninglock_type_supported_promise_test_2 BACKGROUND supported is ' + supported); + expect(supported).assertTrue(); + console.info('is_runninglock_type_supported_promise_test_2 success'); + done(); + }) + .catch(error => { + console.log('is_runninglock_type_supported_promise_test_2 error: ' + error); + expect().assertFail(); + done(); + }) + }) + it('is_runninglock_type_supported_callback_test_3', 0, async function (done) { + runningLock.isRunningLockTypeSupported(runningLock.RunningLockType.BACKGROUND, (error, supported) => { + if (typeof error === "undefined") { + console.info('is_runninglock_type_supported_callback_test_3 BACKGROUND supported is ' + supported); + expect(supported).assertTrue(); + console.info('is_runninglock_type_supported_callback_test_3 success'); + done(); + } else { + console.log('is_runninglock_type_supported_callback_test_3: ' + error); + expect().assertFail(); + done(); + } + }) + }) + it('power_is_screen_on_promise_test', 0, async function (done) { + power.isScreenOn() + .then(screenOn => { + console.info('power_is_screen_on_promise_test screenOn is ' + screenOn); + expect(screenOn).assertTrue(); + console.info('power_is_screen_on_promise_test success'); + done(); + }) + .catch(error => { + console.log('power_is_screen_on_promise_test error: ' + error); + expect().assertFail(); + done(); + }) + }) + it('power_is_screen_on_callback_test', 0, async function (done) { + power.isScreenOn((error, screenOn) => { + if (typeof error === "undefined") { + console.info('power_is_screen_on_callback_test screenOn is ' + screenOn); + expect(screenOn).assertTrue(); + console.info('power_is_screen_on_callback_test success'); + done(); + } else { + console.log('power_is_screen_on_callback_test: ' + error); + expect().assertFail(); + done(); + } + }) + }) + it('power_reboot_device_test', 0, function () { + power.rebootDevice("power_js_test_reboot"); + console.info('power_reboot_device_test success'); + }) + it('power_shutdown_device_test', 0, function () { + power.shutdownDevice("power_js_test_shutdown"); + console.info('power_shutdown_device_test success'); + }) +}) \ No newline at end of file diff --git a/hdi/api/include/power_hdf_client.h b/hdi/api/include/power_hdf_client.h index da2c7e4b..d853ee9c 100644 --- a/hdi/api/include/power_hdf_client.h +++ b/hdi/api/include/power_hdf_client.h @@ -31,6 +31,7 @@ public: ErrCode WriteWakeCount(const std::string& count); ErrCode WakeLock(const std::string& name); ErrCode WakeUnlock(const std::string& name); + ErrCode Dump(std::string& info); private: ErrCode Dispatch(uint32_t cmd, MessageParcel &data, MessageParcel &reply); sptr GetService(); diff --git a/hdi/api/include/power_hdf_info.h b/hdi/api/include/power_hdf_info.h index 8499eb26..8c40d7b7 100644 --- a/hdi/api/include/power_hdf_info.h +++ b/hdi/api/include/power_hdf_info.h @@ -22,6 +22,7 @@ enum PowerHdfCmd { CMD_WRITE_WAKE_COUNT, CMD_WAKE_LOCK, CMD_WAKE_UNLOCK, + CMD_DUMP, }; enum PowerHdfState { diff --git a/hdi/client/src/power_hdf_client.cpp b/hdi/client/src/power_hdf_client.cpp index 1d80c0db..83b42801 100644 --- a/hdi/client/src/power_hdf_client.cpp +++ b/hdi/client/src/power_hdf_client.cpp @@ -89,6 +89,18 @@ sptr PowerHdfClient::GetService() return service; } +ErrCode PowerHdfClient::Dump(std::string& info) +{ + MessageParcel data; + MessageParcel reply; + ErrCode ret = Dispatch(CMD_DUMP, data, reply); + if (ret != ERR_OK) { + return ret; + } + info = reply.ReadString(); + return ERR_OK; +} + ErrCode PowerHdfClient::Dispatch(uint32_t cmd, MessageParcel &data, MessageParcel &reply) { POWER_HILOGD(MODULE_SERVICE, "Start to dispatch cmd: %{public}d", cmd); @@ -108,6 +120,5 @@ ErrCode PowerHdfClient::Dispatch(uint32_t cmd, MessageParcel &data, MessageParce return ret; } - } // namespace PowerMgr } // namespace OHOS \ No newline at end of file diff --git a/hdi/service/include/power_hdf_service.h b/hdi/service/include/power_hdf_service.h index 1e3d83de..b46d8c9d 100644 --- a/hdi/service/include/power_hdf_service.h +++ b/hdi/service/include/power_hdf_service.h @@ -38,6 +38,7 @@ public: static int32_t WriteWakeCount(struct HdfSBuf *data); static int32_t WakeLock(struct HdfSBuf *data); static int32_t WakeUnlock(struct HdfSBuf *data); + static int32_t Dump(struct HdfSBuf *data); struct IDeviceIoService ioService; struct HdfDeviceObject *device; diff --git a/hdi/service/src/power_hdf_service.cpp b/hdi/service/src/power_hdf_service.cpp index e20db284..c599c81d 100644 --- a/hdi/service/src/power_hdf_service.cpp +++ b/hdi/service/src/power_hdf_service.cpp @@ -107,6 +107,10 @@ int32_t PowerHdfService::Dispatch(struct HdfDeviceIoClient *client, ret = PowerHdfService::WakeUnlock(data); break; } + case CMD_DUMP: { + ret = PowerHdfService::Dump(reply); + break; + } default: break; } @@ -214,6 +218,35 @@ int32_t PowerHdfService::WakeUnlock(struct HdfSBuf *data) return HDF_SUCCESS; } +static void loadSystemInfo(const char* const path, std::string& info) +{ + UniqueFd fd(TEMP_FAILURE_RETRY(open(path, O_RDWR | O_CLOEXEC))); + std::string str; + if (fd >= 0) { + bool ret = LoadStringFromFd(fd, str); + if (!ret) { + str = "# Failed to read"; + } + } else { + str = "# Failed to open"; + } + info.append(path); + info.append(": " + str + "\n"); +} + +int32_t PowerHdfService::Dump(struct HdfSBuf *reply) +{ + HDF_LOGD("%{public}s enter", __func__); + std::string dumpInfo(""); + loadSystemInfo(SUSPEND_STATE_PATH, dumpInfo); + loadSystemInfo(WAKEUP_COUNT_PATH, dumpInfo); + loadSystemInfo(LOCK_PATH, dumpInfo); + loadSystemInfo(UNLOCK_PATH, dumpInfo); + + HdfSbufWriteString(reply, dumpInfo.c_str()); + return HDF_SUCCESS; +} + struct HdfDriverEntry g_powerHdfEntry = { .moduleVersion = 1, .moduleName = "power_hdf", diff --git a/interfaces/innerkits/native/include/power_state_machine_info.h b/interfaces/innerkits/native/include/power_state_machine_info.h index 1f7d23f3..720cf8c5 100644 --- a/interfaces/innerkits/native/include/power_state_machine_info.h +++ b/interfaces/innerkits/native/include/power_state_machine_info.h @@ -87,6 +87,7 @@ enum class UserActivityType : uint32_t { USER_ACTIVITY_TYPE_ACCESSIBILITY = 3, USER_ACTIVITY_TYPE_ATTENTION = 4, USER_ACTIVITY_TYPE_SOFTWARE = 5, + USER_ACTIVITY_TYPE_MAX = USER_ACTIVITY_TYPE_SOFTWARE, }; // WakeupReasonType list @@ -101,6 +102,7 @@ enum class WakeupDeviceType : uint32_t { WAKEUP_DEVICE_WAKE_MOTION = 7, WAKEUP_DEVICE_HDMI = 8, WAKEUP_DEVICE_LID = 9, + WAKEUP_DEVICE_MAX = WAKEUP_DEVICE_LID, }; // SuspendDeviceType list @@ -135,6 +137,7 @@ enum class StateChangeReason : uint32_t { STATE_CHANGE_REASON_LID = 16, STATE_CHANGE_REASON_CAMERA = 17, STATE_CHANGE_REASON_ACCESSIBILITY = 18, + STATE_CHANGE_REASON_RESET = 19, STATE_CHANGE_REASON_REMOTE = 100, STATE_CHANGE_REASON_UNKNOWN = 1000, }; diff --git a/interfaces/kits/js/@ohos.power.d.ts b/interfaces/kits/js/@ohos.power.d.ts index 68aa0f2d..9d1d90d1 100644 --- a/interfaces/kits/js/@ohos.power.d.ts +++ b/interfaces/kits/js/@ohos.power.d.ts @@ -19,180 +19,40 @@ import {AsyncCallback} from './basic'; * Provides interfaces to manage power. * * @SysCap SystemCapability.PowerMgr.PowerManager - * @devices phone, tablet - * @since 6 + * @devices phone, tablet, tv, wearable + * @since 7 */ declare namespace power { - /** - * Enumerates the {@link RunningLock} types. - * - *

Two {@link RunningLock} types are available: {@link BACKGROUND}, and {@link PROXIMITY_SCREEN_CONTROL}. - * {@link BACKGROUND} ensures that applications can run in the background. - * {@link PROXIMITY_SCREEN_CONTROL} determines whether to turn on or off the screen based on the proximity sensor. - * - * @since 6 - */ - export enum RunningLockType { - /** - * Indicates the lock that prevents the system from hibernating. - */ - BACKGROUND = 1, - /** - * Indicates the lock that determines whether to turn on or off the screen based on the proximity sensor. - * For example, during a call, if the proximity sensor detects that the device is moving close to - * the user's ear, the screen turns off; if the proximity sensor detects that the device is moving away - * from the user's ear, the screen turns on. - */ - PROXIMITY_SCREEN_CONTROL - } - /** - * Enumerates the {@link PowerState} types. - * - *

Three {@link PowerState} types are available: {@link AWAKE}, {@link SLEEP}, and {@link INACTIVE}. - * {@link AWAKE} Indicates that the screen is on and the system is running. - * {@link INACTIVE} Indicates that the screen is off and the system is running. - * {@link SLEEP} Indicates that the screen is on and the system is running. - * - * @since 6 - */ - export enum PowerState { - /** - * Indicates that the screen is on and the system is running. - */ - AWAKE = 0, - /** - * Indicates that the screen is off and the system is running. - */ - INACTIVE, - /** - * Indicates that the screen is off and the system is hibernating. - */ - SLEEP, - } - - export enum PowerMode { - /** - * Indicates extream power save mode - */ - EXTREAM_MODE = 601, - /** - * Indicates normal mode - */ - NORMAL_MODE, - /** - * Indicates sleep mode - */ - SAVE_MODE, - /** - * Indicates low power mode - */ - LOWPOWER_MODE - } - - export class RunningLock { - /** - * Prevents the system from hibernating and sets the lock duration. - * - * @param timeout Indicates the lock duration (ms). After the lock duration times out, the lock is automatically - * released and the system hibernates if no other {@link RunningLock} is set. - * @since 6 - */ - function lock(timeout: number, callback: AsyncCallback): void; - function lock(timeout: number): Promise; - - /** - * Checks whether a lock is held or in use. - * - * @return Returns true if the lock is held or in use; returns false if the lock has been released. - * @since 6 - */ - function isUsed(callback: AsyncCallback): void; - function isUsed(): Promise; - - /** - * Release the {@link RunningLock} that prevents the system from hibernating. - * - * @since 6 - */ - function unlock(callback: AsyncCallback): void; - function unlock(): Promise; - } - - /** - * Checks whether the specified {@link RunningLockType} is supported. - * - * @param type Indicates the specified {@link RunningLockType}. - * @return Returns true if the specified {@link RunningLockType} is supported; - * returns false otherwise. - * @since 6 - */ - function isRunningLockTypeSupported(type: RunningLockType, callback: AsyncCallback): void; - function isRunningLockTypeSupported(type: RunningLockType): Promise; - - /** - * Creates a RunningLock object. - * - *

This method requires the ohos.permission.RUNNING_LOCK permission. - * - *

The {@link RunningLock} object can be used to perform a lock operation to prevent the system from hibernating. - * - * @param name Indicates the RunningLock name. A recommended name consists of the package or class name and - * a suffix. - * @param type Indicates the RunningLockType. - * @return Returns the RunningLock object. - * @since 6 - */ - function createRunningLock(name: string, type: RunningLockType, callback: AsyncCallback): void; - function createRunningLock(name: string, type: RunningLockType): Promise; - - /** - * Shuts down the system. - * - *

This method requires the ohos.permission.SHUTDOWN permission. - * - * @param reason Indicates the shutdown reason. - * @since 6 - */ - function shutownDevice(reason: string, callback: AsyncCallback): void; - function shutownDevice(reason: string): Promise; - - /** - * Restarts the system. - * - *

This method requires the ohos.permission.REBOOT permission. - * - * @param reason Indicates the restart reason. For example, "recovery" indicates entering the recovery mode - * after the restart. If the parameter is not specified, the system enters the normal mode after the restart. - * @since 6 - */ - function rebootDevice(reason: string, callback: AsyncCallback): void; - function rebootDevice(reason: string): Promise; - - /** - * Checks whether the screen of a device is on or off. - * - * @return Returns true if the screen is on; returns false otherwise. - * @since 6 - */ - function isScreenOn(callback: AsyncCallback): void; - function isScreenOn(): Promise; - - /** - * Get power state. - * - * @return Returns power state indicates the specified {@link PowerState} - * @since 6 - */ - function getState(callback: AsyncCallback): void; - function getState(): Promise; - - /** - * Get power mode. - * - * @return Returns current power mode name. - * @since 6 - */ - function getMode(callback: AsyncCallback):void - function getMode(): Promise; + /** + * Shuts down the system. + * + *

This method requires the ohos.permission.SHUTDOWN permission. + * + * @param reason Indicates the shutdown reason. + * @systemapi + * @since 7 + */ + function shutdownDevice(reason: string): void; + + /** + * Restarts the system. + * + *

This method requires the ohos.permission.REBOOT permission. + * + * @param reason Indicates the restart reason. For example, "recovery" indicates entering the recovery mode + * after the restart. If the parameter is not specified, the system enters the normal mode after the restart. + * @since 7 + */ + function rebootDevice(reason: string): void; + + /** + * Checks whether the screen of a device is on or off. + * + * @return Returns true if the screen is on; returns false otherwise. + * @since 7 + */ + function isScreenOn(callback: AsyncCallback): void; + function isScreenOn(): Promise; } export default power; + diff --git a/interfaces/kits/js/@ohos.runninglock.d.ts b/interfaces/kits/js/@ohos.runninglock.d.ts new file mode 100644 index 00000000..808ea5f1 --- /dev/null +++ b/interfaces/kits/js/@ohos.runninglock.d.ts @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2021 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. + */ + +import {AsyncCallback} from './basic.d.ts'; + +/** + * Provides a mechanism to prevent the system from hibernating so that the applications can run in the background or + * when the screen is off. + * + *

{@link createRunningLock} can be called to obtain a {@link RunningLock}. + *

{@link lock} can be called to set the lock duration, during which the system will not hibernate. After the + * lock duration times out, the lock is automatically released and the system hibernates if no other {@link + * RunningLock} is set. + * + * @SysCap SystemCapability.PowerMgr.PowerManager + * @devices phone, tablet, tv, wearable + * @since 7 + */ +declare namespace runningLock { + class RunningLock { + /** + * Prevents the system from hibernating and sets the lock duration. + * + * @param timeout Indicates the lock duration (ms). After the lock duration times out, the lock is automatically + * released and the system hibernates if no other {@link RunningLock} is set. + * @since 7 + */ + function lock(timeout: number): void; + + /** + * Checks whether a lock is held or in use. + * + * @return Returns true if the lock is held or in use; returns false if the lock has been released. + * @since 7 + */ + function isUsed(): boolean; + + /** + * Release the {@link RunningLock} that prevents the system from hibernating. + * + * @since 7 + */ + function unlock(): void; + } + + /** + * Enumerates the {@link RunningLock} types. + * + *

Two {@link RunningLock} types are available: {@link BACKGROUND}, and {@link PROXIMITY_SCREEN_CONTROL}. + * {@link BACKGROUND} ensures that applications can run in the background. + * {@link PROXIMITY_SCREEN_CONTROL} determines whether to turn on or off the screen based on the proximity sensor. + * + * @since 7 + */ + export enum RunningLockType { + /** + * Indicates the lock that prevents the system from hibernating. + */ + BACKGROUND = 1, + /** + * Indicates the lock that determines whether to turn on or off the screen based on the proximity sensor. + * For example, during a call, if the proximity sensor detects that the device is moving close to + * the user's ear, the screen turns off; if the proximity sensor detects that the device is moving away + * from the user's ear, the screen turns on. + */ + PROXIMITY_SCREEN_CONTROL + } + + /** + * Checks whether the specified {@link RunningLockType} is supported. + * + * @param type Indicates the specified {@link RunningLockType}. + * @return Returns true if the specified {@link RunningLockType} is supported; + * returns false otherwise. + * @since 7 + */ + function isRunningLockTypeSupported(type: RunningLockType, callback: AsyncCallback): void; + function isRunningLockTypeSupported(type: RunningLockType): Promise; + /** + * Creates a {@link RunningLock} object. + * + *

This method requires the ohos.permission.RUNNING_LOCK permission. + * + *

The {@link RunningLock} object can be used to perform a lock operation to prevent the system from hibernating. + * + * @param name Indicates the {@link RunningLock} name. A recommended name consists of the package or class name and + * a suffix. + * @param type Indicates the {@link RunningLockType}. + * @return Returns the {@link RunningLock} object. + * @since 7 + */ + function createRunningLock(name: string, type: RunningLockType, callback: AsyncCallback): void; + function createRunningLock(name: string, type: RunningLockType): Promise; +} +export default runningLock; diff --git a/ohos.build b/ohos.build index b8324d4e..c48be5c0 100644 --- a/ohos.build +++ b/ohos.build @@ -4,8 +4,8 @@ "power_manager_native": { "module_list": [ "//base/powermgr/power_manager/interfaces/innerkits:powermgr_client", - "//base/powermgr/power_manager/interfaces/kits/js:power", - "//base/powermgr/power_manager/interfaces/kits/js:power_js", + "//base/powermgr/power_manager/frameworks/napi/power:power", + "//base/powermgr/power_manager/frameworks/napi/runninglock:runninglock", "//base/powermgr/power_manager/sa_profile:powermgr_sa_profile", "//base/powermgr/power_manager/services:powermgrservice", "//base/powermgr/power_manager/hdi:hdi_group", @@ -30,7 +30,8 @@ } ], "test_list": [ - "//base/powermgr/power_manager/services/native/test:powermgr_test" + "//base/powermgr/power_manager/services/native/test:powermgr_test", + "//base/powermgr/power_manager/test:systemtest" ] } } diff --git a/services/native/include/actions/irunning_lock_action.h b/services/native/include/actions/irunning_lock_action.h index 89b80058..36d0aacc 100644 --- a/services/native/include/actions/irunning_lock_action.h +++ b/services/native/include/actions/irunning_lock_action.h @@ -34,8 +34,8 @@ public: return LOCK_TAGS[ToUnderlying(type)]; } - void Acquire(RunningLockType type); - void Release(RunningLockType type); + virtual void Acquire(RunningLockType type); + virtual void Release(RunningLockType type); virtual void Lock(RunningLockType type, const std::string& tag) = 0; virtual void Unlock(RunningLockType type, const std::string& tag) = 0; diff --git a/services/native/include/power_mgr_service.h b/services/native/include/power_mgr_service.h index 2166b4eb..c9137e0a 100644 --- a/services/native/include/power_mgr_service.h +++ b/services/native/include/power_mgr_service.h @@ -94,7 +94,31 @@ public: { return ready_; } + void SetDisplayOffTime(int64_t time) + { + powerStateMachine_->SetDisplayOffTime(time); + } + void SetSleepTime(int64_t time) + { + powerStateMachine_->SetSleepTime(time); + } + void EnableMock(IDeviceStateAction* stateAction, IDevicePowerAction* powerAction, + IRunningLockAction* lockAction) + { + POWER_HILOGE(MODULE_SERVICE, "Service EnableMock:%{public}d", mockCount_++); + runningLockMgr_->EnableMock(lockAction); + powerStateMachine_->EnableMock(stateAction); + shutdownService_.EnableMock(powerAction); + } + void MockProximity(uint32_t status) + { + runningLockMgr_->SetProximity(status); + } + void MockSystemWakeup() + { + PowerStateMachine::onWakeup(); + } private: bool Init(); bool PowerStateMachineInit(); @@ -109,6 +133,7 @@ private: std::shared_ptr powerMgrNotify_; ShutdownService shutdownService_; PowerModeModule powerModeModule_; + uint32_t mockCount_{0}; }; } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/include/power_state_machine.h b/services/native/include/power_state_machine.h index 86d3a4c8..67420c4a 100644 --- a/services/native/include/power_state_machine.h +++ b/services/native/include/power_state_machine.h @@ -27,6 +27,9 @@ #include "power_state_machine_info.h" #include "running_lock_info.h" +#define DEFAULT_DISPLAY_OFF_TIME 5000 +#define DEFAULT_SLEEP_TIME 5000 + namespace OHOS { namespace PowerMgr { class RunningLockMgr; @@ -34,7 +37,8 @@ class PowerMgrService; struct ScreenState { DisplayState state; - int64_t lastUpdateTime; + int64_t lastOnTime; + int64_t lastOffTime; }; struct DevicePowerState { @@ -62,6 +66,9 @@ public: explicit PowerStateMachine(const wptr& pms); ~PowerStateMachine(); + static void onSuspend(); + static void onWakeup(); + bool Init(); void SuspendDeviceInner(pid_t pid, int64_t callTimeMs, SuspendDeviceType type, bool suspendImmed, bool ignoreScreenState = false); @@ -80,8 +87,7 @@ public: void ResetSleepTimer(); void HandleDelayTimer(int32_t event); bool SetState(PowerState state, StateChangeReason reason, bool force = false); - static void onSuspend(); - static void onWakeup(); + // only use for test int64_t GetLastSuspendDeviceTime() const { @@ -105,7 +111,10 @@ public: virtual void OnRemoteDied(const wptr& remote); virtual ~PowerStateCallbackDeathRecipient() = default; }; - + void DumpInfo(std::string& result); + void EnableMock(IDeviceStateAction* mockAction); + void SetDisplayOffTime(int64_t time); + void SetSleepTime(int64_t time); private: class StateController { public: @@ -115,10 +124,11 @@ private: ~StateController() = default; PowerState GetState() { return state_; } TransitResult TransitTo(StateChangeReason reason, bool ignoreLock = false); + StateChangeReason lastReason_; + int64_t lastTime_; protected: bool CheckState(); PowerState state_; - StateChangeReason lastReason_; std::weak_ptr owner_; std::function action_; }; @@ -153,6 +163,8 @@ private: sptr powerStateCBDeathRecipient_; std::set, classcomp> powerStateListeners_; std::unique_ptr stateAction_; + int64_t displayOffTime_{DEFAULT_DISPLAY_OFF_TIME}; + int64_t sleepTime_{DEFAULT_SLEEP_TIME}; }; } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/include/running_lock_mgr.h b/services/native/include/running_lock_mgr.h index 08d98c48..b9adffcb 100644 --- a/services/native/include/running_lock_mgr.h +++ b/services/native/include/running_lock_mgr.h @@ -41,6 +41,10 @@ public: SYSTEM_LOCK_DISPLAY = 1, SYSTEM_LOCK_OTHER }; + enum { + PROXIMITY_AWAY = 0, + PROXIMITY_CLOSE + }; using RunningLockProxyMap = std::unordered_map>; explicit RunningLockMgr(const wptr& pms) : pms_(pms) {} ~RunningLockMgr(); @@ -51,8 +55,6 @@ public: std::shared_ptr CreateRunningLock(const sptr& token, const RunningLockInfo& runningLockInfo, const UserIPCInfo &userIPCinfo); void ReleaseLock(const sptr token); - void acquireSystemLock(SystemLockType type); - void releaseSystemLock(SystemLockType type); uint32_t GetRunningLockNum(RunningLockType type = RunningLockType::RUNNINGLOCK_BUTT); uint32_t GetValidRunningLockNum(RunningLockType type = RunningLockType::RUNNINGLOCK_BUTT); void SetWorkTriggerList(const sptr& token, const WorkTriggerList& workTriggerList); @@ -72,8 +74,9 @@ public: static constexpr uint32_t CHECK_TIMEOUT_INTERVAL_MS = 60 * 1000; static constexpr uint32_t MAX_DUMP_NUM = 10; void CheckOverTime(); + void SetProximity(uint32_t status); void DumpInfo(std::string& result); - + void EnableMock(IRunningLockAction* mockAction); private: static constexpr const char* const LOCK_TAG_APP = "lock_app"; static constexpr const char* const LOCK_TAG_DISPLAY = "lock_display"; @@ -87,6 +90,10 @@ private: void Lock(); void Unlock(); bool IsLocking() { return locking_; }; + void EnableMock(std::shared_ptr& mock) + { + action_ = mock; + } private: std::shared_ptr action_; const std::string tag_; @@ -100,6 +107,7 @@ private: ~LockCounter() = default; uint32_t Increase(); uint32_t Decrease(); + void Clear(); uint32_t GetCount() { return counter_; } RunningLockType GetType() { return type_; } private: @@ -116,10 +124,12 @@ private: void Enable(); void Disable(); bool IsEnabled() { return enabled_; } - private: - void OnProximity(); + void OnClose(); void OnAway(); + uint32_t GetStatus() { return status_; } + private: bool enabled_; + uint32_t status_; }; class RunningLockDeathRecipient : public IRemoteObject::DeathRecipient { diff --git a/services/native/include/shutdown_service.h b/services/native/include/shutdown_service.h index 3e1c8650..39f15c9d 100644 --- a/services/native/include/shutdown_service.h +++ b/services/native/include/shutdown_service.h @@ -35,7 +35,11 @@ public: void Shutdown(const std::string& reason); void AddShutdownCallback(const sptr& callback); void DelShutdownCallback(const sptr& callback); - + void EnableMock(IDevicePowerAction* mockAction) + { + std::unique_ptr mock(mockAction); + devicePowerAction_ = std::move(mock); + } private: using IntentWant = OHOS::AAFwk::Want; class CallbackManager : public IRemoteObject::DeathRecipient { diff --git a/services/native/src/actions/default/system_suspend_controller.cpp b/services/native/src/actions/default/system_suspend_controller.cpp index 3ec0a548..569ffb21 100644 --- a/services/native/src/actions/default/system_suspend_controller.cpp +++ b/services/native/src/actions/default/system_suspend_controller.cpp @@ -42,5 +42,10 @@ void SystemSuspendController::ReleaseRunningLock(const std::string& name) { client_->WakeUnlock(name); } + +void SystemSuspendController::Dump(std::string& info) +{ + client_->Dump(info); +} } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/src/actions/default/system_suspend_controller.h b/services/native/src/actions/default/system_suspend_controller.h index 6a9199c0..2bfaa5f1 100644 --- a/services/native/src/actions/default/system_suspend_controller.h +++ b/services/native/src/actions/default/system_suspend_controller.h @@ -32,6 +32,7 @@ public: void Suspend(std::function onSuspend, std::function onWakeup, bool force); void AcquireRunningLock(const std::string& name); void ReleaseRunningLock(const std::string& name); + void Dump(std::string& info); private: DECLARE_DELAYED_REF_SINGLETON(SystemSuspendController); diff --git a/services/native/src/power_mgr_dumper.cpp b/services/native/src/power_mgr_dumper.cpp index 25c5703e..081ee57b 100644 --- a/services/native/src/power_mgr_dumper.cpp +++ b/services/native/src/power_mgr_dumper.cpp @@ -17,12 +17,15 @@ #include "power_common.h" #include "power_mgr_service.h" +#include "system_suspend_controller.h" namespace OHOS { namespace PowerMgr { namespace { const std::string ARGS_HELP = "-h"; const std::string ARGS_RUNNINGLOCK = "-runninglock"; +const std::string ARGS_STATE = "-state"; +const std::string ARGS_HDF = "-hdf"; } bool PowerMgrDumper::Dump(const std::vector& args, std::string& result) @@ -33,16 +36,26 @@ bool PowerMgrDumper::Dump(const std::vector& args, std::string& res ShowUsage(result); return true; } - if (args[0] == ARGS_RUNNINGLOCK) { - auto pms = DelayedSpSingleton::GetInstance(); - if (pms == nullptr) { - return true; - } - auto runningLockMgr = pms->GetRunningLockMgr(); - if (runningLockMgr == nullptr) { - return true; + auto pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + return true; + } + for (auto it = args.begin(); it != args.end(); it++) { + if (*it == ARGS_RUNNINGLOCK) { + auto runningLockMgr = pms->GetRunningLockMgr(); + if (runningLockMgr == nullptr) { + continue; + } + runningLockMgr->DumpInfo(result); + } else if (*it == ARGS_STATE) { + auto stateMachine = pms->GetPowerStateMachine(); + if (stateMachine == nullptr) { + continue; + } + stateMachine->DumpInfo(result); + } else if (*it == ARGS_HDF) { + SystemSuspendController::GetInstance().Dump(result); } - runningLockMgr->DumpInfo(result); } return true; } diff --git a/services/native/src/power_mgr_service.cpp b/services/native/src/power_mgr_service.cpp index da13cd3a..00d0cf3b 100644 --- a/services/native/src/power_mgr_service.cpp +++ b/services/native/src/power_mgr_service.cpp @@ -125,13 +125,18 @@ void PowerMgrService::OnStop() int32_t PowerMgrService::Dump(int32_t fd, const std::vector& args) { std::vector argsInStr; - std::transform(args.begin(), args.end(), std::back_inserter(argsInStr), [](const std::u16string &arg) { - return Str16ToStr8(arg); + std::transform(args.begin(), args.end(), std::back_inserter(argsInStr), + [](const std::u16string &arg) { + std::string ret = Str16ToStr8(arg); + POWER_HILOGI(MODULE_SERVICE, "arg: %{public}s", ret.c_str()); + return ret; }); std::string result; PowerMgrDumper::Dump(argsInStr, result); if (!SaveStringToFd(fd, result)) { POWER_HILOGE(MODULE_SERVICE, "PowerMgrService::Dump failed, save to fd failed."); + POWER_HILOGE(MODULE_SERVICE, "Dump Info:\n"); + POWER_HILOGE(MODULE_SERVICE, "%{public}s", result.c_str()); return ERR_OK; } return ERR_OK; @@ -143,12 +148,17 @@ void PowerMgrService::RebootDevice(const std::string& reason) auto uid = IPCSkeleton::GetCallingUid(); if (reason.find("recovery") != std::string::npos) { if (!Permission::CheckCallingPermission("ohos.permission.REBOOT_RECOVERY")) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, %{public}d permission check fail", __func__, pid); + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, %{public}d permission check fail", + __func__, pid); return; } } else { - if ((uid >= APP_FIRST_UID) && !Permission::CheckCallingPermission("ohos.permission.REBOOT")) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, %{public}d permission check fail", __func__, pid); + if ((uid >= APP_FIRST_UID) + && !Permission::CheckCallingPermission("ohos.permission.REBOOT")) { + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, %{public}d permission check fail", + __func__, pid); return; } } @@ -160,41 +170,57 @@ void PowerMgrService::ShutDownDevice(const std::string& reason) { pid_t pid = IPCSkeleton::GetCallingPid(); auto uid = IPCSkeleton::GetCallingUid(); - if ((uid >= APP_FIRST_UID) && !Permission::CheckCallingPermission("ohos.permission.SHUTDOWN")) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, %{public}d permission check fail", __func__, pid); + if ((uid >= APP_FIRST_UID) + && !Permission::CheckCallingPermission("ohos.permission.SHUTDOWN")) { + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, %{public}d permission check fail", + __func__, pid); return; } POWER_HILOGI(MODULE_SERVICE, "PID: %{public}d Call %{public}s !", pid, __func__); shutdownService_.Shutdown(reason); } -void PowerMgrService::SuspendDevice(int64_t callTimeMs, SuspendDeviceType reason, bool suspendImmed) +void PowerMgrService::SuspendDevice(int64_t callTimeMs, + SuspendDeviceType reason, + bool suspendImmed) { auto uid = IPCSkeleton::GetCallingUid(); if (uid >= APP_FIRST_UID) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, illegal calling uid %{public}d.", __func__, uid); + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, illegal calling uid %{public}d.", + __func__, uid); return; } pid_t pid = IPCSkeleton::GetCallingPid(); powerStateMachine_->SuspendDeviceInner(pid, callTimeMs, reason, suspendImmed); } -void PowerMgrService::WakeupDevice(int64_t callTimeMs, WakeupDeviceType reason, const std::string& details) +void PowerMgrService::WakeupDevice(int64_t callTimeMs, + WakeupDeviceType reason, + const std::string& details) { auto uid = IPCSkeleton::GetCallingUid(); if (uid >= APP_FIRST_UID) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, illegal calling uid %{public}d.", __func__, uid); + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, illegal calling uid %{public}d.", + __func__, uid); return; } pid_t pid = IPCSkeleton::GetCallingPid(); powerStateMachine_->WakeupDeviceInner(pid, callTimeMs, reason, details, "OHOS"); } -void PowerMgrService::RefreshActivity(int64_t callTimeMs, UserActivityType type, bool needChangeBacklight) +void PowerMgrService::RefreshActivity(int64_t callTimeMs, + UserActivityType type, + bool needChangeBacklight) { auto uid = IPCSkeleton::GetCallingUid(); - if ((uid >= APP_FIRST_UID) || !Permission::CheckCallingPermission("ohos.permission.REFRESH_USER_ACTION")) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, illegal calling uid %{public}d.", __func__, uid); + if ((uid >= APP_FIRST_UID) + || !Permission::CheckCallingPermission("ohos.permission.REFRESH_USER_ACTION")) { + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, illegal calling uid %{public}d.", + __func__, uid); return; } pid_t pid = IPCSkeleton::GetCallingPid(); @@ -203,11 +229,13 @@ void PowerMgrService::RefreshActivity(int64_t callTimeMs, UserActivityType type, PowerState PowerMgrService::GetState() { + POWER_HILOGI(MODULE_SERVICE, "GetState"); return powerStateMachine_->GetState(); } bool PowerMgrService::IsScreenOn() { + POWER_HILOGI(MODULE_SERVICE, "IsScreenOn"); return powerStateMachine_->IsScreenOn(); } @@ -215,7 +243,9 @@ bool PowerMgrService::ForceSuspendDevice(int64_t callTimeMs) { auto uid = IPCSkeleton::GetCallingUid(); if (uid >= APP_FIRST_UID) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, illegal calling uid %{public}d.", __func__, uid); + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, illegal calling uid %{public}d.", + __func__, uid); return false; } pid_t pid = IPCSkeleton::GetCallingPid(); @@ -228,11 +258,15 @@ inline void PowerMgrService::FillUserIPCInfo(UserIPCInfo &userIPCinfo) userIPCinfo.uid = IPCSkeleton::GetCallingUid(); } -void PowerMgrService::CreateRunningLock(const sptr& token, const RunningLockInfo& runningLockInfo) +void PowerMgrService::CreateRunningLock(const sptr& token, + const RunningLockInfo& runningLockInfo) { auto uid = IPCSkeleton::GetCallingUid(); - if ((uid >= APP_FIRST_UID) && !Permission::CheckCallingPermission("ohos.permission.RUNNING_LOCK")) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, %{public}d permission check fail", __func__, uid); + if ((uid >= APP_FIRST_UID) + && !Permission::CheckCallingPermission("ohos.permission.RUNNING_LOCK")) { + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, %{public}d permission check fail", + __func__, uid); return; } @@ -247,8 +281,11 @@ void PowerMgrService::CreateRunningLock(const sptr& token, const void PowerMgrService::ReleaseRunningLock(const sptr& token) { auto uid = IPCSkeleton::GetCallingUid(); - if ((uid >= APP_FIRST_UID) && !Permission::CheckCallingPermission("ohos.permission.RUNNING_LOCK")) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, %{public}d permission check fail", __func__, uid); + if ((uid >= APP_FIRST_UID) + && !Permission::CheckCallingPermission("ohos.permission.RUNNING_LOCK")) { + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, %{public}d permission check fail", + __func__, uid); return; } @@ -264,16 +301,25 @@ bool PowerMgrService::IsRunningLockTypeSupported(uint32_t type) return true; } -void PowerMgrService::Lock(const sptr& token, const RunningLockInfo& runningLockInfo, uint32_t timeOutMS) +void PowerMgrService::Lock(const sptr& token, + const RunningLockInfo& runningLockInfo, + uint32_t timeOutMS) { auto uid = IPCSkeleton::GetCallingUid(); - if ((uid >= APP_FIRST_UID) && !Permission::CheckCallingPermission("ohos.permission.RUNNING_LOCK")) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, %{public}d permission check fail", __func__, uid); + if ((uid >= APP_FIRST_UID) + && !Permission::CheckCallingPermission("ohos.permission.RUNNING_LOCK")) { + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, %{public}d permission check fail", + __func__, uid); return; } - POWER_HILOGI(MODULE_SERVICE, "%{public}s :timeOutMS = %d, name = %s, type = %d", __func__, - timeOutMS, runningLockInfo.name.c_str(), runningLockInfo.type); + POWER_HILOGI(MODULE_SERVICE, + "%{public}s :timeOutMS = %{public}d, name = %{public}s, type = %{public}d", + __func__, + timeOutMS, + runningLockInfo.name.c_str(), + runningLockInfo.type); UserIPCInfo userIPCInfo; FillUserIPCInfo(userIPCInfo); @@ -283,8 +329,11 @@ void PowerMgrService::Lock(const sptr& token, const RunningLockIn void PowerMgrService::UnLock(const sptr& token) { auto uid = IPCSkeleton::GetCallingUid(); - if ((uid >= APP_FIRST_UID) && !Permission::CheckCallingPermission("ohos.permission.RUNNING_LOCK")) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, %{public}d permission check fail", __func__, uid); + if ((uid >= APP_FIRST_UID) + && !Permission::CheckCallingPermission("ohos.permission.RUNNING_LOCK")) { + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, %{public}d permission check fail", + __func__, uid); return; } @@ -295,7 +344,8 @@ void PowerMgrService::UnLock(const sptr& token) void PowerMgrService::ForceUnLock(const sptr& token) { POWER_HILOGI(MODULE_SERVICE, "%{public}s called.", __func__); - UnLock(token); + runningLockMgr_->UnLock(token); + runningLockMgr_->ReleaseLock(token); } bool PowerMgrService::IsUsed(const sptr& token) @@ -308,20 +358,28 @@ void PowerMgrService::NotifyRunningLockChanged(bool isUnLock) { if (isUnLock) { // When unlock we try to suspend - if (!runningLockMgr_->ExistValidRunningLock() && !powerStateMachine_->IsScreenOn()) { - // runninglock is empty and Screen is off, so we try to suspend device from Z side. - POWER_HILOGI(MODULE_SERVICE, "%{public}s :RunningLock is empty, try to suspend from Z Side!", __func__); + if (!runningLockMgr_->ExistValidRunningLock() + && !powerStateMachine_->IsScreenOn()) { + // runninglock is empty and Screen is off, + // so we try to suspend device from Z side. + POWER_HILOGI(MODULE_SERVICE, + "%{public}s :RunningLock is empty, try to suspend from Z Side!", + __func__); powerStateMachine_->SuspendDeviceInner(getpid(), GetTickCount(), - SuspendDeviceType::SUSPEND_DEVICE_REASON_MIN, true, true); + SuspendDeviceType::SUSPEND_DEVICE_REASON_MIN, true, true); } } } -void PowerMgrService::SetWorkTriggerList(const sptr& token, const WorkTriggerList& workTriggerList) +void PowerMgrService::SetWorkTriggerList(const sptr& token, + const WorkTriggerList& workTriggerList) { auto uid = IPCSkeleton::GetCallingUid(); - if ((uid >= APP_FIRST_UID) && !Permission::CheckCallingPermission("ohos.permission.RUNNING_LOCK")) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, %{public}d permission check fail", __func__, uid); + if ((uid >= APP_FIRST_UID) + && !Permission::CheckCallingPermission("ohos.permission.RUNNING_LOCK")) { + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, %{public}d permission check fail", + __func__, uid); return; } @@ -333,7 +391,9 @@ void PowerMgrService::ProxyRunningLock(bool proxyLock, pid_t uid, pid_t pid) { auto calllingUid = IPCSkeleton::GetCallingUid(); if (calllingUid >= APP_FIRST_UID) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, illegal calling uid %{public}d.", __func__, + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, illegal calling uid %{public}d.", + __func__, calllingUid); return; } @@ -343,8 +403,11 @@ void PowerMgrService::ProxyRunningLock(bool proxyLock, pid_t uid, pid_t pid) void PowerMgrService::RegisterPowerStateCallback(const sptr& callback) { auto uid = IPCSkeleton::GetCallingUid(); - if ((uid >= APP_FIRST_UID) && !Permission::CheckCallingPermission("ohos.permission.POWER_MANAGER")) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, %{public}d permission check fail", __func__, uid); + if ((uid >= APP_FIRST_UID) + && !Permission::CheckCallingPermission("ohos.permission.POWER_MANAGER")) { + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, %{public}d permission check fail", + __func__, uid); return; } powerStateMachine_->RegisterPowerStateCallback(callback); @@ -353,8 +416,11 @@ void PowerMgrService::RegisterPowerStateCallback(const sptr void PowerMgrService::UnRegisterPowerStateCallback(const sptr& callback) { auto uid = IPCSkeleton::GetCallingUid(); - if ((uid >= APP_FIRST_UID) && !Permission::CheckCallingPermission("ohos.permission.POWER_MANAGER")) { - POWER_HILOGE(MODULE_SERVICE, "%{public}s Request failed, %{public}d permission check fail", __func__, uid); + if ((uid >= APP_FIRST_UID) + && !Permission::CheckCallingPermission("ohos.permission.POWER_MANAGER")) { + POWER_HILOGE(MODULE_SERVICE, + "%{public}s Request failed, %{public}d permission check fail", + __func__, uid); return; } powerStateMachine_->UnRegisterPowerStateCallback(callback); diff --git a/services/native/src/power_state_machine.cpp b/services/native/src/power_state_machine.cpp index 5420ea79..744e0146 100644 --- a/services/native/src/power_state_machine.cpp +++ b/services/native/src/power_state_machine.cpp @@ -34,8 +34,10 @@ PowerStateMachine::PowerStateMachine(const wptr& pms) : pms_(pms), currentState_(PowerState::UNKNOWN) { POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine_currentState: func is Start."); - // NOTICE Need get screen state when device startup, rightnow we set screen is on as default - mDeviceState_.screenState.lastUpdateTime = GetTickCount(); + // NOTICE Need get screen state when device startup, + // rightnow we set screen is on as default + mDeviceState_.screenState.lastOnTime = GetTickCount(); + mDeviceState_.screenState.lastOffTime = 0; mDeviceState_.lastWakeupEventTime = 0; mDeviceState_.lastRefreshActivityTime = 0; mDeviceState_.lastWakeupDeviceTime = 0; @@ -46,9 +48,12 @@ PowerStateMachine::PowerStateMachine(const wptr& pms) std::vector inactiveBlocker {RunningLockType::RUNNINGLOCK_SCREEN, RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL}; std::vector sleepBlocker {RunningLockType::RUNNINGLOCK_BACKGROUND}; - lockMap_.emplace(PowerState::AWAKE, std::make_shared>(awakeBlocker)); - lockMap_.emplace(PowerState::INACTIVE, std::make_shared>(inactiveBlocker)); - lockMap_.emplace(PowerState::SLEEP, std::make_shared>(sleepBlocker)); + lockMap_.emplace(PowerState::AWAKE, + std::make_shared>(awakeBlocker)); + lockMap_.emplace(PowerState::INACTIVE, + std::make_shared>(inactiveBlocker)); + lockMap_.emplace(PowerState::SLEEP, + std::make_shared>(sleepBlocker)); POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine_currentState: func is End."); } @@ -59,8 +64,9 @@ bool PowerStateMachine::Init() { POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine:: Init start"); - InitStateMap(); stateAction_ = PowerMgrFactory::GetDeviceStateAction(); + InitStateMap(); + if (powerStateCBDeathRecipient_ == nullptr) { powerStateCBDeathRecipient_ = new PowerStateCallbackDeathRecipient(); } @@ -85,7 +91,8 @@ void PowerStateMachine::InitStateMap() controllerMap_.emplace(PowerState::AWAKE, std::make_shared(PowerState::AWAKE, shared_from_this(), [this] { POWER_HILOGI(MODULE_SERVICE, "StateController_AWAKE: func is Start."); - uint32_t ret = stateAction_->SetDisplayState(DisplayState::DISPLAY_ON); + mDeviceState_.screenState.lastOnTime = GetTickCount(); + uint32_t ret = this->stateAction_->SetDisplayState(DisplayState::DISPLAY_ON); if (ret != ActionResult::SUCCESS) { POWER_HILOGE(MODULE_SERVICE, "Failed to go to AWAKE, Display Err"); return TransitResult::HDI_ERR; @@ -98,7 +105,8 @@ void PowerStateMachine::InitStateMap() controllerMap_.emplace(PowerState::INACTIVE, std::make_shared(PowerState::INACTIVE, shared_from_this(), [this] { POWER_HILOGI(MODULE_SERVICE, "StateController_INACTIVE: func is Start."); - uint32_t ret = stateAction_->SetDisplayState(DisplayState::DISPLAY_OFF); + mDeviceState_.screenState.lastOffTime = GetTickCount(); + uint32_t ret = this->stateAction_->SetDisplayState(DisplayState::DISPLAY_OFF); if (ret != ActionResult::SUCCESS) { POWER_HILOGE(MODULE_SERVICE, "Failed to go to INACTIVE, Display Err"); return TransitResult::HDI_ERR; @@ -111,12 +119,12 @@ void PowerStateMachine::InitStateMap() controllerMap_.emplace(PowerState::SLEEP, std::make_shared(PowerState::SLEEP, shared_from_this(), [this] { POWER_HILOGI(MODULE_SERVICE,"StateController_SLEEP: func is Start."); - uint32_t ret = stateAction_->SetDisplayState(DisplayState::DISPLAY_OFF); + uint32_t ret = this->stateAction_->SetDisplayState(DisplayState::DISPLAY_OFF); if (ret != ActionResult::SUCCESS) { POWER_HILOGE(MODULE_SERVICE, "Failed to go to SLEEP, Display Err"); return TransitResult::HDI_ERR; } - ret = stateAction_->GoToSleep(onSuspend, onWakeup, false); + ret = this->stateAction_->GoToSleep(onSuspend, onWakeup, false); if (ret != ActionResult::SUCCESS) { POWER_HILOGE(MODULE_SERVICE, "Failed to go to SLEEP, Sleep Err"); return TransitResult::HDI_ERR; @@ -147,10 +155,17 @@ void PowerStateMachine::onWakeup() handler->SendEvent(PowermsEventHandler::SYSTEM_WAKE_UP_MSG, 0, 0); } -void PowerStateMachine::SuspendDeviceInner(pid_t pid, int64_t callTimeMs, SuspendDeviceType type, bool suspendImmed, +void PowerStateMachine::SuspendDeviceInner(pid_t pid, + int64_t callTimeMs, + SuspendDeviceType type, + bool suspendImmed, bool ignoreScreenState) { POWER_HILOGI(MODULE_SERVICE, "PID: %{public}d Try to Suspend Device!!", pid); + if (type > SuspendDeviceType::SUSPEND_DEVICE_REASON_MAX) { + POWER_HILOGE(MODULE_SERVICE, "Invalid type: %{public}d", type); + return; + } // Check the screen state if (!ignoreScreenState) { if (stateAction_ != nullptr) { @@ -167,26 +182,39 @@ void PowerStateMachine::SuspendDeviceInner(pid_t pid, int64_t callTimeMs, Suspen POWER_HILOGI(MODULE_SERVICE, "SuspendDeviceInner: fun is End!"); } -void PowerStateMachine::WakeupDeviceInner(pid_t pid, int64_t callTimeMs, WakeupDeviceType type, - const std::string& details, const std::string& pkgName) +void PowerStateMachine::WakeupDeviceInner(pid_t pid, + int64_t callTimeMs, + WakeupDeviceType type, + const std::string& details, + const std::string& pkgName) { POWER_HILOGI(MODULE_SERVICE, "PID: %{public}d Try to Wakeup Device!!", pid); - + if (type > WakeupDeviceType::WAKEUP_DEVICE_MAX) { + POWER_HILOGE(MODULE_SERVICE, "Invalid type: %{public}d", type); + return; + } // Call legacy wakeup, Check the screen state if (stateAction_ != nullptr) { stateAction_->Wakeup(callTimeMs, type, details, pkgName); } mDeviceState_.lastWakeupDeviceTime = callTimeMs; + ResetInactiveTimer(); SetState(PowerState::AWAKE, GetReasonByWakeType(type), true); POWER_HILOGD(MODULE_SERVICE, "Wakeup Device Call"); } -void PowerStateMachine::RefreshActivityInner(pid_t pid, int64_t callTimeMs, UserActivityType type, +void PowerStateMachine::RefreshActivityInner(pid_t pid, + int64_t callTimeMs, + UserActivityType type, bool needChangeBacklight) { POWER_HILOGI(MODULE_SERVICE, "PID: %{public}d Start to RefreshActivity!!", pid); + if (type > UserActivityType::USER_ACTIVITY_TYPE_MAX) { + POWER_HILOGE(MODULE_SERVICE, "Invalid type: %{public}d", type); + return; + } // The minimum refreshactivity interval is 100ms!! int64_t now = GetTickCount(); if ((mDeviceState_.lastRefreshActivityTime + MIN_TIME_MS_BETWEEN_USERACTIVITIES) > now) { @@ -199,6 +227,7 @@ void PowerStateMachine::RefreshActivityInner(pid_t pid, int64_t callTimeMs, User if (stateAction_ != nullptr) { stateAction_->RefreshActivity(callTimeMs, type, needChangeBacklight ? REFRESH_ACTIVITY_NEED_CHANGE_LIGHTS : REFRESH_ACTIVITY_NO_CHANGE_LIGHTS); + mDeviceState_.screenState.lastOnTime = GetTickCount(); stateAction_->SetDisplayState(DisplayState::DISPLAY_ON); } //reset timer @@ -214,6 +243,7 @@ bool PowerStateMachine::ForceSuspendDeviceInner(pid_t pid, int64_t callTimeMs) { POWER_HILOGI(MODULE_SERVICE, "ForceSuspendDeviceInner: fun is Start!"); if (stateAction_ != nullptr) { + currentState_ = PowerState::SLEEP; stateAction_->GoToSleep(onSuspend, onWakeup, true); } @@ -239,12 +269,19 @@ void PowerStateMachine::ReceiveScreenEvent(bool isScreenOn) POWER_HILOGI(MODULE_SERVICE, "ReceiveScreenEvent: fun is Start!"); std::lock_guard lock(mutex_); auto prestate = mDeviceState_.screenState.state; - mDeviceState_.screenState.lastUpdateTime = GetTickCount(); + if (isScreenOn) { + mDeviceState_.screenState.lastOnTime = GetTickCount(); + } else { + mDeviceState_.screenState.lastOffTime = GetTickCount(); + } if (prestate != mDeviceState_.screenState.state) { NotifyPowerStateChanged(isScreenOn ? PowerState::AWAKE : PowerState::INACTIVE); } - POWER_HILOGI(MODULE_SERVICE, "receive new screen event, new state is %{public}d, at %{public}" PRId64 "", - mDeviceState_.screenState.state, mDeviceState_.screenState.lastUpdateTime); + POWER_HILOGI(MODULE_SERVICE, + "receive new screen event, new state is %{public}d, (%{public}lld, %{public}lld)", + mDeviceState_.screenState.state, + mDeviceState_.screenState.lastOnTime, + mDeviceState_.screenState.lastOffTime); } void PowerStateMachine::RegisterPowerStateCallback(const sptr& callback) @@ -258,8 +295,12 @@ void PowerStateMachine::RegisterPowerStateCallback(const sptrAddDeathRecipient(powerStateCBDeathRecipient_); } - POWER_HILOGI(MODULE_SERVICE, "%{public}s, object = %p, callback = %p, listeners.size = %d," - " insertOk = %d", __func__, object.GetRefPtr(), callback.GetRefPtr(), + POWER_HILOGI(MODULE_SERVICE, + "%{public}s, object = %{public}p, callback = %{public}p, listeners.size = %{public}d," + " insertOk = %{public}d", + __func__, + object.GetRefPtr(), + callback.GetRefPtr(), static_cast(powerStateListeners_.size()), retIt.second); } @@ -275,16 +316,118 @@ void PowerStateMachine::UnRegisterPowerStateCallback(const sptrRemoveDeathRecipient(powerStateCBDeathRecipient_); } - POWER_HILOGI(MODULE_SERVICE, "%{public}s, object = %p, callback = %p, listeners.size = %d," - " eraseNum = %zu", __func__, object.GetRefPtr(), callback.GetRefPtr(), + POWER_HILOGI(MODULE_SERVICE, + "%{public}s, object = %{public}p, callback = %{public}p, listeners.size = %{public}d," + " eraseNum = %zu", + __func__, + object.GetRefPtr(), + callback.GetRefPtr(), static_cast(powerStateListeners_.size()), eraseNum); } +static const char* GetReasonTypeString(StateChangeReason type) +{ + switch (type) { + case StateChangeReason::STATE_CHANGE_REASON_INIT: + return "INIT"; + case StateChangeReason::STATE_CHANGE_REASON_TIMEOUT: + return "TIMEOUT"; + case StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK: + return "RUNNING_LOCK"; + case StateChangeReason::STATE_CHANGE_REASON_BATTERY: + return "BATTERY"; + case StateChangeReason::STATE_CHANGE_REASON_THERMAL: + return "THERMAL"; + case StateChangeReason::STATE_CHANGE_REASON_WORK: + return "WORK"; + case StateChangeReason::STATE_CHANGE_REASON_SYSTEM: + return "SYSTEM"; + case StateChangeReason::STATE_CHANGE_REASON_APPLICATION: + return "APPLICATION"; + case StateChangeReason::STATE_CHANGE_REASON_SETTINGS: + return "SETTINGS"; + case StateChangeReason::STATE_CHANGE_REASON_HARD_KEY: + return "HARD_KEY"; + case StateChangeReason::STATE_CHANGE_REASON_TOUCH: + return "TOUCH"; + case StateChangeReason::STATE_CHANGE_REASON_CABLE: + return "CABLE"; + case StateChangeReason::STATE_CHANGE_REASON_SENSOR: + return "SENSOR"; + case StateChangeReason::STATE_CHANGE_REASON_LID: + return "LID"; + case StateChangeReason::STATE_CHANGE_REASON_CAMERA: + return "CAMERA"; + case StateChangeReason::STATE_CHANGE_REASON_ACCESSIBILITY: + return "ACCESSIBILITY"; + case StateChangeReason::STATE_CHANGE_REASON_REMOTE: + return "REMOTE"; + case StateChangeReason::STATE_CHANGE_REASON_UNKNOWN: + return "UNKNOWN"; + default: + break; + } + + return "UNKNOWN"; +} + +static const char* GetPowerStateString(PowerState state) +{ + switch (state) { + case PowerState::AWAKE: + return "AWAKE"; + case PowerState::INACTIVE: + return "INACTIVE"; + case PowerState::SLEEP: + return "SLEEP"; + case PowerState::UNKNOWN: + return "UNKNOWN"; + default: + break; + } + + return "UNKNOWN"; +} + +static const char* GetRunningLockTypeString(RunningLockType type) +{ + switch (type) { + case RunningLockType::RUNNINGLOCK_SCREEN: + return "SCREEN"; + case RunningLockType::RUNNINGLOCK_BACKGROUND: + return "BACKGROUND"; + case RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL: + return "PROXIMITY_SCREEN_CONTROL"; + case RunningLockType::RUNNINGLOCK_BUTT: + return "BUTT"; + default: + break; + } + + return "UNKNOWN"; +} + +void PowerStateMachine::EnableMock(IDeviceStateAction* mockAction) +{ + POWER_HILOGI(MODULE_SERVICE, "enableMock: fun is Start!"); + std::lock_guard lock(mutex_); + // reset to awake state when mock + currentState_ = PowerState::AWAKE; + ResetInactiveTimer(); + + std::unique_ptr mock(mockAction); + stateAction_.reset(); + stateAction_ = std::move(mock); +} + void PowerStateMachine::NotifyPowerStateChanged(PowerState state) { - POWER_HILOGI(MODULE_SERVICE, "%{public}s state = %u, listeners.size = %d", __func__, - static_cast(state), static_cast(powerStateListeners_.size())); + POWER_HILOGI(MODULE_SERVICE, + "%{public}s state = %u, listeners.size = %{public}d", + __func__, + static_cast(state), + static_cast(powerStateListeners_.size())); std::lock_guard lock(mutex_); int64_t now = GetTickCount(); // Send Notification event @@ -314,14 +457,15 @@ void PowerStateMachine::SendEventToPowerMgrNotify(PowerState state, int64_t call } else if (state == PowerState::INACTIVE) { notify->PublishScreenOffEvents(callTime); } else { - POWER_HILOGI(MODULE_SERVICE, "No need to publish event, state:%d", state); + POWER_HILOGI(MODULE_SERVICE, "No need to publish event, state:%{public}d", state); } POWER_HILOGD(MODULE_SERVICE, "SendEventToPowerMgrNotify: fun is End!"); } const std::string TASK_UNREG_POWER_STATE_CALLBACK = "PowerState_UnRegPowerStateCB"; -void PowerStateMachine::PowerStateCallbackDeathRecipient::OnRemoteDied(const wptr& remote) +void PowerStateMachine::PowerStateCallbackDeathRecipient::OnRemoteDied( + const wptr& remote) { POWER_HILOGD(MODULE_SERVICE, "OnRemoteDied: fun is Start!"); if (remote == nullptr || remote.promote() == nullptr) { @@ -338,7 +482,8 @@ void PowerStateMachine::PowerStateCallbackDeathRecipient::OnRemoteDied(const wpt return; } sptr callback = iface_cast(remote.promote()); - std::function unRegFunc = std::bind(&PowerMgrService::UnRegisterPowerStateCallback, pms, callback); + std::function unRegFunc = + std::bind(&PowerMgrService::UnRegisterPowerStateCallback, pms, callback); handler->PostTask(unRegFunc, TASK_UNREG_POWER_STATE_CALLBACK); POWER_HILOGD(MODULE_SERVICE, "OnRemoteDied: fun is End!"); } @@ -361,7 +506,7 @@ void PowerStateMachine::SetDelayTimer(int64_t delayTime, int32_t event) void PowerStateMachine::CancelDelayTimer(int32_t event) { - POWER_HILOGD(MODULE_SERVICE, "CancelDelayTimer: fun is Start!"); + POWER_HILOGD(MODULE_SERVICE, "CancelDelayTimer (%{public}d): fun is Start!", event); auto pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { return; @@ -384,7 +529,8 @@ void PowerStateMachine::ResetInactiveTimer() if (this->CheckRunningLock(PowerState::INACTIVE)) { const uint32_t HALF = 2; - this->SetDelayTimer(this->GetDisplayOffTime() / HALF, PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG); + this->SetDelayTimer(this->GetDisplayOffTime() / HALF, + PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG); } POWER_HILOGD(MODULE_SERVICE, "ResetInactiveTimer: fun is End!"); } @@ -397,14 +543,15 @@ void PowerStateMachine::ResetSleepTimer() CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG); if (this->CheckRunningLock(PowerState::SLEEP)) { - this->SetDelayTimer(this->GetSleepTime(), PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG); + this->SetDelayTimer(this->GetSleepTime(), + PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG); } POWER_HILOGD(MODULE_SERVICE, "ResetSleepTimer: fun is End!"); } void PowerStateMachine::HandleDelayTimer(int32_t event) { - POWER_HILOGD(MODULE_SERVICE, "handle delay timer: (%d)", event); + POWER_HILOGD(MODULE_SERVICE, "handle delay timer: (%{public}d)", event); switch (event) { case PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG: HandleActivityTimeout(); @@ -426,36 +573,67 @@ void PowerStateMachine::HandleDelayTimer(int32_t event) void PowerStateMachine::HandleActivityTimeout() { - POWER_HILOGI(MODULE_SERVICE, "HandleActivityTimeout (%{public}d)", stateAction_->GetDisplayState()); - if (stateAction_->GetDisplayState() == DisplayState::DISPLAY_ON) { - const uint32_t HALF = 2; + POWER_HILOGI(MODULE_SERVICE, "HandleActivityTimeout (%{public}d)", + stateAction_->GetDisplayState()); + DisplayState dispState = stateAction_->GetDisplayState(); + const uint32_t HALF = 2; + if (!this->CheckRunningLock(PowerState::INACTIVE)) { + POWER_HILOGW(MODULE_SERVICE, "RunningLock is blocking to transit to INACTIVE"); + return; + } + if (dispState == DisplayState::DISPLAY_ON) { stateAction_->SetDisplayState(DisplayState::DISPLAY_DIM); - SetDelayTimer(GetDisplayOffTime() / HALF, PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG); + SetDelayTimer(GetDisplayOffTime() / HALF, + PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG); + } else { + POWER_HILOGW(MODULE_SERVICE, + "HandleActivityTimeout when display: %{public}d", dispState); } POWER_HILOGI(MODULE_SERVICE, "HandleActivityTimeout: fun is End!"); } void PowerStateMachine::HandleActivityOffTimeout() { - POWER_HILOGI(MODULE_SERVICE, "HandleActivityDimTimeout (%{public}d)", stateAction_->GetDisplayState()); - if (stateAction_->GetDisplayState() == DisplayState::DISPLAY_DIM) { + POWER_HILOGI(MODULE_SERVICE, "HandleActivityOffTimeout (%{public}d)", + stateAction_->GetDisplayState()); + if (!this->CheckRunningLock(PowerState::INACTIVE)) { + POWER_HILOGW(MODULE_SERVICE, "RunningLock is blocking to transit to INACTIVE"); + return; + } + DisplayState dispState = stateAction_->GetDisplayState(); + // Also transit state when ON if system not support DIM + if (dispState == DisplayState::DISPLAY_ON + || dispState == DisplayState::DISPLAY_DIM) { SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT); + } else { + POWER_HILOGW(MODULE_SERVICE, + "HandleActivityOffTimeout when display: %{public}d", dispState); } POWER_HILOGI(MODULE_SERVICE, "HandleActivityOffTimeOut: fun is End!"); } void PowerStateMachine::HandleActivitySleepTimeout() { - POWER_HILOGI(MODULE_SERVICE, "HandleActivityOffTimeout (%{public}d)", stateAction_->GetDisplayState()); - if (stateAction_->GetDisplayState() == DisplayState::DISPLAY_OFF) { + POWER_HILOGI(MODULE_SERVICE, "HandleActivitySleepTimeout (%{public}d)", + stateAction_->GetDisplayState()); + if (!this->CheckRunningLock(PowerState::SLEEP)) { + POWER_HILOGW(MODULE_SERVICE, "RunningLock is blocking to transit to SLEEP"); + return; + } + DisplayState dispState = stateAction_->GetDisplayState(); + if (dispState == DisplayState::DISPLAY_OFF) { SetState(PowerState::SLEEP, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT); + } else { + POWER_HILOGW(MODULE_SERVICE, + "HandleActivitySleepTimeout when display: %{public}d", dispState); } POWER_HILOGI(MODULE_SERVICE, "HandleActivitySleepTimeout: fun is End!"); } void PowerStateMachine::HandleSystemWakeup() { - POWER_HILOGI(MODULE_SERVICE, "HandleSystemWakeup (%{public}d)", stateAction_->GetDisplayState()); + POWER_HILOGI(MODULE_SERVICE, "HandleSystemWakeup (%{public}d)", + stateAction_->GetDisplayState()); if (IsScreenOn()) { SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_SYSTEM, true); } else { @@ -483,37 +661,57 @@ bool PowerStateMachine::CheckRunningLock(PowerState state) } std::shared_ptr> pLock = iterator->second; - for (std::vector::const_iterator iter = pLock->begin(); iter != pLock->end(); ++iter) { + for (std::vector::const_iterator iter = pLock->begin(); + iter != pLock->end(); ++iter) { uint32_t count = runningLockMgr->GetValidRunningLockNum(*iter); if (count > 0) { - POWER_HILOGE(MODULE_SERVICE, "RunningLock(%d) is locking (%d) for state (%d)",*iter, count, state); + POWER_HILOGE(MODULE_SERVICE, + "RunningLock %{public}s is locking (count=%{public}d), blocking %{public}s", + GetRunningLockTypeString(*iter), + count, + GetPowerStateString(state)); return false; } } - POWER_HILOGI(MODULE_SERVICE, "No RunningLock block for state (%d)", state); + POWER_HILOGI(MODULE_SERVICE, "No RunningLock block for state (%{public}d)", state); return true; } +void PowerStateMachine::SetDisplayOffTime(int64_t time) +{ + POWER_HILOGI(MODULE_SERVICE, "SetDisplayOffTime: %{public}lld", time); + displayOffTime_ = time; + if (currentState_ == PowerState::AWAKE) { + ResetInactiveTimer(); + } +} + +void PowerStateMachine::SetSleepTime(int64_t time) +{ + POWER_HILOGI(MODULE_SERVICE, "SetSleepTime: %{public}lld", time); + sleepTime_ = time; + if (currentState_ == PowerState::INACTIVE) { + ResetSleepTimer(); + } +} + int64_t PowerStateMachine::GetDisplayOffTime() { - POWER_HILOGI(MODULE_SERVICE, "GetDisplayOffTime: fun is Start!"); - // temp solution, will get from SettingsProvider - const uint32_t time = 5000; - return time; + POWER_HILOGI(MODULE_SERVICE, "GetDisplayOffTime: %{public}lld", displayOffTime_); + return displayOffTime_; } int64_t PowerStateMachine::GetSleepTime() { - POWER_HILOGI(MODULE_SERVICE, "GetSleepTime: fun is Start!"); - // temp solution, will get from mode xml - const uint32_t time = 5000; - return time; + POWER_HILOGI(MODULE_SERVICE, "GetSleepTime: %{public}lld", sleepTime_); + return sleepTime_; } bool PowerStateMachine::SetState(PowerState state, StateChangeReason reason, bool force) { - POWER_HILOGI(MODULE_SERVICE, "SetState state=%{public}d, reason=%{public}d, force=%{public}d", + POWER_HILOGI(MODULE_SERVICE, + "SetState state=%{public}d, reason=%{public}d, force=%{public}d", state, reason, force); auto iterator = controllerMap_.find(state); if (iterator == controllerMap_.end()) { @@ -555,20 +753,19 @@ StateChangeReason PowerStateMachine::GetReasonByUserActivity(UserActivityType ty return ret; } - StateChangeReason PowerStateMachine::GetReasonByWakeType(WakeupDeviceType type) { POWER_HILOGI(MODULE_SERVICE, "GetReasonByWakeType Start:%{public}d", type); StateChangeReason ret = StateChangeReason::STATE_CHANGE_REASON_UNKNOWN; switch (type) { - case WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON: + case WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON: // fall through case WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY: ret = StateChangeReason::STATE_CHANGE_REASON_HARD_KEY; break; case WakeupDeviceType::WAKEUP_DEVICE_APPLICATION: ret = StateChangeReason::STATE_CHANGE_REASON_APPLICATION; break; - case WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN: + case WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN: // fall through case WakeupDeviceType::WAKEUP_DEVICE_HDMI: ret = StateChangeReason::STATE_CHANGE_REASON_CABLE; break; @@ -609,7 +806,7 @@ StateChangeReason PowerStateMachine::GetReasionBySuspendType(SuspendDeviceType t case SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH: ret = StateChangeReason::STATE_CHANGE_REASON_LID; break; - case SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON: + case SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON: // fall through case SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON: ret = StateChangeReason::STATE_CHANGE_REASON_HARD_KEY; break; @@ -629,7 +826,50 @@ StateChangeReason PowerStateMachine::GetReasionBySuspendType(SuspendDeviceType t return ret; } -TransitResult PowerStateMachine::StateController::TransitTo(StateChangeReason reason, bool ignoreLock) +void PowerStateMachine::DumpInfo(std::string& result) +{ + result.append("POWER MANAGER DUMP (hidumper -PowerStateMachine):\n"); + result.append("Current State: ") + .append(GetPowerStateString(GetState())) + .append(" Reasion: ") + .append(ToString(static_cast( + controllerMap_.find(GetState())->second->lastReason_))) + .append(" Time: ") + .append(ToString(controllerMap_.find(GetState())->second->lastTime_)) + .append("\n"); + + result.append("DUMP DETAILS:\n"); + result.append("Last Screen On: ") + .append(ToString(mDeviceState_.screenState.lastOnTime)) + .append("\n"); + result.append("Last Screen Off: ") + .append(ToString(mDeviceState_.screenState.lastOffTime)) + .append("\n"); + result.append("Last SuspendDevice: ") + .append(ToString(mDeviceState_.lastSuspendDeviceTime)) + .append("\n"); + result.append("Last WakeupDevice: ") + .append(ToString(mDeviceState_.lastWakeupDeviceTime)) + .append("\n"); + result.append("Last Refresh: ") + .append(ToString(mDeviceState_.lastRefreshActivityTime)) + .append("\n"); + + result.append("DUMP EACH STATES:\n"); + for (auto it = controllerMap_.begin(); it != controllerMap_.end(); it++) { + result.append("State: ") + .append(GetPowerStateString(it->second->GetState())) + .append(" Reason:") + .append(GetReasonTypeString(it->second->lastReason_)) + .append(" Time:") + .append(ToString(it->second->lastTime_)) + .append("\n"); + } +} + +TransitResult PowerStateMachine::StateController::TransitTo( + StateChangeReason reason, + bool ignoreLock) { POWER_HILOGI(MODULE_SERVICE, "TransitTo start"); std::shared_ptr owner = owner_.lock(); @@ -637,11 +877,15 @@ TransitResult PowerStateMachine::StateController::TransitTo(StateChangeReason re POWER_HILOGE(MODULE_SERVICE, "TransitTo: no owner"); return TransitResult::OTHER_ERR; } - POWER_HILOGI(MODULE_SERVICE, "Transit from %{public}d to %{public}d for %{public}d", - owner->currentState_, this->state_, reason); + POWER_HILOGI(MODULE_SERVICE, + "Transit from %{public}s to %{public}s for %{public}s", + GetPowerStateString(owner->currentState_), + GetPowerStateString(this->state_), + GetReasonTypeString(reason)); TransitResult ret = TransitResult::OTHER_ERR; if (!CheckState()) { - POWER_HILOGE(MODULE_SERVICE, "TransitTo: already in %d", owner->currentState_); + POWER_HILOGE(MODULE_SERVICE, "TransitTo: already in %{public}d", + owner->currentState_); return TransitResult::ALREADY_IN_STATE; } if (!ignoreLock && !owner->CheckRunningLock(GetState())) { @@ -651,6 +895,7 @@ TransitResult PowerStateMachine::StateController::TransitTo(StateChangeReason re ret = action_(); if (ret == TransitResult::SUCCESS) { lastReason_ = reason; + lastTime_ = GetTickCount(); owner->currentState_ = GetState(); owner->NotifyPowerStateChanged(owner->currentState_); } diff --git a/services/native/src/running_lock_mgr.cpp b/services/native/src/running_lock_mgr.cpp index 5278b06a..3d214a86 100644 --- a/services/native/src/running_lock_mgr.cpp +++ b/services/native/src/running_lock_mgr.cpp @@ -45,7 +45,8 @@ bool RunningLockMgr::Init() if (runningLockAction_ == nullptr) { runningLockAction_ = PowerMgrFactory::GetRunningLockAction(); if (!runningLockAction_) { - POWER_HILOGE(MODULE_SERVICE, "RunningLockMgr::Init create RunningLockMgr fail"); + POWER_HILOGE(MODULE_SERVICE, + "RunningLockMgr::Init create RunningLockMgr fail"); return false; } } @@ -68,8 +69,10 @@ bool RunningLockMgr::Init() bool RunningLockMgr::InitLocks() { - lockCounters_.emplace(RunningLockType::RUNNINGLOCK_SCREEN, std::make_shared( + lockCounters_.emplace(RunningLockType::RUNNINGLOCK_SCREEN, + std::make_shared( RunningLockType::RUNNINGLOCK_SCREEN, [this](bool active) { + POWER_HILOGI(MODULE_SERVICE, "RUNNINGLOCK_SCREEN action start!"); auto pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { return; @@ -79,39 +82,97 @@ bool RunningLockMgr::InitLocks() return; } if (active) { - stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK); + POWER_HILOGI(MODULE_SERVICE, "RUNNINGLOCK_SCREEN active!"); + stateMachine->SetState(PowerState::AWAKE, + StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK); + stateMachine->CancelDelayTimer( + PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG); + stateMachine->CancelDelayTimer( + PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG); } else { - stateMachine->ResetInactiveTimer(); + POWER_HILOGI(MODULE_SERVICE, "RUNNINGLOCK_SCREEN inactive!"); + if (stateMachine->GetState() == PowerState::AWAKE) { + stateMachine->ResetInactiveTimer(); + } else { + POWER_HILOGD(MODULE_SERVICE, + "Screen On unlock in state: %{public}d", + stateMachine->GetState()); + } } }) ); - lockCounters_.emplace(RunningLockType::RUNNINGLOCK_BACKGROUND, std::make_shared( - RunningLockType::RUNNINGLOCK_SCREEN, [this](bool active) { + lockCounters_.emplace(RunningLockType::RUNNINGLOCK_BACKGROUND, + std::make_shared( + RunningLockType::RUNNINGLOCK_BACKGROUND, [this](bool active) { + POWER_HILOGI(MODULE_SERVICE, "RUNNINGLOCK_BACKGROUND action start!"); + auto pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + return; + } + auto stateMachine = pms->GetPowerStateMachine(); + if (stateMachine == nullptr) { + return; + } auto iterator = systemLocks_.find(SystemLockType::SYSTEM_LOCK_APP); if (iterator == systemLocks_.end()) { return; } std::shared_ptr pSysLock = iterator->second; if (active) { + POWER_HILOGI(MODULE_SERVICE, "RUNNINGLOCK_BACKGROUND active!"); + stateMachine->CancelDelayTimer( + PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG); pSysLock->Lock(); } else { + POWER_HILOGI(MODULE_SERVICE, "RUNNINGLOCK_BACKGROUND inactive!"); + if (stateMachine->GetState() == PowerState::INACTIVE) { + stateMachine->ResetSleepTimer(); + } else { + POWER_HILOGD(MODULE_SERVICE, + "Background unlock in state: %{public}d", + stateMachine->GetState()); + } pSysLock->Unlock(); } }) ); - lockCounters_.emplace(RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL, std::make_shared( - RunningLockType::RUNNINGLOCK_SCREEN, [this](bool active) { + lockCounters_.emplace(RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL, + std::make_shared( + RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL, [this](bool active) { + POWER_HILOGI(MODULE_SERVICE, + "RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL action start!"); + auto pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + return; + } + auto stateMachine = pms->GetPowerStateMachine(); + if (stateMachine == nullptr) { + return; + } auto iterator = systemLocks_.find(SystemLockType::SYSTEM_LOCK_APP); if (iterator == systemLocks_.end()) { return; } std::shared_ptr pSysLock = iterator->second; if (active) { + POWER_HILOGI(MODULE_SERVICE, + "RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL active!"); + stateMachine->SetState(PowerState::AWAKE, + StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK); + stateMachine->CancelDelayTimer( + PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG); + stateMachine->CancelDelayTimer( + PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG); pSysLock->Lock(); proximityController_.Enable(); } else { + POWER_HILOGI(MODULE_SERVICE, + "RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL inactive!"); + stateMachine->SetState(PowerState::AWAKE, + StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK); + stateMachine->ResetInactiveTimer(); pSysLock->Unlock(); proximityController_.Disable(); } @@ -121,7 +182,8 @@ bool RunningLockMgr::InitLocks() return true; } -std::shared_ptr RunningLockMgr::GetRunningLockInner(const sptr& token) +std::shared_ptr RunningLockMgr::GetRunningLockInner( + const sptr& token) { std::lock_guard lock(mutex_); auto iterator = runningLocks_.find(token); @@ -132,15 +194,20 @@ std::shared_ptr RunningLockMgr::GetRunningLockInner(const sptr return nullptr; } -std::shared_ptr RunningLockMgr::CreateRunningLock(const sptr& token, - const RunningLockInfo& runningLockInfo, const UserIPCInfo& userIPCinfo) +std::shared_ptr RunningLockMgr::CreateRunningLock( + const sptr& token, + const RunningLockInfo& runningLockInfo, + const UserIPCInfo& userIPCinfo) { auto lockInner = RunningLockInner::CreateRunningLockInner(runningLockInfo, userIPCinfo); if (lockInner == nullptr) { return nullptr; } - POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::%{public}s : ok,name = %s,type = %d", __func__, - runningLockInfo.name.c_str(), runningLockInfo.type); + POWER_HILOGD(MODULE_SERVICE, + "RunningLockMgr::%{public}s : ok,name = %{public}s,type = %{public}d", + __func__, + runningLockInfo.name.c_str(), + runningLockInfo.type); mutex_.lock(); runningLocks_.emplace(token, lockInner); @@ -151,7 +218,8 @@ std::shared_ptr RunningLockMgr::CreateRunningLock(const sptr token) { - POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :token = %p", __func__, token.GetRefPtr()); + POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :token = %{public}p", + __func__, token.GetRefPtr()); auto lockInner = GetRunningLockInner(token); if (lockInner == nullptr) { return; @@ -165,15 +233,20 @@ void RunningLockMgr::ReleaseLock(const sptr token) token->RemoveDeathRecipient(runningLockDeathRecipient_); } -void RunningLockMgr::RemoveAndPostUnlockTask(const sptr& token, uint32_t timeOutMS) +void RunningLockMgr::RemoveAndPostUnlockTask( + const sptr& token, uint32_t timeOutMS) { auto handler = handler_.lock(); if (handler == nullptr) { return; } const string& tokenStr = to_string(reinterpret_cast(token.GetRefPtr())); - POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :token = %p,tokenStr = %s,timeOutMS = %d", __func__, - token.GetRefPtr(), tokenStr.c_str(), timeOutMS); + POWER_HILOGI(MODULE_SERVICE, + "RunningLockMgr::%{public}s :token = %p,tokenStr = %s,timeOutMS = %d", + __func__, + token.GetRefPtr(), + tokenStr.c_str(), + timeOutMS); handler->RemoveTask(tokenStr); if (timeOutMS != 0) { std::function unLockFunc = std::bind(&RunningLockMgr::UnLock, this, token); @@ -181,19 +254,25 @@ void RunningLockMgr::RemoveAndPostUnlockTask(const sptr& token, u } } -void RunningLockMgr::Lock(const sptr& token, const RunningLockInfo& runningLockInfo, +void RunningLockMgr::Lock(const sptr& token, + const RunningLockInfo& runningLockInfo, const UserIPCInfo& userIPCinfo, uint32_t timeOutMS) { - POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :token = %p,name = %s,type = %d", __func__, - token.GetRefPtr(), runningLockInfo.name.c_str(), runningLockInfo.type); + POWER_HILOGI(MODULE_SERVICE, + "RunningLockMgr::%{public}s :token = %p,name = %s,type = %d", + __func__, + token.GetRefPtr(), + runningLockInfo.name.c_str(), + runningLockInfo.type); auto lockInner = GetRunningLockInner(token); if (lockInner == nullptr) { - POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::Lock failed, can't find %p", token.GetRefPtr()); + POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::Lock failed, can't find %{public}p", + token.GetRefPtr()); return; } if (!lockInner->GetDisabled()) { - POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::Lock, this lock(%s) is already on", + POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::Lock, this lock(%s) is already on", lockInner->GetRunningLockName().c_str()); return; } @@ -201,13 +280,17 @@ void RunningLockMgr::Lock(const sptr& token, const RunningLockInf auto iterator = lockCounters_.find(lockInner->GetRunningLockType()); if (iterator == lockCounters_.end()) { - POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::Lock failed, unsupported type %d", + POWER_HILOGD(MODULE_SERVICE, + "RunningLockMgr::Lock failed, unsupported type %{public}d", lockInner->GetRunningLockType()); return; } std::shared_ptr counter = iterator->second; counter->Increase(); - + POWER_HILOGD(MODULE_SERVICE, + "LockCounter: %{public}d, %{public}d", + lockInner->GetRunningLockType(), + counter->GetCount()); if (timeOutMS > 0) { RemoveAndPostUnlockTask(token, timeOutMS); } @@ -215,14 +298,16 @@ void RunningLockMgr::Lock(const sptr& token, const RunningLockInf void RunningLockMgr::UnLock(const sptr token) { - POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :token = %p", __func__, token.GetRefPtr()); + POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :token = %p", + __func__, token.GetRefPtr()); auto lockInner = GetRunningLockInner(token); if (lockInner == nullptr) { return; } if (lockInner->GetDisabled()) { - POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::Unlock, this lock(%s) is already off", + POWER_HILOGD(MODULE_SERVICE, + "RunningLockMgr::Unlock, this lock(%{public}s) is already off", lockInner->GetRunningLockName().c_str()); return; } @@ -231,7 +316,8 @@ void RunningLockMgr::UnLock(const sptr token) auto iterator = lockCounters_.find(lockInner->GetRunningLockType()); if (iterator == lockCounters_.end()) { - POWER_HILOGD(MODULE_SERVICE, "RunningLockMgr::Unlock failed, unsupported type %d", + POWER_HILOGD(MODULE_SERVICE, + "RunningLockMgr::Unlock failed, unsupported type %{public}d", lockInner->GetRunningLockType()); return; } @@ -264,7 +350,8 @@ uint32_t RunningLockMgr::GetValidRunningLockNum(RunningLockType type) { auto iterator = lockCounters_.find(type); if (iterator == lockCounters_.end()) { - POWER_HILOGD(MODULE_SERVICE, "GetValidRunningLockNum failed, unsupported type %d", type); + POWER_HILOGD(MODULE_SERVICE, + "GetValidRunningLockNum failed, unsupported type %d", type); return 0; } std::shared_ptr counter = iterator->second; @@ -284,9 +371,12 @@ bool RunningLockMgr::ExistValidRunningLock() return false; } -void RunningLockMgr::SetWorkTriggerList(const sptr& token, const WorkTriggerList& workTriggerList) +void RunningLockMgr::SetWorkTriggerList(const sptr& token, + const WorkTriggerList& workTriggerList) { - POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :token = %p", __func__, token.GetRefPtr()); + POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :token = %p", + __func__, + token.GetRefPtr()); auto lockInner = GetRunningLockInner(token); if (lockInner == nullptr) { @@ -302,10 +392,12 @@ void RunningLockMgr::SetWorkTriggerList(const sptr& token, const UnLockReally(token, lockInner); } -void RunningLockMgr::NotifyHiViewRunningLockInfo(const string& tokenStr, const RunningLockInner& lockInner, +void RunningLockMgr::NotifyHiViewRunningLockInfo(const string& tokenStr, + const RunningLockInner& lockInner, RunningLockChangedType changeType) const { - string lockName = lockInner.GetRunningLockName().empty() ? "NULL" : lockInner.GetRunningLockName(); + string lockName = lockInner.GetRunningLockName().empty() + ? "NULL" : lockInner.GetRunningLockName(); string msg = "token=" + tokenStr + " lockName=" + lockName + " type=" + to_string(ToUnderlying(lockInner.GetRunningLockType())); auto MakeNotifyInfo = [](int uid, int pid, const string& tag) { @@ -337,8 +429,11 @@ void RunningLockMgr::CheckOverTime() } int64_t curTime = GetTickCount(); int64_t detectTime = curTime - CHECK_TIMEOUT_INTERVAL_MS; - POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :cur = %" PRId64 " detectTime=%" PRId64 "", __func__, - curTime, detectTime); + POWER_HILOGI(MODULE_SERVICE, + "RunningLockMgr::%{public}s :cur = %" PRId64 " detectTime=%" PRId64 "", + __func__, + curTime, + detectTime); if (detectTime < 0) { return; } @@ -368,7 +463,8 @@ void RunningLockMgr::SendCheckOverTimeMsg(int64_t delayTime) if (handler == nullptr) { return; } - POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s ,delay = %" PRId64 "", __func__, + POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s ,delay = %" PRId64 "", + __func__, delayTime); handler->SendEvent(PowermsEventHandler::CHECK_RUNNINGLOCK_OVERTIME_MSG, 0, delayTime); } @@ -396,8 +492,10 @@ void RunningLockMgr::NotifyRunningLockChanged(const sptr& token, break; } case NOTIFY_RUNNINGLOCK_OVERTIME: { - POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :%s token=%s", __func__, - runninglockNotifyStr_.at(changeType).c_str(), tokenStr.c_str()); + POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s :%s token=%s", + __func__, + runninglockNotifyStr_.at(changeType).c_str(), + tokenStr.c_str()); break; } default: { @@ -408,41 +506,56 @@ void RunningLockMgr::NotifyRunningLockChanged(const sptr& token, bool RunningLockMgr::MatchProxyMap(const UserIPCInfo& userIPCinfo) { if (proxyMap_.empty()) { - POWER_HILOGD(MODULE_SERVICE, "%{public}s ret false by proxyMap_.empty(), useripcinfo uid = %d pid = %d.", - __func__, userIPCinfo.uid, userIPCinfo.pid); + POWER_HILOGD(MODULE_SERVICE, + "%{public}s ret false by proxyMap_.empty(), useripcinfo uid = %d pid = %d.", + __func__, + userIPCinfo.uid, + userIPCinfo.pid); return false; } auto it = proxyMap_.find(userIPCinfo.uid); // 1. Find pidset by uid. if (it == proxyMap_.end()) { - POWER_HILOGD(MODULE_SERVICE, "%{public}s not find uidmap, useripcinfo uid = %d pid = %d.", - __func__, userIPCinfo.uid, userIPCinfo.pid); + POWER_HILOGD(MODULE_SERVICE, + "%{public}s not find uidmap, useripcinfo uid = %d pid = %d.", + __func__, + userIPCinfo.uid, + userIPCinfo.pid); return false; } auto& pidset = it->second; // 2. Count by owner pid. if (pidset.count(userIPCinfo.pid) > 0) { - POWER_HILOGD(MODULE_SERVICE, "%{public}s find uidmap and count pid > 1, useripcinfo uid = %d pid = %d.", - __func__, userIPCinfo.uid, userIPCinfo.pid); + POWER_HILOGD(MODULE_SERVICE, + "%{public}s find uidmap and count pid > 1, useripcinfo uid = %d pid = %d.", + __func__, + userIPCinfo.uid, + userIPCinfo.pid); return true; } - POWER_HILOGD(MODULE_SERVICE, "%{public}s find uidmap and count pid = 0,count(-1) = %d, useripcinfo uid = %d " + POWER_HILOGD(MODULE_SERVICE, + "%{public}s find uidmap and count pid = 0,count(-1) = %d, useripcinfo uid = %d " "pid = %d.", __func__, static_cast(pidset.count(INVALID_PID)), - userIPCinfo.uid, userIPCinfo.pid); + userIPCinfo.uid, + userIPCinfo.pid); // 3. Count by INVALID_PID, return true when proxy (uid, -1). return (pidset.count(INVALID_PID) > 0); } -void RunningLockMgr::SetRunningLockDisableFlag(std::shared_ptr& lockInner, bool forceRefresh) +void RunningLockMgr::SetRunningLockDisableFlag( + std::shared_ptr& lockInner, + bool forceRefresh) { if (proxyMap_.empty() && (!forceRefresh)) { /** * Generally when proxymap empty keep the default value false. - * When PGManager cancel proxy uid and pid, because we update the proxy map before, so we should refresh + * When PGManager cancel proxy uid and pid, + * because we update the proxy map before, so we should refresh * all of the runninglock disable flag always. */ - POWER_HILOGD(MODULE_SERVICE, "%{public}s ret false by proxyMap_.empty() and forceRefresh = false", __func__); + POWER_HILOGD(MODULE_SERVICE, + "%{public}s ret false by proxyMap_.empty() and forceRefresh = false", __func__); lockInner->SetDisabled(false); return; } @@ -451,7 +564,8 @@ void RunningLockMgr::SetRunningLockDisableFlag(std::shared_ptr if (matched) { // Matched the lock owner useripcinfo, set disabled directly. lockInner->SetDisabled(true); - POWER_HILOGD(MODULE_SERVICE, "%{public}s MatchProxyMap matched by useripcinfo uid = %d pid = %d.", + POWER_HILOGD(MODULE_SERVICE, + "%{public}s MatchProxyMap matched by useripcinfo uid = %d pid = %d.", __func__, userIPCinfo.uid, userIPCinfo.pid); return; } @@ -460,33 +574,45 @@ void RunningLockMgr::SetRunningLockDisableFlag(std::shared_ptr if (list.empty()) { // Not matched, and no trigger list. lockInner->SetDisabled(false); - POWER_HILOGD(MODULE_SERVICE, "%{public}s useripcinfo not matched and list is empty().", __func__); + POWER_HILOGD(MODULE_SERVICE, + "%{public}s useripcinfo not matched and list is empty().", __func__); return; } bool triggerMatched = true; - // Have trigger list, need to judge whether or not all of the list matched, otherwise we should hold the lock. + // Have trigger list, need to judge whether or not all of the list matched, + // otherwise we should hold the lock. for (auto& workTrigger : list) { UserIPCInfo triggerIPCInfo {workTrigger->GetUid(), workTrigger->GetPid()}; if (!MatchProxyMap(triggerIPCInfo)) { triggerMatched = false; - POWER_HILOGD(MODULE_SERVICE, "%{public}s workTrigger not matched uid = %d, pid = %d.", __func__, - triggerIPCInfo.uid, triggerIPCInfo.pid); + POWER_HILOGD(MODULE_SERVICE, + "%{public}s workTrigger not matched uid = %d, pid = %d.", + __func__, + triggerIPCInfo.uid, + triggerIPCInfo.pid); break; } } lockInner->SetDisabled(triggerMatched); - POWER_HILOGD(MODULE_SERVICE, "%{public}s useripcinfo uid = %d pid = %d, triggerMatched = %d.", __func__, - userIPCinfo.uid, userIPCinfo.pid, triggerMatched); + POWER_HILOGD(MODULE_SERVICE, + "%{public}s useripcinfo uid = %d pid = %d, triggerMatched = %d.", + __func__, + userIPCinfo.uid, + userIPCinfo.pid, + triggerMatched); } -void RunningLockMgr::LockReally(const sptr& token, std::shared_ptr& lockInner) +void RunningLockMgr::LockReally(const sptr& token, + std::shared_ptr& lockInner) { if (lockInner->GetReallyLocked()) { - POWER_HILOGD(MODULE_SERVICE, "%{public}s :return by lockInner->GetReallyLocked() == true.", __func__); + POWER_HILOGD(MODULE_SERVICE, + "%{public}s :return by lockInner->GetReallyLocked() == true.", __func__); return; } if (lockInner->GetDisabled()) { - POWER_HILOGD(MODULE_SERVICE, "%{public}s :return by lockInner->GetDisabled() == true.", __func__); + POWER_HILOGD(MODULE_SERVICE, + "%{public}s :return by lockInner->GetDisabled() == true.", __func__); return; } runningLockAction_->Acquire(lockInner->GetRunningLockType()); @@ -494,22 +620,27 @@ void RunningLockMgr::LockReally(const sptr& token, std::shared_pt NotifyRunningLockChanged(token, lockInner, NOTIFY_RUNNINGLOCK_ADD); POWER_HILOGD(MODULE_SERVICE, "%{public}s :called end.", __func__); } -void RunningLockMgr::UnLockReally(const sptr& token, std::shared_ptr& lockInner) +void RunningLockMgr::UnLockReally(const sptr& token, + std::shared_ptr& lockInner) { /** - * Case 1: Firstly PGManager ProxyRunningLock by uid and pid, secondly application lock by the same uid and - * pid, when call Lock() we matched the proxymap, and no really locked to kernel. So we don't need to - * unlocked to kernel. - * Case 2: Firstly application create the runninglock and call Lock(), and then PGManager Proxyed it, + * Case 1: Firstly PGManager ProxyRunningLock by uid and pid, + * secondly application lock by the same uid and + * pid, when call Lock() we matched the proxymap, and no really locked to kernel. + * So we don't need to unlocked to kernel. + * Case 2: Firstly application create the runninglock and call Lock(), + * and then PGManager Proxyed it, * At this time, lock should be unlocked to kernel because we have locked to kernel for it. */ if (!lockInner->GetReallyLocked()) { - POWER_HILOGD(MODULE_SERVICE, "%{public}s :return by lockInner->GetReallyLocked() == false.", __func__); + POWER_HILOGD(MODULE_SERVICE, + "%{public}s :return by lockInner->GetReallyLocked() == false.", __func__); return; } // If disabled, unlock to the kernel. if (!lockInner->GetDisabled()) { - POWER_HILOGD(MODULE_SERVICE, "%{public}s :return by lockInner->GetDisabled() == false.", __func__); + POWER_HILOGD(MODULE_SERVICE, + "%{public}s :return by lockInner->GetDisabled() == false.", __func__); return; } runningLockAction_->Release(lockInner->GetRunningLockType()); @@ -535,7 +666,8 @@ void RunningLockMgr::ProxyRunningLockInner(bool proxyLock) void RunningLockMgr::ProxyRunningLock(bool proxyLock, pid_t uid, pid_t pid) { - POWER_HILOGD(MODULE_SERVICE, "%{public}s :proxyLock = %d, uid = %d, pid = %d", __func__, + POWER_HILOGD(MODULE_SERVICE, + "%{public}s :proxyLock = %d, uid = %d, pid = %d", __func__, proxyLock, uid, pid); auto it = proxyMap_.find(uid); if (proxyLock) { @@ -543,7 +675,8 @@ void RunningLockMgr::ProxyRunningLock(bool proxyLock, pid_t uid, pid_t pid) if (it == proxyMap_.end()) { unordered_set pidset({pid}); proxyMap_.emplace(uid, pidset); - POWER_HILOGD(MODULE_SERVICE, "%{public}s :proxyLock = true first emplace {uid = %d, pid = %d}", + POWER_HILOGD(MODULE_SERVICE, + "%{public}s :proxyLock = true first emplace {uid = %d, pid = %d}", __func__, uid, pid); } else { if (pid == INVALID_PID) { @@ -555,37 +688,43 @@ void RunningLockMgr::ProxyRunningLock(bool proxyLock, pid_t uid, pid_t pid) auto& pidset = it->second; pidset.insert(pid); } - POWER_HILOGD(MODULE_SERVICE, "%{public}s :proxyLock = true uid = %d exist insert pid = %d", + POWER_HILOGD(MODULE_SERVICE, + "%{public}s :proxyLock = true uid = %d exist insert pid = %d", __func__, uid, pid); } // 1. Set the matched runninglock inner disabled flag. } else { if (it == proxyMap_.end()) { // No insert proxy info, nothing to erase. - POWER_HILOGD(MODULE_SERVICE, "%{public}s :proxyLock = false not find by uid = %d", + POWER_HILOGD(MODULE_SERVICE, + "%{public}s :proxyLock = false not find by uid = %d", __func__, uid); return; } // 1. Clear the runninglock inner disabled flag 2.removed from proxyMap_ if (pid == INVALID_PID) { proxyMap_.erase(uid); - POWER_HILOGD(MODULE_SERVICE, "%{public}s :proxyLock = false pid = -1 rmv uid = %d map", + POWER_HILOGD(MODULE_SERVICE, + "%{public}s :proxyLock = false pid = -1 rmv uid = %d map", __func__, uid); } else { auto& pidset = it->second; pidset.erase(pid); - POWER_HILOGD(MODULE_SERVICE, "%{public}s :proxyLock = false uid = %d erase single pid = %d", + POWER_HILOGD(MODULE_SERVICE, + "%{public}s :proxyLock = false uid = %d erase single pid = %d", __func__, uid, pid); if (pidset.size() == 0) { proxyMap_.erase(uid); - POWER_HILOGD(MODULE_SERVICE, "%{public}s :pidset.size()=0 erase uid keymap", __func__); + POWER_HILOGD(MODULE_SERVICE, + "%{public}s :pidset.size()=0 erase uid keymap", __func__); } } } ProxyRunningLockInner(proxyLock); } -void RunningLockMgr::NotifyHiView(RunningLockChangedType changeType, const std::string& msg) const +void RunningLockMgr::NotifyHiView(RunningLockChangedType changeType, + const std::string& msg) const { if (msg.empty()) { return; @@ -593,8 +732,50 @@ void RunningLockMgr::NotifyHiView(RunningLockChangedType changeType, const std:: const int logLevel = 2; const string &tag = runninglockNotifyStr_.at(changeType); HiviewDFX::HiSysEvent::Write(HiviewDFX::HiSysEvent::Domain::POWERMGR, "Lock", - HiviewDFX::HiSysEvent::EventType::FAULT, "LOG_LEVEL", logLevel, "TAG", tag, "MESSAGE", msg); - POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s: %s %s", __func__, tag.c_str(), msg.c_str()); + HiviewDFX::HiSysEvent::EventType::FAULT, + "LOG_LEVEL", + logLevel, + "TAG", + tag, + "MESSAGE", + msg); + POWER_HILOGI(MODULE_SERVICE, "RunningLockMgr::%{public}s: %s %s", + __func__, + tag.c_str(), + msg.c_str()); +} + +void RunningLockMgr::EnableMock(IRunningLockAction* mockAction) +{ + std::shared_ptr mock(mockAction); + for(auto it = systemLocks_.begin(); it != systemLocks_.end(); it++) { + it->second->EnableMock(mock); + } + runningLockAction_ = mock; + + // reset lock list; + runningLocks_.clear(); + for(auto it = lockCounters_.begin(); it != lockCounters_.end(); it++) { + it->second->Clear(); + } +} + +static const char* GetRunningLockTypeString(RunningLockType type) +{ + switch (type) { + case RunningLockType::RUNNINGLOCK_SCREEN: + return "SCREEN"; + case RunningLockType::RUNNINGLOCK_BACKGROUND: + return "BACKGROUND"; + case RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL: + return "PROXIMITY_SCREEN_CONTROL"; + case RunningLockType::RUNNINGLOCK_BUTT: + return "BUTT"; + default: + break; + } + + return "UNKNOWN"; } void RunningLockMgr::DumpInfo(std::string& result) @@ -605,11 +786,20 @@ void RunningLockMgr::DumpInfo(std::string& result) result.append("POWER MANAGER DUMP (hidumper -runninglock):\n"); result.append(" totalSize=").append(ToString(runningLocks_.size())) .append(" validSize=").append(ToString(validSize)).append("\n"); + result.append("Summary By Type: \n"); + for (auto it = lockCounters_.begin(); it != lockCounters_.end(); it++) { + result.append(GetRunningLockTypeString(it->first)) + .append(": ") + .append(ToString(it->second->GetCount())) + .append("\n"); + } if (runningLocks_.empty()) { + result.append("Lock List is Empty. \n"); return; } + result.append("Dump Lock List: \n"); auto curTick = GetTickCount(); int index = 0; for (auto& it : runningLocks_) { @@ -624,26 +814,21 @@ void RunningLockMgr::DumpInfo(std::string& result) auto& ipcinfo = lockInner->GetUserIPCInfo(); result.append(" index=").append(ToString(index)) .append(" time=").append(ToString(curTick - lockInner->GetLockTimeMs())) - .append(" type=").append(ToString(static_cast(lockinfo.type))) + .append(" type=").append(GetRunningLockTypeString(lockinfo.type)) .append(" name=").append(lockinfo.name) .append(" uid=").append(ToString(ipcinfo.uid)) .append(" pid=").append(ToString(ipcinfo.pid)) .append(" disable=").append(ToString(lockInner->GetDisabled())) - .append(" reallyLocked=").append(ToString(lockInner->GetReallyLocked())) - .append(" overTimeFlag=").append(ToString(lockInner->GetOverTimeFlag())).append("\n"); - - auto& worklist = lockinfo.workTriggerlist; - result.append(" workTrigger: size=").append(ToString(worklist.size())).append("\n"); - if (worklist.size() != 0) { - for (auto& work : worklist) { - result.append(" name=").append(work->GetName()) - .append(" uid=").append(ToString(work->GetUid())) - .append(" pid=").append(ToString(work->GetPid())) - .append(" abilityid=").append(ToString(work->GetAbilityId())).append("\n"); - } - } - result.append("\n"); + .append("\n"); } + + result.append("Peripherals Info: \n") + .append("Proximity: ") + .append("Enabled: ") + .append(ToString(proximityController_.IsEnabled())) + .append("Status: ") + .append(ToString(proximityController_.GetStatus())) + .append("\n"); } void RunningLockMgr::RunningLockDeathRecipient::OnRemoteDied(const wptr& remote) @@ -661,7 +846,9 @@ void RunningLockMgr::RunningLockDeathRecipient::OnRemoteDied(const wptr forceUnLockFunc = std::bind(&PowerMgrService::ForceUnLock, pms, remote.promote()); - POWER_HILOGI(MODULE_SERVICE, "RunningLockDeathRecipient::%{public}s :remote.promote() = %p", __func__, + POWER_HILOGI(MODULE_SERVICE, + "RunningLockDeathRecipient::%{public}s :remote.promote() = %p", + __func__, remote.promote().GetRefPtr()); handler->PostTask(forceUnLockFunc, TASK_RUNNINGLOCK_FORCEUNLOCK); } @@ -700,7 +887,16 @@ uint32_t RunningLockMgr::LockCounter::Decrease() return counter_; } -RunningLockMgr::ProximityController::ProximityController() : enabled_(false) +void RunningLockMgr::LockCounter::Clear() +{ + if (counter_ > 0) { + activate_(false); + } + counter_ = 0; +} + +RunningLockMgr::ProximityController::ProximityController() : + enabled_(false), status_(0) { } @@ -718,7 +914,7 @@ void RunningLockMgr::ProximityController::Disable() enabled_ = false; } -void RunningLockMgr::ProximityController::OnProximity() +void RunningLockMgr::ProximityController::OnClose() { if (!enabled_) { return; @@ -731,7 +927,9 @@ void RunningLockMgr::ProximityController::OnProximity() if (stateMachine == nullptr) { return; } - stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_SENSOR, true); + stateMachine->SetState(PowerState::INACTIVE, + StateChangeReason::STATE_CHANGE_REASON_SENSOR, + true); } void RunningLockMgr::ProximityController::OnAway() @@ -747,7 +945,24 @@ void RunningLockMgr::ProximityController::OnAway() if (stateMachine == nullptr) { return; } - stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_SENSOR, true); + stateMachine->SetState(PowerState::AWAKE, + StateChangeReason::STATE_CHANGE_REASON_SENSOR, + true); +} + +void RunningLockMgr::SetProximity(uint32_t status) +{ + switch (status) + { + case PROXIMITY_CLOSE: + proximityController_.OnClose(); + break; + case PROXIMITY_AWAY: + proximityController_.OnAway(); + break; + default: + break; + } } } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/test/unittest/BUILD.gn b/services/native/test/unittest/BUILD.gn index b4504f2c..403c5cbb 100644 --- a/services/native/test/unittest/BUILD.gn +++ b/services/native/test/unittest/BUILD.gn @@ -22,7 +22,9 @@ config("module_private_config") { include_dirs = [ "include", + "mock", "//utils/system/safwk/native/include", + "//third_party/googletest/googletest/include", ] } @@ -97,6 +99,32 @@ ohos_unittest("test_power_state_machine") { "${powermgr_service_path}/native/src/actions:powermgr_actions", "${powermgr_utils_path}:powermgr_utils", "//third_party/googletest:gtest_main", + "//third_party/googletest:gmock_main", + "//utils/native/base:utils", + ] + + external_deps = deps_ex +} + +ohos_unittest("test_power_mgr_mock") { + module_out_path = module_output_path + + sources = [ + "src/power_mgr_mock_test.cpp", + ] + + configs = [ + "${powermgr_utils_path}:utils_config", + ":module_private_config", + ] + + deps = [ + "${powermgr_native_innerkits_path}:powermgr_client", + "${powermgr_service_path}:powermgrservice", + "${powermgr_service_path}/native/src/actions:powermgr_actions", + "${powermgr_utils_path}:powermgr_utils", + "//third_party/googletest:gtest_main", + "//third_party/googletest:gmock_main", "//utils/native/base:utils", ] diff --git a/services/native/test/unittest/include/power_mgr_mock_test.h b/services/native/test/unittest/include/power_mgr_mock_test.h new file mode 100644 index 00000000..155d350c --- /dev/null +++ b/services/native/test/unittest/include/power_mgr_mock_test.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2021 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 POWERMGR_POWERMGR_MOCK_TEST_H +#define POWERMGR_POWERMGR_MOCK_TEST_H + +#include +#include + +#include "mock_lock_action.h" +#include "mock_power_action.h" +#include "mock_state_action.h" +#include "power_common.h" +#include "power_mgr_service.h" + +namespace OHOS { +namespace PowerMgr { + +constexpr int NEXT_WAIT_TIME_S = 1; +constexpr int ASYNC_WAIT_TIME_S = 3; +constexpr int REFRESHACTIVITY_WAIT_TIME_S = 8; +constexpr int SCREEN_OFF_WAIT_TIME_S = (DEFAULT_DISPLAY_OFF_TIME / 1000); +constexpr int SCREEN_DIM_WAIT_TIME_S = (SCREEN_OFF_WAIT_TIME_S / 2); +constexpr int SLEEP_WAIT_TIME_S = (DEFAULT_SLEEP_TIME / 1000); + +class PowerMgrMockTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; +} // namespace PowerMgr +} // namespace OHOS + +#endif // POWERMGR_POWERMGR_MOCK_TEST_H diff --git a/services/native/test/unittest/mock/mock_lock_action.h b/services/native/test/unittest/mock/mock_lock_action.h new file mode 100644 index 00000000..0d7108ba --- /dev/null +++ b/services/native/test/unittest/mock/mock_lock_action.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2021 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 POWERMGR_MOCK_LOCK_ACTION_H +#define POWERMGR_MOCK_LOCK_ACTION_H + +#include +#include "actions/irunning_lock_action.h" + +namespace OHOS { +namespace PowerMgr { +class MockLockAction : public IRunningLockAction { +public: + MockLockAction() = default; + virtual ~MockLockAction() = default; + MOCK_METHOD1(Acquire, void(RunningLockType type)); + MOCK_METHOD1(Release, void(RunningLockType type)); + MOCK_METHOD2(Lock, void(RunningLockType type, const std::string& tag)); + MOCK_METHOD2(Unlock, void(RunningLockType type, const std::string& tag)); + +}; +} // namespace PowerMgr +} // namespace OHOS + +#endif // POWERMGR_MOCK_POWER_ACTION_H \ No newline at end of file diff --git a/services/native/test/unittest/mock/mock_power_action.h b/services/native/test/unittest/mock/mock_power_action.h new file mode 100644 index 00000000..ffa2c006 --- /dev/null +++ b/services/native/test/unittest/mock/mock_power_action.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2021 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 POWERMGR_MOCK_POWER_ACTION_H +#define POWERMGR_MOCK_POWER_ACTION_H + +#include "actions/idevice_power_action.h" +#include + +namespace OHOS { +namespace PowerMgr { +class MockPowerAction : public IDevicePowerAction { +public: + MockPowerAction() = default; + virtual ~MockPowerAction() = default; + MOCK_METHOD1(Reboot, void(const std::string& reason)); + MOCK_METHOD1(Shutdown, void(const std::string& reason)); +}; +} // namespace PowerMgr +} // namespace OHOS + +#endif // POWERMGR_MOCK_POWER_ACTION_H \ No newline at end of file diff --git a/services/native/test/unittest/mock/mock_state_action.h b/services/native/test/unittest/mock/mock_state_action.h new file mode 100644 index 00000000..a11c1449 --- /dev/null +++ b/services/native/test/unittest/mock/mock_state_action.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2021 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 POWERMGR_MOCK_STATE_ACTION_H +#define POWERMGR_MOCK_STATE_ACTION_H + +#include "actions/idevice_state_action.h" +#include + +namespace OHOS { +namespace PowerMgr { +class MockStateAction : public IDeviceStateAction { +public: + MockStateAction() = default; + virtual ~MockStateAction() = default; + MOCK_METHOD3(Suspend, void(int64_t callTimeMs, SuspendDeviceType type, uint32_t flags)); + MOCK_METHOD0(ForceSuspend, void()); + MOCK_METHOD4(Wakeup, void(int64_t callTimeMs, WakeupDeviceType type, + const std::string& details, const std::string& pkgName)); + MOCK_METHOD3(RefreshActivity, void(int64_t callTimeMs, UserActivityType type, uint32_t flags)); + MOCK_METHOD0(GetDisplayState, DisplayState()); + MOCK_METHOD1(SetDisplayState, uint32_t(DisplayState state)); + MOCK_METHOD3(GoToSleep, uint32_t(std::function onSuspend, std::function onWakeup, bool force)); +}; +} // namespace PowerMgr +} // namespace OHOS + +#endif // POWERMGR_MOCK_STATE_ACTION_H \ No newline at end of file diff --git a/services/native/test/unittest/src/power_mgr_mock_test.cpp b/services/native/test/unittest/src/power_mgr_mock_test.cpp new file mode 100644 index 00000000..33bf2a95 --- /dev/null +++ b/services/native/test/unittest/src/power_mgr_mock_test.cpp @@ -0,0 +1,3090 @@ +/* + * Copyright (c) 2021 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 "power_mgr_mock_test.h" + +using namespace testing::ext; +using namespace OHOS::PowerMgr; +using namespace OHOS; +using namespace std; +using ::testing::_; + +static sptr service; +static MockStateAction* stateAction; +static MockPowerAction* powerAction; +static MockLockAction* lockAction; + +static void ResetMockAction() +{ + stateAction = new MockStateAction(); + powerAction = new MockPowerAction(); + lockAction = new MockLockAction(); + service->EnableMock(stateAction, powerAction, lockAction); +} + +void PowerMgrMockTest::SetUpTestCase(void) +{ + // create singleton service object at the beginning + service = DelayedSpSingleton::GetInstance(); + service->OnStart(); + ResetMockAction(); +} + +void PowerMgrMockTest::TearDownTestCase(void) +{ + service->OnStop(); + DelayedSpSingleton::DestroyInstance(); + delete stateAction; + delete powerAction; + delete lockAction; +} + +void PowerMgrMockTest::SetUp(void) +{ +} + +void PowerMgrMockTest::TearDown(void) +{ +} + +/** + * @tc.name: PowerMgrMock001 + * @tc.desc: test RebootDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock001, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock001: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock001:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock001: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*powerAction, Reboot(std::string("test"))).Times(1); + pms->RebootDevice(std::string("test")); + sleep(ASYNC_WAIT_TIME_S); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock001:End."); + GTEST_LOG_(INFO) << "PowerMgrMock001: end."; +} + +/** + * @tc.name: PowerMgrMock002 + * @tc.desc: test ShutDownDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock002, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock002: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock002:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock002: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*powerAction, Shutdown(std::string("test"))).Times(1); + pms->ShutDownDevice(std::string("test")); + sleep(ASYNC_WAIT_TIME_S); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock002:End."); + GTEST_LOG_(INFO) << "PowerMgrMock002: end."; +} + + +/** + * @tc.name: PowerMgrMock003 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock003, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock003: start."; + + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:Start."); + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock003: Failed to get PowerMgrService"; + } + + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:Start mock."); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:Start suspend."); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:end."); + GTEST_LOG_(INFO) << "PowerMgrMock003: end."; +} + +/** + * @tc.name: PowerMgrMock004 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock004, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock004: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock004:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock004: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock004:End ."); + GTEST_LOG_(INFO) << "PowerMgrMock004: end."; +} + +/** + * @tc.name: PowerMgrMock005 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock005, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock005: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock005:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock005: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT, false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT, false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock005:End"); + GTEST_LOG_(INFO) << "PowerMgrMock005: end."; +} + +/** + * @tc.name: PowerMgrMock006 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock006, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock006: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock006:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock006: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH, false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH, false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock006:End."); + GTEST_LOG_(INFO) << "PowerMgrMock006: end."; +} + +/** + * @tc.name: PowerMgrMock007 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock007, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock007: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock007:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock007: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON, false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON, false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock007:End."); + GTEST_LOG_(INFO) << "PowerMgrMock007: end."; +} + +/** + * @tc.name: PowerMgrMock008 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock008, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock008: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock008:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock008: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI , false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI , false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock008:End."); + GTEST_LOG_(INFO) << "PowerMgrMock008: end."; +} + +/** + * @tc.name: PowerMgrMock009 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock009, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock009: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock009:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock009: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON , false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON , false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock009:End."); + GTEST_LOG_(INFO) << "PowerMgrMock009: end."; +} + +/** + * @tc.name: PowerMgrMock010 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock010, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock010: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock010:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock010: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY , false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY , false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock010:End."); + GTEST_LOG_(INFO) << "PowerMgrMock010: end."; +} + +/** + * @tc.name: PowerMgrMock011 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock011, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock011: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock011:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock011: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND , false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND , false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock011:End."); + GTEST_LOG_(INFO) << "PowerMgrMock011: end."; +} + + + +/** + * @tc.name: PowerMgrMock012 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock012, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock012: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock012:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock012: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock012:End."); + GTEST_LOG_(INFO) << "PowerMgrMock012: end."; +} + +/** + * @tc.name: PowerMgrMock013 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock013, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock013: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock013:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock013: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock013:End."); + GTEST_LOG_(INFO) << "PowerMgrMock013: end."; +} + +/** + * @tc.name: PowerMgrMock014 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock014, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock014: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock014:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock014: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock014:End."); + GTEST_LOG_(INFO) << "PowerMgrMock014: end."; +} + +/** + * @tc.name: PowerMgrMock015 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock015, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock015: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock015:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock015: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock015:End."); + GTEST_LOG_(INFO) << "PowerMgrMock015: end."; +} + +/** + * @tc.name: PowerMgrMock016 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock016, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock016: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock016:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock016: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_GESTURE , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_GESTURE , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock016:End."); + GTEST_LOG_(INFO) << "PowerMgrMock016: end."; +} + +/** + * @tc.name: PowerMgrMock017 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock017, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock017: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock017:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock017: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock017:End."); + GTEST_LOG_(INFO) << "PowerMgrMock017: end."; +} + +/** + * @tc.name: PowerMgrMock018 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock018, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock018: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock018:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock018: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock018:End."); + GTEST_LOG_(INFO) << "PowerMgrMock018: end."; +} + +/** + * @tc.name: PowerMgrMock019 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock019, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock019: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock019:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock019: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock019:End."); + GTEST_LOG_(INFO) << "PowerMgrMock019: end."; +} + +/** + * @tc.name: PowerMgrMock020 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock020, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock020: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock020:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock020: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_HDMI , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_HDMI , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock020:End."); + GTEST_LOG_(INFO) << "PowerMgrMock020: end."; +} + +/** + * @tc.name: PowerMgrMock021 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock021, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock021: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock021:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock021: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_LID , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock021:End."); + GTEST_LOG_(INFO) << "PowerMgrMock021: end."; +} + +/** + * @tc.name: PowerMgrMock022 + * @tc.desc: test SuspendDevice and auto sleep by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock022, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock022: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock022:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock022: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sleep(SLEEP_WAIT_TIME_S + 1); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock022:End."); + GTEST_LOG_(INFO) << "PowerMgrMock022: end."; +} + +/** + * @tc.name: PowerMgrMock023 + * @tc.desc: test WakeupDevice and auto suspend and sleep by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock023, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock023: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock023:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock023: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID , std::string("test")); + sleep(SCREEN_DIM_WAIT_TIME_S + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(SLEEP_WAIT_TIME_S + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + sleep(SLEEP_WAIT_TIME_S + 1); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock023:End."); + GTEST_LOG_(INFO) << "PowerMgrMock023: end."; +} + +/** + * @tc.name: PowerMgrMock024 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock024, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock024: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock024:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock024: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_TOUCH, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_TOUCH, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock024:End."); + GTEST_LOG_(INFO) << "PowerMgrMock024: end."; +} + +/** + * @tc.name: PowerMgrMock025 + * @tc.desc: test IsScreenOn by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock025, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock025: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock025:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock025: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_EQ(pms->IsScreenOn(), true); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock025:End."); + GTEST_LOG_(INFO) << "PowerMgrMock025: end."; +} + +/** + * @tc.name: PowerMgrMock026 + * @tc.desc: test IsScreenOn by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock026, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock026: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock026:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock026: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_EQ(pms->IsScreenOn(), true); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock026:End"); + GTEST_LOG_(INFO) << "PowerMgrMock026: end."; +} + +/** + * @tc.name: PowerMgrMock027 + * @tc.desc: test IsScreenOn by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock027, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock027: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock027:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock027: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_OFF)); + EXPECT_EQ(pms->IsScreenOn(), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock027:End."); + GTEST_LOG_(INFO) << "PowerMgrMock027: end."; +} + +/** + * @tc.name: PowerMgrMock028 + * @tc.desc: test IsScreenOn by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock028, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock028: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock028:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock028: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_SUSPEND)); + EXPECT_EQ(pms->IsScreenOn(), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock028:End."); + GTEST_LOG_(INFO) << "PowerMgrMock028: end."; +} + +/** + * @tc.name: PowerMgrMock029 + * @tc.desc: test ForceSuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock029, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock029: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock029:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock029: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_EQ(pms->ForceSuspendDevice(0), true); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock029:End."); + GTEST_LOG_(INFO) << "PowerMgrMock029: end."; +} + +/** + * @tc.name: PowerMgrMock030 + * @tc.desc: test Screen on RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock030, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock030: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock030:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock030: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sleep(SCREEN_DIM_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock030:End."); + GTEST_LOG_(INFO) << "PowerMgrMock030: end."; +} + +/** + * @tc.name: PowerMgrMock031 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock031, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock031: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock031:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock031: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sleep(SLEEP_WAIT_TIME_S + 1); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock031:End."); + GTEST_LOG_(INFO) << "PowerMgrMock031: end."; +} + +/** + * @tc.name: PowerMgrMock032 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock032, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock032: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock032:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock032: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sleep(SCREEN_DIM_WAIT_TIME_S + 1); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock032:End."); + GTEST_LOG_(INFO) << "PowerMgrMock032: end."; +} + +/** + * @tc.name: PowerMgrMock033 + * @tc.desc: test RunningLock release by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock033, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock033: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock033:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock033: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + pms->ReleaseRunningLock(token); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(0); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock033:End."); + GTEST_LOG_(INFO) << "PowerMgrMock033: end."; +} + +/** + * @tc.name: PowerMgrMock034 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock034, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock034: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock034:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock034: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_OTHER, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_OTHER, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock034:End."); + GTEST_LOG_(INFO) << "PowerMgrMock034: end."; +} + +/** + * @tc.name: PowerMgrMock035 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock035, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock035: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock035:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock035: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_BUTTON, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_BUTTON, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock035:End."); + GTEST_LOG_(INFO) << "PowerMgrMock035: end."; +} + +/** + * @tc.name: PowerMgrMock036 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock036, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock036: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock036:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock036: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock036:End."); + GTEST_LOG_(INFO) << "PowerMgrMock036: end."; +} + +/** + * @tc.name: PowerMgrMock037 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock037, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock037: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock037:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock037: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ATTENTION, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ATTENTION, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock037:End."); + GTEST_LOG_(INFO) << "PowerMgrMock037: end."; +} + +/** + * @tc.name: PowerMgrMock038 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock038, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock038: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock038:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock038: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock038:End."); + GTEST_LOG_(INFO) << "PowerMgrMock038: end."; +} + +/** + * @tc.name: PowerMgrMock039 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock039, TestSize.Level2) +{ + UserActivityType abnormaltype={}; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock039: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock039:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock039: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, _, _)).Times(1); + pms->RefreshActivity(0, abnormaltype, true); + + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_EQ(pms->IsScreenOn(), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock039:End."); + GTEST_LOG_(INFO) << "PowerMgrMock039: end."; +} + +/** + * @tc.name: PowerMgrMock040 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock040, TestSize.Level2) +{ + UserActivityType abnormaltype=UserActivityType(6); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock040: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock040:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock040: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, _, _)).Times(0); + pms->RefreshActivity(0, abnormaltype, true); + + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_EQ(pms->IsScreenOn(), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock040:End."); + GTEST_LOG_(INFO) << "PowerMgrMock040: end."; +} + +/** + * @tc.name: PowerMgrMock041 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock041, TestSize.Level2) +{ + WakeupDeviceType abnormaltype=WakeupDeviceType(10); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock041: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock041:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock041: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(0); + EXPECT_CALL(*stateAction, + Wakeup(0, _ , + std::string("test"), _)).Times(0); + pms->WakeupDevice(0, abnormaltype , std::string("test")); + EXPECT_EQ(pms->IsScreenOn(), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock041:End."); + GTEST_LOG_(INFO) << "PowerMgrMock041: end."; +} + +/** + * @tc.name: PowerMgrMock042 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock042, TestSize.Level2) +{ + WakeupDeviceType abnormaltype=WakeupDeviceType(999); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock042: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock042:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock042: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(0); + EXPECT_CALL(*stateAction, + Wakeup(0, _ , + std::string("test"), _)).Times(0); + pms->WakeupDevice(0, abnormaltype , std::string("test")); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock042:End."); + GTEST_LOG_(INFO) << "PowerMgrMock042: end."; +} + + + +/** + * @tc.name: PowerMgrMock043 + * @tc.desc: test WakeupDevice and auto suspend by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock043, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock043: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock043:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock043: Failed to get PowerMgrService"; + } + + // EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + // .Times(::testing::AtLeast(1)) + // .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + sleep(SCREEN_DIM_WAIT_TIME_S + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock043:End."); + GTEST_LOG_(INFO) << "PowerMgrMock043: end."; +} + +/** + * @tc.name: PowerMgrMock044 + * @tc.desc: test WakeupDevice and auto suspend by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock044, TestSize.Level2) +{ + WakeupDeviceType abnormaltype = WakeupDeviceType(10); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock044: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock044:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock044: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + //EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)).Times(0) + sleep(SCREEN_DIM_WAIT_TIME_S/2); + pms->WakeupDevice(0, abnormaltype , std::string("test")); + sleep(SCREEN_DIM_WAIT_TIME_S/2 + 1); + + ResetMockAction(); + GTEST_LOG_(INFO) << "PowerMgrMock044: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock044:End."); +} + +/** + * @tc.name: PowerMgrMock045 + * @tc.desc: test WakeupDevice and auto suspend by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock045, TestSize.Level2) +{ + WakeupDeviceType abnormaltype = WakeupDeviceType(999); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock045: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock045:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock045: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + // EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + // .Times(::testing::AtLeast(1)) + // .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + //EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)).Times(0) + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(SCREEN_OFF_WAIT_TIME_S/2); + pms->WakeupDevice(0, abnormaltype , std::string("test")); + sleep(SCREEN_OFF_WAIT_TIME_S/2 + 1); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock045:End."); + GTEST_LOG_(INFO) << "PowerMgrMock045: end."; +} + +/** + * @tc.name: PowerMgrMock046 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock046, TestSize.Level2) +{ + UserActivityType abnormaltype = UserActivityType(6); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock046: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock046:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock046: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_OFF)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, _, true)).Times(0); + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2); + pms->RefreshActivity(0, abnormaltype, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2 + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock046:End."); + GTEST_LOG_(INFO) << "PowerMgrMock046: end."; +} + +/** + * @tc.name: PowerMgrMock047 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock047, TestSize.Level2) +{ + UserActivityType abnormaltype = {}; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock047: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock047:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock047: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_OFF)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, _, true)).Times(0); + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2); + pms->RefreshActivity(0, abnormaltype, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2 + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock047:End."); + GTEST_LOG_(INFO) << "PowerMgrMock047: end."; +} + +/** + * @tc.name: PowerMgrMock048 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock048, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock048: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock048:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock048: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + sleep(SLEEP_WAIT_TIME_S+1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock048:End"); + GTEST_LOG_(INFO) << "PowerMgrMock048: end."; +} + +/** + * @tc.name: PowerMgrMock049 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock049, TestSize.Level2) +{ + SuspendDeviceType abnormaltype = SuspendDeviceType(10); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock049: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock049:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock049: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); + EXPECT_CALL(*stateAction, + Suspend(0, _, false)).Times(0); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + //EXPECT_CALL(*stateAction,Suspend(0, _ , false)).Times(0); + pms->SuspendDevice(0, abnormaltype, false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock049:End."); + GTEST_LOG_(INFO) << "PowerMgrMock049: end."; +} + +/** + * @tc.name: PowerMgrMock050 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock050, TestSize.Level2) +{ + SuspendDeviceType abnormaltype = SuspendDeviceType(999); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock050: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock050:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock050: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); + EXPECT_CALL(*stateAction, + Suspend(0, _, false)).Times(0); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + pms->SuspendDevice(0, abnormaltype, false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock050:End."); + GTEST_LOG_(INFO) << "PowerMgrMock050: end."; +} + +/** + * @tc.name: PowerMgrMock051 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock051, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock051: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock051:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock051: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + sleep(SLEEP_WAIT_TIME_S+1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock051:End."); + GTEST_LOG_(INFO) << "PowerMgrMock051: end."; +} + +/** + * @tc.name: PowerMgrMock052 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock052, TestSize.Level2) +{ + SuspendDeviceType abnormaltype = SuspendDeviceType(10); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock052: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock052:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock052: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, + Suspend(0, _, false)).Times(0); + pms->SuspendDevice(0, abnormaltype, false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock052:End."); + GTEST_LOG_(INFO) << "PowerMgrMock052: end."; +} + +/** + * @tc.name: PowerMgrMock053 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock053, TestSize.Level2) +{ + SuspendDeviceType abnormaltype = {}; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock053: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock053:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock053: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, + Suspend(0, _, false)); + pms->SuspendDevice(0, abnormaltype, false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock053:End."); + GTEST_LOG_(INFO) << "PowerMgrMock053: end."; +} + + + +/** + * @tc.name: PowerMgrMock054 + * @tc.desc: test ForceSuspendDevice by mock during Inactive + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock054, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock054: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock054:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock054: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->ForceSuspendDevice(0); + sleep(SLEEP_WAIT_TIME_S+1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock054:End."); + GTEST_LOG_(INFO) << "PowerMgrMock054: end."; +} + +/** + * @tc.name: PowerMgrMock056 + * @tc.desc: test SCREEN_ON RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock056, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock056: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock056:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock056: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sleep(SCREEN_DIM_WAIT_TIME_S + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock056:End."); + GTEST_LOG_(INFO) << "PowerMgrMock056: end."; +} + +/** + * @tc.name: PowerMgrMock057 + * @tc.desc: test SCREEN_ON RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock057, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock057: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock057:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock057: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock057:End."); + GTEST_LOG_(INFO) << "PowerMgrMock057: end."; +} + + + +/** + * @tc.name: PowerMgrMock059 + * @tc.desc: test Screen RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock059, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock059: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock059:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock059: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sleep(SCREEN_DIM_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(SCREEN_OFF_WAIT_TIME_S+1); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock059:End."); + GTEST_LOG_(INFO) << "PowerMgrMock059: end."; +} + +/** + * @tc.name: PowerMgrMock060 + * @tc.desc: test Screen RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock060, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock060: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock060:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock060: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + sleep(SLEEP_WAIT_TIME_S*10); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock060:End."); + GTEST_LOG_(INFO) << "PowerMgrMock060: end."; +} + +/** + * @tc.name: PowerMgrMock061 + * @tc.desc: test Screen on RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock061, TestSize.Level2) +{ + int i; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock061: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock061:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock061: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + for(i=0;i<10;i++){ + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + } + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock061:End."); + GTEST_LOG_(INFO) << "PowerMgrMock061: end."; +} + +/** + * @tc.name: PowerMgrMock062 + * @tc.desc: test Screen RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock062, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock062: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock062:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock062: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(1); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sleep(SLEEP_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock062:End."); + GTEST_LOG_(INFO) << "PowerMgrMock062: end."; +} + +/** + * @tc.name: PowerMgrMock063 + * @tc.desc: test Screen RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock063, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock063: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock063:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock063: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_EQ(pms->ForceSuspendDevice(0), true); + //pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sleep(SLEEP_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock063:End."); + GTEST_LOG_(INFO) << "PowerMgrMock063: end."; +} + +/** + * @tc.name: PowerMgrMock064 + * @tc.desc: test Screen RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock064, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock064: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock063:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock064: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, Suspend(_, _, _)).Times(0); + + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + + pms->UnLock(token); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock064:End."); + GTEST_LOG_(INFO) << "PowerMgrMock064: end."; +} + +/** + * @tc.name: PowerMgrMock065 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock065, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock065: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock065:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock065: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_EQ(pms->ForceSuspendDevice(0), true); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock065:End."); + GTEST_LOG_(INFO) << "PowerMgrMock065: end."; +} + +/** + * @tc.name: PowerMgrMock066 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock066, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock066: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock066:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock066: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(SCREEN_DIM_WAIT_TIME_S+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(SCREEN_OFF_WAIT_TIME_S+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(1); + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock066:End."); + GTEST_LOG_(INFO) << "PowerMgrMock066: end."; +} + +/** + * @tc.name: PowerMgrMock067 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock067, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock067: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock067:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock067: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(SCREEN_DIM_WAIT_TIME_S+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(SCREEN_OFF_WAIT_TIME_S+1); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + sleep(SLEEP_WAIT_TIME_S*10); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock067:End."); + GTEST_LOG_(INFO) << "PowerMgrMock067: end."; +} + +/** + * @tc.name: PowerMgrMock068 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock068, TestSize.Level2) +{ + int i; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock068: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock068:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock068: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(SCREEN_DIM_WAIT_TIME_S+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + pms->CreateRunningLock(token, info); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + for(i=0;i<10;i++){ + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + } + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock068:End."); + GTEST_LOG_(INFO) << "PowerMgrMock068: end."; +} + +/** + * @tc.name: PowerMgrMock069 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock069, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock069: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock069:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock069: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sleep(SLEEP_WAIT_TIME_S ); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + // ON_CALL(*stateAction, GetDisplayState()) + // .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + // sleep(SCREEN_DIM_WAIT_TIME_S+1); + // ON_CALL(*stateAction, GetDisplayState()) + // .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + // sleep(SCREEN_OFF_WAIT_TIME_S+1); + // EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + // .Times(1) + // .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock069:End"); + GTEST_LOG_(INFO) << "PowerMgrMock069: end."; +} + +/** + * @tc.name: PowerMgrMock070 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock070, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock070: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock070: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + + // EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + // .Times(1) + // .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_EQ(pms->ForceSuspendDevice(0), true); + sleep(SLEEP_WAIT_TIME_S + 1); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070:End."); + GTEST_LOG_(INFO) << "PowerMgrMock070: end."; +} + +/** + * @tc.name: PowerMgrMock071 + * @tc.desc: test proximity screen control RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock071, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock071: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock071:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock071: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock071:End."); + GTEST_LOG_(INFO) << "PowerMgrMock071: end."; +} + + +/** + * @tc.name: PowerMgrMock072 + * @tc.desc: test proximity screen control RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock072, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock072: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock072:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock072: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_EQ(pms->ForceSuspendDevice(0), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock072:End."); + GTEST_LOG_(INFO) << "PowerMgrMock072: end."; +} + +/** + * @tc.name: PowerMgrMock073 + * @tc.desc: test proximity screen control RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock073, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock073: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock073:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock073: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep(SLEEP_WAIT_TIME_S ); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + //sleep(SCREEN_DIM_WAIT_TIME_S+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(SCREEN_DIM_WAIT_TIME_S+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock073:End."); + GTEST_LOG_(INFO) << "PowerMgrMock073: end."; +} + +/** + * @tc.name: PowerMgrMock074 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock074, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock074: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock074:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock074: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + pms->ReleaseRunningLock(token); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(0); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), false); + + sleep(SCREEN_OFF_WAIT_TIME_S+1); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock074:End."); + GTEST_LOG_(INFO) << "PowerMgrMock074: end."; +} + +/** + * @tc.name: PowerMgrMock075 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock075, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock075: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock075:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock075: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep(SLEEP_WAIT_TIME_S*10); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); + sleep(SLEEP_WAIT_TIME_S+1); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock075:End."); + GTEST_LOG_(INFO) << "PowerMgrMock075: end."; +} + +/** + * @tc.name: PowerMgrMock076 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock076, TestSize.Level2) +{ + int i; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock076: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock076:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock076: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + for(i=0;i<10;i++){ + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + } + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock076:End."); + GTEST_LOG_(INFO) << "PowerMgrMock076: end."; +} + +/** + * @tc.name: PowerMgrMock077 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock077, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock077: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock077:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock077: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sleep(SLEEP_WAIT_TIME_S + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(SCREEN_DIM_WAIT_TIME_S+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(SCREEN_OFF_WAIT_TIME_S+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock077:End."); + GTEST_LOG_(INFO) << "PowerMgrMock077: end."; +} + +/** + * @tc.name: PowerMgrMock078 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock078, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock078: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock078:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock078: Failed to get PowerMgrService"; + } + + //pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->ForceSuspendDevice(0); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock078:End."); + GTEST_LOG_(INFO) << "PowerMgrMock078: end."; +} + +/** + * @tc.name: PowerMgrMock079 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock079, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock079: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock079:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock079: Failed to get PowerMgrService"; + } + + //pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock079:End."); + GTEST_LOG_(INFO) << "PowerMgrMock079: end."; +} + +/** + * @tc.name: PowerMgrMock080 + * @tc.desc: test Auto SuspendDevice by mock after 15s + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock080, TestSize.Level2) +{ + int64_t time =15000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock080: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock080:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock080: Failed to get PowerMgrService"; + } + + pms->SetDisplayOffTime(time); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(SCREEN_DIM_WAIT_TIME_S+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(time/1000+1); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + // EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + sleep(SLEEP_WAIT_TIME_S+1); + + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock080:End."); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock080: end."; +} + +/** + * @tc.name: PowerMgrMock081 + * @tc.desc: test Auto SuspendDevice by mock after 30s + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock081, TestSize.Level2) +{ + int64_t time =30000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock081: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock081:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock081: Failed to get PowerMgrService"; + } + + pms->SetDisplayOffTime(time); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(SCREEN_DIM_WAIT_TIME_S+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(time/1000+1); + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + sleep(SLEEP_WAIT_TIME_S+1); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock081:End"); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock081: end."; +} + +/** + * @tc.name: PowerMgrMock082 + * @tc.desc: test Auto SuspendDevice by mock after 1min + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock082, TestSize.Level2) +{ + int64_t time =60000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock082: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock082: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000+1); + sleep(SLEEP_WAIT_TIME_S+1); + + ResetMockAction(); +pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock082: end."; +} + +/** + * @tc.name: PowerMgrMock083 + * @tc.desc: test Auto SuspendDevice by mock after 2mins + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock083, TestSize.Level2) +{ + int64_t time =120000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock083: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock083: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000+1); + sleep(SLEEP_WAIT_TIME_S+1); + + ResetMockAction(); +pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock083: end."; +} + +/** + * @tc.name: PowerMgrMock084 + * @tc.desc: test Auto SuspendDevice by mock after 5mins + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock084, TestSize.Level2) +{ + int64_t time =300000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock084: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock084: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000+1); + sleep(SLEEP_WAIT_TIME_S+1); + + ResetMockAction(); +pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock084: end."; +} + +/** + * @tc.name: PowerMgrMock085 + * @tc.desc: test Auto SuspendDevice by mock after 10mins + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock085, TestSize.Level2) +{ + int64_t time =600000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock085: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock085: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000+1); + sleep(SLEEP_WAIT_TIME_S+1); + + ResetMockAction(); +pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock085: end."; +} + +/** + * @tc.name: PowerMgrMock086 + * @tc.desc: test Auto DIM by mock after 15s + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock086, TestSize.Level2) +{ + int64_t time =15000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock086: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock086: Failed to get PowerMgrService"; + } + pms->SetDisplayOffTime(time); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086:DeviceStateAction::SetDisplayState."); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086:Start sleep."); + sleep(time/1000-2); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(3); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086: sleep end."); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086:End."); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock086: end."; +} + +/** + * @tc.name: PowerMgrMock087 + * @tc.desc: test Auto DIM by mock after 30s + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock087, TestSize.Level2) +{ + int64_t time =30000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock087: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0087:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock087: Failed to get PowerMgrService"; + } + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000-2); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(3); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock087:End."); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock087: end."; +} + +/** + * @tc.name: PowerMgrMock088 + * @tc.desc: test Auto DIM by mock after 60s + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock088, TestSize.Level2) +{ + int64_t time =60000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock088: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock088: Failed to get PowerMgrService"; + } + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000-2); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(3); + ResetMockAction(); +pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock088: end."; +} + +/** + * @tc.name: PowerMgrMock089 + * @tc.desc: test Auto DIM by mock after 2min + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock089, TestSize.Level2) +{ + int64_t time =120000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock089: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock089: Failed to get PowerMgrService"; + } + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000-2); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(3); + ResetMockAction(); +pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock089: end."; +} + +/** + * @tc.name: PowerMgrMock090 + * @tc.desc: test Auto DIM by mock after 5min + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock090, TestSize.Level2) +{ + int64_t time =300000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock090: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock090: Failed to get PowerMgrService"; + } + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000-2); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(3); + ResetMockAction(); +pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock090: end."; +} + +/** + * @tc.name: PowerMgrMock091 + * @tc.desc: test Auto DIM by mock after 10min + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock091, TestSize.Level2) +{ + int64_t time =600000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock091: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock091: Failed to get PowerMgrService"; + } + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000-2); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(3); + ResetMockAction(); +pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock091: end."; +} \ No newline at end of file diff --git a/test/BUILD.gn b/test/BUILD.gn new file mode 100644 index 00000000..0db7448f --- /dev/null +++ b/test/BUILD.gn @@ -0,0 +1,20 @@ +# Copyright (c) 2021 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. + +import("//base/powermgr/power_manager/powermgr.gni") +import("//build/test.gni") + +group("systemtest") { + testonly = true + deps = [ "systemtest:systemtest_powermgr" ] +} diff --git a/test/systemtest/BUILD.gn b/test/systemtest/BUILD.gn new file mode 100644 index 00000000..843feafd --- /dev/null +++ b/test/systemtest/BUILD.gn @@ -0,0 +1,74 @@ +# Copyright (c) 2021 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. + +import("//base/powermgr/power_manager/powermgr.gni") +import("//build/test.gni") + +module_output_path = "${powermgr_native_part_name}/powermgr_native" + +############################################################################### +config("module_private_config") { + visibility = [ ":*" ] + + include_dirs = [ + "include", + "mock", + "//utils/system/safwk/native/include", + "//third_party/googletest/googletest/include", + ] +} + +deps_ex = [ + "aafwk_standard:base", + "aafwk_standard:want", + "appexecfwk_standard:appexecfwk_base", + "appexecfwk_standard:libeventhandler", + "ipc:ipc_core", + "hiviewdfx_hilog_native:libhilog", + "safwk:system_ability_fwk", + "samgr_L2:samgr_proxy", +] + +##############################systemtest########################################## + +ohos_systemtest("test_power_st_mgr_mock") { + module_out_path = module_output_path + + sources = [ + "src/power_mgr_st_mock_test.cpp", + ] + + configs = [ + "${powermgr_utils_path}:utils_config", + ":module_private_config", + ] + + deps = [ + "${powermgr_native_innerkits_path}:powermgr_client", + "${powermgr_service_path}:powermgrservice", + "${powermgr_service_path}/native/src/actions:powermgr_actions", + "${powermgr_utils_path}:powermgr_utils", + "//third_party/googletest:gtest_main", + "//third_party/googletest:gmock_main", + "//utils/native/base:utils", + ] + + external_deps = deps_ex +} + +group("systemtest_powermgr") { + testonly = true + deps = [ + ":test_power_st_mgr_mock", + ] +} diff --git a/test/systemtest/include/power_mgr_st_mock_test.h b/test/systemtest/include/power_mgr_st_mock_test.h new file mode 100644 index 00000000..db9965a0 --- /dev/null +++ b/test/systemtest/include/power_mgr_st_mock_test.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2021 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 POWERMGR_POWERMGR_ST_MOCK_TEST_H +#define POWERMGR_POWERMGR_ST_MOCK_TEST_H + +#include +#include + +#include "mock_lock_action.h" +#include "mock_power_action.h" +#include "mock_state_action.h" +#include "power_common.h" +#include "power_mgr_service.h" + +namespace OHOS { +namespace PowerMgr { + +constexpr int NEXT_WAIT_TIME_S = 1; +constexpr int ASYNC_WAIT_TIME_S = 3; +constexpr int REFRESHACTIVITY_WAIT_TIME_S = 8; +constexpr int SCREEN_OFF_WAIT_TIME_S = (DEFAULT_DISPLAY_OFF_TIME / 1000); +constexpr int SCREEN_DIM_WAIT_TIME_S = (SCREEN_OFF_WAIT_TIME_S / 2); +constexpr int SLEEP_WAIT_TIME_S = (DEFAULT_SLEEP_TIME / 1000); + +class PowerMgrMockTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; +} // namespace PowerMgr +} // namespace OHOS + +#endif // POWERMGR_POWERMGR_MOCK_TEST_H diff --git a/test/systemtest/mock/mock_lock_action.h b/test/systemtest/mock/mock_lock_action.h new file mode 100644 index 00000000..0d7108ba --- /dev/null +++ b/test/systemtest/mock/mock_lock_action.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2021 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 POWERMGR_MOCK_LOCK_ACTION_H +#define POWERMGR_MOCK_LOCK_ACTION_H + +#include +#include "actions/irunning_lock_action.h" + +namespace OHOS { +namespace PowerMgr { +class MockLockAction : public IRunningLockAction { +public: + MockLockAction() = default; + virtual ~MockLockAction() = default; + MOCK_METHOD1(Acquire, void(RunningLockType type)); + MOCK_METHOD1(Release, void(RunningLockType type)); + MOCK_METHOD2(Lock, void(RunningLockType type, const std::string& tag)); + MOCK_METHOD2(Unlock, void(RunningLockType type, const std::string& tag)); + +}; +} // namespace PowerMgr +} // namespace OHOS + +#endif // POWERMGR_MOCK_POWER_ACTION_H \ No newline at end of file diff --git a/test/systemtest/mock/mock_power_action.h b/test/systemtest/mock/mock_power_action.h new file mode 100644 index 00000000..ffa2c006 --- /dev/null +++ b/test/systemtest/mock/mock_power_action.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2021 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 POWERMGR_MOCK_POWER_ACTION_H +#define POWERMGR_MOCK_POWER_ACTION_H + +#include "actions/idevice_power_action.h" +#include + +namespace OHOS { +namespace PowerMgr { +class MockPowerAction : public IDevicePowerAction { +public: + MockPowerAction() = default; + virtual ~MockPowerAction() = default; + MOCK_METHOD1(Reboot, void(const std::string& reason)); + MOCK_METHOD1(Shutdown, void(const std::string& reason)); +}; +} // namespace PowerMgr +} // namespace OHOS + +#endif // POWERMGR_MOCK_POWER_ACTION_H \ No newline at end of file diff --git a/test/systemtest/mock/mock_state_action.h b/test/systemtest/mock/mock_state_action.h new file mode 100644 index 00000000..a11c1449 --- /dev/null +++ b/test/systemtest/mock/mock_state_action.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2021 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 POWERMGR_MOCK_STATE_ACTION_H +#define POWERMGR_MOCK_STATE_ACTION_H + +#include "actions/idevice_state_action.h" +#include + +namespace OHOS { +namespace PowerMgr { +class MockStateAction : public IDeviceStateAction { +public: + MockStateAction() = default; + virtual ~MockStateAction() = default; + MOCK_METHOD3(Suspend, void(int64_t callTimeMs, SuspendDeviceType type, uint32_t flags)); + MOCK_METHOD0(ForceSuspend, void()); + MOCK_METHOD4(Wakeup, void(int64_t callTimeMs, WakeupDeviceType type, + const std::string& details, const std::string& pkgName)); + MOCK_METHOD3(RefreshActivity, void(int64_t callTimeMs, UserActivityType type, uint32_t flags)); + MOCK_METHOD0(GetDisplayState, DisplayState()); + MOCK_METHOD1(SetDisplayState, uint32_t(DisplayState state)); + MOCK_METHOD3(GoToSleep, uint32_t(std::function onSuspend, std::function onWakeup, bool force)); +}; +} // namespace PowerMgr +} // namespace OHOS + +#endif // POWERMGR_MOCK_STATE_ACTION_H \ No newline at end of file diff --git a/test/systemtest/src/power_mgr_st_mock_test.cpp b/test/systemtest/src/power_mgr_st_mock_test.cpp new file mode 100644 index 00000000..0beea3a1 --- /dev/null +++ b/test/systemtest/src/power_mgr_st_mock_test.cpp @@ -0,0 +1,2623 @@ +/* + * Copyright (c) 2021 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 "power_mgr_st_mock_test.h" + +using namespace testing::ext; +using namespace OHOS::PowerMgr; +using namespace OHOS; +using namespace std; +using ::testing::_; + +static sptr service; +static MockStateAction* stateAction; +static MockPowerAction* powerAction; +static MockLockAction* lockAction; + +static void ResetMockAction() +{ + stateAction = new MockStateAction(); + powerAction = new MockPowerAction(); + lockAction = new MockLockAction(); + service->EnableMock(stateAction, powerAction, lockAction); +} + +void PowerMgrMockTest::SetUpTestCase(void) +{ + // create singleton service object at the beginning + service = DelayedSpSingleton::GetInstance(); + service->OnStart(); + ResetMockAction(); +} + +void PowerMgrMockTest::TearDownTestCase(void) +{ + service->OnStop(); + DelayedSpSingleton::DestroyInstance(); + delete stateAction; + delete powerAction; + delete lockAction; +} + +void PowerMgrMockTest::SetUp(void) +{ +} + +void PowerMgrMockTest::TearDown(void) +{ +} + +/** + * @tc.name: PowerMgrMock001 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock001, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock001: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock001:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock001: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock001:End ."); + GTEST_LOG_(INFO) << "PowerMgrMock001: end."; +} + +/** + * @tc.name: PowerMgrMock002 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock002, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock002: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock002:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock002: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT, false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT, false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock002:End"); + GTEST_LOG_(INFO) << "PowerMgrMock002: end."; +} + +/** + * @tc.name: PowerMgrMock003 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock003, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock003: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock003: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH, false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH, false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:End."); + GTEST_LOG_(INFO) << "PowerMgrMock003: end."; +} + +/** + * @tc.name: PowerMgrMock004 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock004, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock004: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock004:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock004: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON, false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON, false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock004:End."); + GTEST_LOG_(INFO) << "PowerMgrMock004: end."; +} + +/** + * @tc.name: PowerMgrMock005 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock005, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock005: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock005:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock005: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI , false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI , false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock005:End."); + GTEST_LOG_(INFO) << "PowerMgrMock005: end."; +} + +/** + * @tc.name: PowerMgrMock006 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock006, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock006: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock006:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock006: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON , false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON , false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock006:End."); + GTEST_LOG_(INFO) << "PowerMgrMock006: end."; +} + +/** + * @tc.name: PowerMgrMock007 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock007, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock007: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock007:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock007: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY , false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY , false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock007:End."); + GTEST_LOG_(INFO) << "PowerMgrMock007: end."; +} + +/** + * @tc.name: PowerMgrMock008 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock008, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock008: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock008:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock008: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND , false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND , false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock008:End."); + GTEST_LOG_(INFO) << "PowerMgrMock008: end."; +} + + + +/** + * @tc.name: PowerMgrMock009 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock009, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock009: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock009:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock009: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock009:End."); + GTEST_LOG_(INFO) << "PowerMgrMock009: end."; +} + +/** + * @tc.name: PowerMgrMock010 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock010, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock010: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock010:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock010: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock010:End."); + GTEST_LOG_(INFO) << "PowerMgrMock010: end."; +} + +/** + * @tc.name: PowerMgrMock011 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock011, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock011: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock011:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock011: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock011:End."); + GTEST_LOG_(INFO) << "PowerMgrMock011: end."; +} + +/** + * @tc.name: PowerMgrMock012 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock012, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock012: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock012:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock012: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_GESTURE , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_GESTURE , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock012:End."); + GTEST_LOG_(INFO) << "PowerMgrMock012: end."; +} + +/** + * @tc.name: PowerMgrMock013 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock013, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock013: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock013:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock013: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock013:End."); + GTEST_LOG_(INFO) << "PowerMgrMock013: end."; +} + +/** + * @tc.name: PowerMgrMock014 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock014, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock014: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock014:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock014: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock014:End."); + GTEST_LOG_(INFO) << "PowerMgrMock014: end."; +} + +/** + * @tc.name: PowerMgrMock015 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock015, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock015: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock015:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock015: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock015:End."); + GTEST_LOG_(INFO) << "PowerMgrMock015: end."; +} + +/** + * @tc.name: PowerMgrMock016 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock016, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock016: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock016:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock016: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_HDMI , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_HDMI , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock016:End."); + GTEST_LOG_(INFO) << "PowerMgrMock016: end."; +} + +/** + * @tc.name: PowerMgrMock017 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock017, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock017: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock017:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock017: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_LID , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID , std::string("test")); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock017:End."); + GTEST_LOG_(INFO) << "PowerMgrMock017: end."; +} + + + +/** + * @tc.name: PowerMgrMock018 + * @tc.desc: test WakeupDevice and auto suspend and sleep by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock018, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock018: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock018:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock018: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID , std::string("test")); + sleep(SCREEN_DIM_WAIT_TIME_S + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(SCREEN_DIM_WAIT_TIME_S + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(SLEEP_WAIT_TIME_S + 1); + sleep(SLEEP_WAIT_TIME_S + 1); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock018:End."); + GTEST_LOG_(INFO) << "PowerMgrMock018: end."; +} + +/** + * @tc.name: PowerMgrMock019 + * @tc.desc: test RunningLock release by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock019, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock019: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock019:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock019: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + pms->ReleaseRunningLock(token); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(0); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock019:End."); + GTEST_LOG_(INFO) << "PowerMgrMock019: end."; +} + +/** + * @tc.name: PowerMgrMock020 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock020, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock020: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock020:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock020: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_OTHER, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_OTHER, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock020:End."); + GTEST_LOG_(INFO) << "PowerMgrMock020: end."; +} + +/** + * @tc.name: PowerMgrMock021 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock021, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock021: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock021:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock021: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_BUTTON, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_BUTTON, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock021:End."); + GTEST_LOG_(INFO) << "PowerMgrMock021: end."; +} + +/** + * @tc.name: PowerMgrMock022 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock022, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock022: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock022:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock022: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock022:End."); + GTEST_LOG_(INFO) << "PowerMgrMock022: end."; +} + +/** + * @tc.name: PowerMgrMock023 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock023, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock023: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock023:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock023: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ATTENTION, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ATTENTION, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock023:End."); + GTEST_LOG_(INFO) << "PowerMgrMock023: end."; +} + +/** + * @tc.name: PowerMgrMock024 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock024, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock024: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock024:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock024: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock024:End."); + GTEST_LOG_(INFO) << "PowerMgrMock024: end."; +} + +/** + * @tc.name: PowerMgrMock025 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock025, TestSize.Level2) +{ + UserActivityType abnormaltype={}; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock025: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock025:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock025: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, _, _)).Times(1); + pms->RefreshActivity(0, abnormaltype, true); + + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_EQ(pms->IsScreenOn(), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock025:End."); + GTEST_LOG_(INFO) << "PowerMgrMock025: end."; +} + +/** + * @tc.name: PowerMgrMock026 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock026, TestSize.Level2) +{ + UserActivityType abnormaltype=UserActivityType(6); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock026: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock026:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock026: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, _, _)).Times(0); + pms->RefreshActivity(0, abnormaltype, true); + + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_EQ(pms->IsScreenOn(), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock026:End."); + GTEST_LOG_(INFO) << "PowerMgrMock026: end."; +} + +/** + * @tc.name: PowerMgrMock027 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock027, TestSize.Level2) +{ + WakeupDeviceType abnormaltype=WakeupDeviceType(10); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock027: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock027:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock027: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(0); + EXPECT_CALL(*stateAction, + Wakeup(0, _ , + std::string("test"), _)).Times(0); + pms->WakeupDevice(0, abnormaltype , std::string("test")); + EXPECT_EQ(pms->IsScreenOn(), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock027:End."); + GTEST_LOG_(INFO) << "PowerMgrMock027: end."; +} + +/** + * @tc.name: PowerMgrMock028 + * @tc.desc: test WakeupDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock028, TestSize.Level2) +{ + WakeupDeviceType abnormaltype=WakeupDeviceType(999); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock028: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock028:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock028: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(0); + EXPECT_CALL(*stateAction, + Wakeup(0, _ , + std::string("test"), _)).Times(0); + pms->WakeupDevice(0, abnormaltype , std::string("test")); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock028:End."); + GTEST_LOG_(INFO) << "PowerMgrMock028: end."; +} + + + +/** + * @tc.name: PowerMgrMock029 + * @tc.desc: test WakeupDevice and auto suspend by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock029, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock029: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock029:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock029: Failed to get PowerMgrService"; + } + + // EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + // .Times(::testing::AtLeast(1)) + // .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + sleep(SCREEN_DIM_WAIT_TIME_S + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock029:End."); + GTEST_LOG_(INFO) << "PowerMgrMock029: end."; +} + +/** + * @tc.name: PowerMgrMock030 + * @tc.desc: test WakeupDevice and auto suspend by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock030, TestSize.Level2) +{ + WakeupDeviceType abnormaltype = WakeupDeviceType(10); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock030: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock030:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock030: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + //EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)).Times(0) + sleep(SCREEN_DIM_WAIT_TIME_S/2); + pms->WakeupDevice(0, abnormaltype , std::string("test")); + sleep(SCREEN_DIM_WAIT_TIME_S/2 + 1); + + ResetMockAction(); + GTEST_LOG_(INFO) << "PowerMgrMock030: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock030:End."); +} + +/** + * @tc.name: PowerMgrMock031 + * @tc.desc: test WakeupDevice and auto suspend by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock031, TestSize.Level2) +{ + WakeupDeviceType abnormaltype = WakeupDeviceType(999); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock031: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock031:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock031: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + //EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)).Times(0) + sleep(SCREEN_DIM_WAIT_TIME_S/2); + pms->WakeupDevice(0, abnormaltype , std::string("test")); + sleep(SCREEN_DIM_WAIT_TIME_S/2 + 1); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock031:End."); + GTEST_LOG_(INFO) << "PowerMgrMock031: end."; +} + +/** + * @tc.name: PowerMgrMock032 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock032, TestSize.Level2) +{ + UserActivityType abnormaltype = UserActivityType(6); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock032: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock032:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock032: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_OFF)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, _, true)).Times(0); + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2); + pms->RefreshActivity(0, abnormaltype, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2 + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock032:End."); + GTEST_LOG_(INFO) << "PowerMgrMock032: end."; +} + +/** + * @tc.name: PowerMgrMock033 + * @tc.desc: test RefreshActivity by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock033, TestSize.Level2) +{ + UserActivityType abnormaltype = {}; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock033: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock033:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock033: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_OFF)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, _, true)).Times(0); + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2); + pms->RefreshActivity(0, abnormaltype, true); + + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2 + 1); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock033:End."); + GTEST_LOG_(INFO) << "PowerMgrMock033: end."; +} + +/** + * @tc.name: PowerMgrMock034 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock034, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock034: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock034:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock034: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + sleep(SLEEP_WAIT_TIME_S+1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock034:End"); + GTEST_LOG_(INFO) << "PowerMgrMock034: end."; +} + +/** + * @tc.name: PowerMgrMock035 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock035, TestSize.Level2) +{ + SuspendDeviceType abnormaltype = SuspendDeviceType(10); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock035: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock035:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock035: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); + EXPECT_CALL(*stateAction, + Suspend(0, _, false)).Times(0); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + //EXPECT_CALL(*stateAction,Suspend(0, _ , false)).Times(0); + pms->SuspendDevice(0, abnormaltype, false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock035:End."); + GTEST_LOG_(INFO) << "PowerMgrMock035: end."; +} + +/** + * @tc.name: PowerMgrMock036 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock036, TestSize.Level2) +{ + SuspendDeviceType abnormaltype = SuspendDeviceType(999); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock036: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock036:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock036: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); + EXPECT_CALL(*stateAction, + Suspend(0, _, false)).Times(0); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + pms->SuspendDevice(0, abnormaltype, false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock036:End."); + GTEST_LOG_(INFO) << "PowerMgrMock036: end."; +} + +/** + * @tc.name: PowerMgrMock037 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock037, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock037: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock037:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock037: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + sleep(SLEEP_WAIT_TIME_S+1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock037:End."); + GTEST_LOG_(INFO) << "PowerMgrMock037: end."; +} + +/** + * @tc.name: PowerMgrMock038 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock038, TestSize.Level2) +{ + SuspendDeviceType abnormaltype = SuspendDeviceType(10); + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock038: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock038:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock038: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, + Suspend(0, _, false)).Times(0); + pms->SuspendDevice(0, abnormaltype, false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock038:End."); + GTEST_LOG_(INFO) << "PowerMgrMock038: end."; +} + +/** + * @tc.name: PowerMgrMock039 + * @tc.desc: test SuspendDevice by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock039, TestSize.Level2) +{ + SuspendDeviceType abnormaltype = {}; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock039: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock039:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock039: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, + Suspend(0, _, false)); + pms->SuspendDevice(0, abnormaltype, false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock039:End."); + GTEST_LOG_(INFO) << "PowerMgrMock039: end."; +} + + + +/** + * @tc.name: PowerMgrMock040 + * @tc.desc: test ForceSuspendDevice by mock during Inactive + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock040, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock040: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock040:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock040: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->ForceSuspendDevice(0); + sleep(SLEEP_WAIT_TIME_S+1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock040:End."); + GTEST_LOG_(INFO) << "PowerMgrMock040: end."; +} + +/** + * @tc.name: PowerMgrMock041 + * @tc.desc: test SCREEN_ON RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock041, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock041: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock041:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock041: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sleep(SCREEN_DIM_WAIT_TIME_S + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock041:End."); + GTEST_LOG_(INFO) << "PowerMgrMock041: end."; +} + +/** + * @tc.name: PowerMgrMock042 + * @tc.desc: test SCREEN_ON RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock042, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock042: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock042:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock042: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + //EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + //sleep(SCREEN_DIM_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock042:End."); + GTEST_LOG_(INFO) << "PowerMgrMock042: end."; +} + +/** + * @tc.name: PowerMgrMock043 + * @tc.desc: test Screen RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock043, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock043: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock043:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock043: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sleep(SCREEN_DIM_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + sleep(SCREEN_OFF_WAIT_TIME_S+1); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock043:End."); + GTEST_LOG_(INFO) << "PowerMgrMock043: end."; +} + +/** + * @tc.name: PowerMgrMock044 + * @tc.desc: test Screen RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock044, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock044: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock044:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock044: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + sleep(SLEEP_WAIT_TIME_S*10); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock044:End."); + GTEST_LOG_(INFO) << "PowerMgrMock044: end."; +} + +/** + * @tc.name: PowerMgrMock045 + * @tc.desc: test Screen on RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock045, TestSize.Level2) +{ + int i; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock045: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock045:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock045: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + for(i=0;i<10;i++){ + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + } + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock045:End."); + GTEST_LOG_(INFO) << "PowerMgrMock045: end."; +} + +/** + * @tc.name: PowerMgrMock046 + * @tc.desc: test Screen RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock046, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock046: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock046:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock046: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(1); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sleep(SLEEP_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock046:End."); + GTEST_LOG_(INFO) << "PowerMgrMock046: end."; +} + +/** + * @tc.name: PowerMgrMock047 + * @tc.desc: test Screen RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock047, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock047: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock047:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock047: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_EQ(pms->ForceSuspendDevice(0), true); + //pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sleep(SLEEP_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock047:End."); + GTEST_LOG_(INFO) << "PowerMgrMock047: end."; +} + +/** + * @tc.name: PowerMgrMock048 + * @tc.desc: test Screen RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock048, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock048: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock048:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock048: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, Suspend(_, _, _)).Times(0); + + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + + pms->UnLock(token); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock048:End."); + GTEST_LOG_(INFO) << "PowerMgrMock048: end."; +} + +/** + * @tc.name: PowerMgrMock049 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock049, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock049: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock049:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock049: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_EQ(pms->ForceSuspendDevice(0), true); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock049:End."); + GTEST_LOG_(INFO) << "PowerMgrMock049: end."; +} + +/** + * @tc.name: PowerMgrMock050 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock050, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock050: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock050:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock050: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock050:End."); + GTEST_LOG_(INFO) << "PowerMgrMock050: end."; +} + +/** + * @tc.name: PowerMgrMock051 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock051, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock051: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock051:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock051: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + //EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + sleep(SLEEP_WAIT_TIME_S*10); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock051:End."); + GTEST_LOG_(INFO) << "PowerMgrMock051: end."; +} + +/** + * @tc.name: PowerMgrMock052 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock052, TestSize.Level2) +{ + int i; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock052: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock052:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock052: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + for(i=0;i<10;i++){ + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + } + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock052:End."); + GTEST_LOG_(INFO) << "PowerMgrMock052: end."; +} + +/** + * @tc.name: PowerMgrMock053 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock053, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock053: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock053:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock053: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + sleep(SLEEP_WAIT_TIME_S + 1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock053:End"); + GTEST_LOG_(INFO) << "PowerMgrMock053: end."; +} + +/** + * @tc.name: PowerMgrMock054 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock054, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock054: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock054:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock054: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_EQ(pms->ForceSuspendDevice(0), true); + sleep(SLEEP_WAIT_TIME_S + 1); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock054:End."); + GTEST_LOG_(INFO) << "PowerMgrMock054: end."; +} + +/** + * @tc.name: PowerMgrMock055 + * @tc.desc: test proximity screen control RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock055, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock055: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock055:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock055: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock055:End."); + GTEST_LOG_(INFO) << "PowerMgrMock055: end."; +} + + +/** + * @tc.name: PowerMgrMock056 + * @tc.desc: test proximity screen control RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock056, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock056: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock056:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock056: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_EQ(pms->ForceSuspendDevice(0), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock056:End."); + GTEST_LOG_(INFO) << "PowerMgrMock056: end."; +} + +/** + * @tc.name: PowerMgrMock057 + * @tc.desc: test proximity screen control RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock057, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock057: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock057:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock057: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock057:End."); + GTEST_LOG_(INFO) << "PowerMgrMock057: end."; +} + +/** + * @tc.name: PowerMgrMock058 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock058, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock058: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock058:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock058: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + pms->ReleaseRunningLock(token); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(0); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), false); + + sleep(SCREEN_OFF_WAIT_TIME_S+1); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock058:End."); + GTEST_LOG_(INFO) << "PowerMgrMock058: end."; +} + +/** + * @tc.name: PowerMgrMock059 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock059, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock059: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock059:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock059: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep(SLEEP_WAIT_TIME_S*10); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); + sleep(SLEEP_WAIT_TIME_S+1); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock059:End."); + GTEST_LOG_(INFO) << "PowerMgrMock059: end."; +} + +/** + * @tc.name: PowerMgrMock060 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock060, TestSize.Level2) +{ + int i; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock060: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock060:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock060: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + for(i=0;i<10;i++){ + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + } + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock060:End."); + GTEST_LOG_(INFO) << "PowerMgrMock060: end."; +} + +/** + * @tc.name: PowerMgrMock061 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock061, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock061: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock061:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock061: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock061:End."); + GTEST_LOG_(INFO) << "PowerMgrMock061: end."; +} + +/** + * @tc.name: PowerMgrMock062 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock062, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock062: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock062:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock062: Failed to get PowerMgrService"; + } + + //pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->ForceSuspendDevice(0); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock062:End."); + GTEST_LOG_(INFO) << "PowerMgrMock062: end."; +} + +/** + * @tc.name: PowerMgrMock063 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock063, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock063: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock063:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock063: Failed to get PowerMgrService"; + } + + //pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock063:End."); + GTEST_LOG_(INFO) << "PowerMgrMock063: end."; +} + +/** + * @tc.name: PowerMgrMock064 + * @tc.desc: test Auto SuspendDevice by mock after 15s + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock064, TestSize.Level2) +{ + int64_t time =15000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock064: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock064:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock064: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000+1); + sleep(SLEEP_WAIT_TIME_S+1); + + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock064:End."); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock064: end."; +} + +/** + * @tc.name: PowerMgrMock065 + * @tc.desc: test Auto SuspendDevice by mock after 30s + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock065, TestSize.Level2) +{ + int64_t time =30000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock065: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock065:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock065: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000+1); + sleep(SLEEP_WAIT_TIME_S+1); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock065:End"); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock065: end."; +} + +// /** +// * @tc.name: PowerMgrMock066 +// * @tc.desc: test Auto SuspendDevice by mock after 1min +// * @tc.type: FUNC +// */ +// HWTEST_F (PowerMgrMockTest, PowerMgrMock066, TestSize.Level2) +// { +// int64_t time =60000; +// sleep(NEXT_WAIT_TIME_S); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock066:Start"); +// GTEST_LOG_(INFO) << "PowerMgrMock066: start."; + +// sptr pms = DelayedSpSingleton::GetInstance(); +// if (pms == nullptr) { +// GTEST_LOG_(INFO) << "PowerMgrMock066: Failed to get PowerMgrService"; +// } + +// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// pms->SetDisplayOffTime(time); +// sleep(time/1000+1); +// sleep(SLEEP_WAIT_TIME_S+1); + +// ResetMockAction(); +// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock066:End"); +// GTEST_LOG_(INFO) << "PowerMgrMock066: end."; +// } + +// /** +// * @tc.name: PowerMgrMock067 +// * @tc.desc: test Auto SuspendDevice by mock after 2mins +// * @tc.type: FUNC +// */ +// HWTEST_F (PowerMgrMockTest, PowerMgrMock067, TestSize.Level2) +// { +// int64_t time =120000; +// sleep(NEXT_WAIT_TIME_S); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock067:Start"); +// GTEST_LOG_(INFO) << "PowerMgrMock067: start."; + +// sptr pms = DelayedSpSingleton::GetInstance(); +// if (pms == nullptr) { +// GTEST_LOG_(INFO) << "PowerMgrMock067: Failed to get PowerMgrService"; +// } + +// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// pms->SetDisplayOffTime(time); +// sleep(time/1000+1); +// sleep(SLEEP_WAIT_TIME_S+1); + +// ResetMockAction(); +// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock067:End"); +// GTEST_LOG_(INFO) << "PowerMgrMock067: end."; +// } + +// /** +// * @tc.name: PowerMgrMock068 +// * @tc.desc: test Auto SuspendDevice by mock after 5mins +// * @tc.type: FUNC +// */ +// HWTEST_F (PowerMgrMockTest, PowerMgrMock068, TestSize.Level2) +// { +// int64_t time =300000; +// sleep(NEXT_WAIT_TIME_S); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock068:Start"); +// GTEST_LOG_(INFO) << "PowerMgrMock068: start."; + +// sptr pms = DelayedSpSingleton::GetInstance(); +// if (pms == nullptr) { +// GTEST_LOG_(INFO) << "PowerMgrMock068: Failed to get PowerMgrService"; +// } + +// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// pms->SetDisplayOffTime(time); +// sleep(time/1000+1); +// sleep(SLEEP_WAIT_TIME_S+1); + +// ResetMockAction(); +// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock068:End"); +// GTEST_LOG_(INFO) << "PowerMgrMock068: end."; +// } + +// /** +// * @tc.name: PowerMgrMock069 +// * @tc.desc: test Auto SuspendDevice by mock after 10mins +// * @tc.type: FUNC +// */ +// HWTEST_F (PowerMgrMockTest, PowerMgrMock069, TestSize.Level2) +// { +// int64_t time =600000; +// sleep(NEXT_WAIT_TIME_S); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock069:Start"); +// GTEST_LOG_(INFO) << "PowerMgrMock069: start."; + +// sptr pms = DelayedSpSingleton::GetInstance(); +// if (pms == nullptr) { +// GTEST_LOG_(INFO) << "PowerMgrMock069: Failed to get PowerMgrService"; +// } + +// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// pms->SetDisplayOffTime(time); +// sleep(time/1000+1); +// sleep(SLEEP_WAIT_TIME_S+1); + +// ResetMockAction(); +// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock069:End"); +// GTEST_LOG_(INFO) << "PowerMgrMock069: end."; +// } + +/** + * @tc.name: PowerMgrMock070 + * @tc.desc: test Auto DIM by mock after 15s + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock070, TestSize.Level2) +{ + int64_t time =15000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock070: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock070: Failed to get PowerMgrService"; + } + pms->SetDisplayOffTime(time); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070:DeviceStateAction::SetDisplayState."); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070:Start sleep."); + sleep(time/1000-2); + sleep(3); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070: sleep end."); + ResetMockAction(); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070:End."); + GTEST_LOG_(INFO) << "PowerMgrMock070: end."; +} + +/** + * @tc.name: PowerMgrMock071 + * @tc.desc: test Auto DIM by mock after 30s + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock071, TestSize.Level2) +{ + int64_t time =30000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock071: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0071:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock071: Failed to get PowerMgrService"; + } + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000-2); + sleep(3); + ResetMockAction(); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock071:End."); + GTEST_LOG_(INFO) << "PowerMgrMock071: end."; +} + +// /** +// * @tc.name: PowerMgrMock072 +// * @tc.desc: test Auto DIM by mock after 60s +// * @tc.type: FUNC +// */ +// HWTEST_F (PowerMgrMockTest, PowerMgrMock072, TestSize.Level2) +// { +// int64_t time =60000; +// sleep(NEXT_WAIT_TIME_S); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0072:Start."); +// GTEST_LOG_(INFO) << "PowerMgrMock072: start."; + +// sptr pms = DelayedSpSingleton::GetInstance(); +// if (pms == nullptr) { +// GTEST_LOG_(INFO) << "PowerMgrMock072: Failed to get PowerMgrService"; +// } + +// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// pms->SetDisplayOffTime(time); +// sleep(time/1000-2); +// sleep(3); +// ResetMockAction(); +// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0072:End."); +// GTEST_LOG_(INFO) << "PowerMgrMock072: end."; +// } + +// /** +// * @tc.name: PowerMgrMock073 +// * @tc.desc: test Auto DIM by mock after 2min +// * @tc.type: FUNC +// */ +// HWTEST_F (PowerMgrMockTest, PowerMgrMock073, TestSize.Level2) +// { +// int64_t time =120000; +// sleep(NEXT_WAIT_TIME_S); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0073:Start."); +// GTEST_LOG_(INFO) << "PowerMgrMock073: start."; + +// sptr pms = DelayedSpSingleton::GetInstance(); +// if (pms == nullptr) { +// GTEST_LOG_(INFO) << "PowerMgrMock073: Failed to get PowerMgrService"; +// } + +// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// pms->SetDisplayOffTime(time); +// sleep(time/1000-2); +// sleep(3); +// ResetMockAction(); +// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0073:End."); +// GTEST_LOG_(INFO) << "PowerMgrMock073: end."; +// } + +// /** +// * @tc.name: PowerMgrMock074 +// * @tc.desc: test Auto DIM by mock after 5min +// * @tc.type: FUNC +// */ +// HWTEST_F (PowerMgrMockTest, PowerMgrMock074, TestSize.Level2) +// { +// int64_t time =300000; +// sleep(NEXT_WAIT_TIME_S); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0074:Start."); +// GTEST_LOG_(INFO) << "PowerMgrMock074: start."; + +// sptr pms = DelayedSpSingleton::GetInstance(); +// if (pms == nullptr) { +// GTEST_LOG_(INFO) << "PowerMgrMock074: Failed to get PowerMgrService"; +// } + +// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// pms->SetDisplayOffTime(time); +// sleep(time/1000-2); +// sleep(3); +// ResetMockAction(); +// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0074:End."); +// GTEST_LOG_(INFO) << "PowerMgrMock074: end."; +// } + +// /** +// * @tc.name: PowerMgrMock075 +// * @tc.desc: test Auto DIM by mock after 10min +// * @tc.type: FUNC +// */ +// HWTEST_F (PowerMgrMockTest, PowerMgrMock075, TestSize.Level2) +// { +// int64_t time =600000; +// sleep(NEXT_WAIT_TIME_S); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0075:Start."); +// GTEST_LOG_(INFO) << "PowerMgrMock075: start."; + +// sptr pms = DelayedSpSingleton::GetInstance(); +// if (pms == nullptr) { +// GTEST_LOG_(INFO) << "PowerMgrMock075: Failed to get PowerMgrService"; +// } + +// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) +// .Times(1) +// .WillOnce(::testing::Return(ActionResult::SUCCESS)); +// pms->SetDisplayOffTime(time); +// sleep(time/1000-2); +// sleep(3); +// ResetMockAction(); +// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); +// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0075:End."); +// GTEST_LOG_(INFO) << "PowerMgrMock075: end."; +// } \ No newline at end of file -- Gitee From 25e7bfdd4fc22117ce356d7ba82cf287cc9b5680 Mon Sep 17 00:00:00 2001 From: Du Jiang Date: Thu, 9 Sep 2021 15:19:39 +0800 Subject: [PATCH 08/11] Revert PowerMgrClient interfaces definition Some PowerMgrClient interfaces are already used by other modules, such as telephony. Revert interfaces definition to adapt previous version. Otherwise there will be build errors. Change-Id: Ibeccee5cdee15d948636196aaa3435feb8d7ef70 --- frameworks/native/power_mgr_client.cpp | 7 +++---- interfaces/innerkits/native/include/power_mgr_client.h | 6 ++++-- services/native/src/actions/default/device_state_action.h | 4 ++-- 3 files changed, 9 insertions(+), 8 deletions(-) diff --git a/frameworks/native/power_mgr_client.cpp b/frameworks/native/power_mgr_client.cpp index 5103750c..ea76a76b 100644 --- a/frameworks/native/power_mgr_client.cpp +++ b/frameworks/native/power_mgr_client.cpp @@ -112,17 +112,16 @@ void PowerMgrClient::ShutDownDevice(const std::string& reason) proxy_->ShutDownDevice(reason); } -void PowerMgrClient::SuspendDevice(SuspendDeviceType reason) +void PowerMgrClient::SuspendDevice(SuspendDeviceType reason, bool suspendImmed) { RETURN_IF(Connect() != ERR_OK); - proxy_->SuspendDevice(GetTickCount(), reason, false); + proxy_->SuspendDevice(GetTickCount(), reason, suspendImmed); POWER_HILOGI(MODULE_INNERKIT, " Calling SuspendDevice success."); } -void PowerMgrClient::WakeupDevice(WakeupDeviceType reason) +void PowerMgrClient::WakeupDevice(WakeupDeviceType reason, const std::string& detail) { RETURN_IF(Connect() != ERR_OK); - std::string detail = "Client"; proxy_->WakeupDevice(GetTickCount(), reason, detail); POWER_HILOGI(MODULE_INNERKIT, " Calling WakeupDevice success."); diff --git a/interfaces/innerkits/native/include/power_mgr_client.h b/interfaces/innerkits/native/include/power_mgr_client.h index 64803388..c0762712 100644 --- a/interfaces/innerkits/native/include/power_mgr_client.h +++ b/interfaces/innerkits/native/include/power_mgr_client.h @@ -52,14 +52,16 @@ public: * * @param reason The reason why will you suspend the device, such as timeout/powerkey/forcesuspend and so on. */ - void SuspendDevice(SuspendDeviceType reason = SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION); + void SuspendDevice(SuspendDeviceType reason = SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, + bool suspendImmed = false); /** * Wake up the device and set the screen on. * * @param reason The reason for waking up the device, such as powerkey/plugin/application. */ - void WakeupDevice(WakeupDeviceType reason = WakeupDeviceType::WAKEUP_DEVICE_APPLICATION); + void WakeupDevice(WakeupDeviceType reason = WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, + const std::string& detail = std::string("app call")); /** * Refresh the screentimeout time, and keep the screen on. RefreshActivity works only when the screen is on. diff --git a/services/native/src/actions/default/device_state_action.h b/services/native/src/actions/default/device_state_action.h index 6e56a0df..7e02b25d 100644 --- a/services/native/src/actions/default/device_state_action.h +++ b/services/native/src/actions/default/device_state_action.h @@ -26,8 +26,8 @@ public: void ForceSuspend() override; void Wakeup(int64_t callTimeMs, WakeupDeviceType type, const std::string& details, const std::string& pkgName) override; - void RefreshActivity(int64_t callTimeMs __unused, UserActivityType type __unused, - uint32_t flags __unused) override {} + void RefreshActivity(int64_t callTimeMs, UserActivityType type, + uint32_t flags) override {} DisplayState GetDisplayState() override; uint32_t SetDisplayState(DisplayState state) override; uint32_t GoToSleep(std::function onSuspend, std::function onWakeup, bool force) override; -- Gitee From 24624214d2944d7b57d19bb5bd3f6cc7e9c2efcf Mon Sep 17 00:00:00 2001 From: Du Jiang Date: Thu, 9 Sep 2021 18:06:54 +0800 Subject: [PATCH 09/11] Change DIM timeout to 2/3 time of display off Change display DIM timeout to 2/3 time of display off for better user experience. Also change test cases accordingly. Fix bugs that display not off when proximity sensor close. Add power save mode test and fix bugs. Change-Id: Ib53d58d5036386e364cfb2a6d6b0df5b5350c8ca --- frameworks/napi/runninglock/runninglock.cpp | 9 +- .../napi/test/power_manager_unit.test.js | 2 +- services/native/include/power_mgr_service.h | 2 + services/native/include/power_state_machine.h | 2 +- services/native/include/running_lock_mgr.h | 4 + services/native/src/power_state_machine.cpp | 14 +- services/native/src/running_lock_mgr.cpp | 64 +- .../unittest/include/power_mgr_mock_test.h | 3 +- .../test/unittest/src/power_mgr_mock_test.cpp | 1552 +++++----- test/systemtest/BUILD.gn | 68 +- .../include/power_mgr_powersavemode_test.h | 64 + .../src/power_mgr_powersavemode_test.cpp | 599 ++++ .../systemtest/src/power_mgr_st_mock_test.cpp | 2573 ++++++++++------- 13 files changed, 3178 insertions(+), 1778 deletions(-) create mode 100644 test/systemtest/include/power_mgr_powersavemode_test.h create mode 100644 test/systemtest/src/power_mgr_powersavemode_test.cpp diff --git a/frameworks/napi/runninglock/runninglock.cpp b/frameworks/napi/runninglock/runninglock.cpp index 52353b6b..5b5be438 100644 --- a/frameworks/napi/runninglock/runninglock.cpp +++ b/frameworks/napi/runninglock/runninglock.cpp @@ -268,10 +268,15 @@ static void IsRunningLockTypeSupportedCallBack(napi_env env, resource, [](napi_env env, void *data) { RunningLockAsyncCallbackInfo *asyncCallbackInfo = (RunningLockAsyncCallbackInfo *)data; - if (asyncCallbackInfo->type == RunningLockType::RUNNINGLOCK_BACKGROUND) { + if (asyncCallbackInfo->type == RunningLockType::RUNNINGLOCK_BACKGROUND + || asyncCallbackInfo->type == RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL) { asyncCallbackInfo->isSupported = true; + } else { + asyncCallbackInfo->isSupported = false; } - POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: runningLock isSupported %{public}s", __func__, + POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: runningLock(%{public}d) isSupported %{public}s", + __func__, + asyncCallbackInfo->type, asyncCallbackInfo->isSupported ? "true" : "false"); }, [](napi_env env, napi_status status, void *data) { diff --git a/frameworks/napi/test/power_manager_unit.test.js b/frameworks/napi/test/power_manager_unit.test.js index 003ff798..c01e133c 100644 --- a/frameworks/napi/test/power_manager_unit.test.js +++ b/frameworks/napi/test/power_manager_unit.test.js @@ -133,7 +133,7 @@ describe('appInfoTest', function () { runningLock.isRunningLockTypeSupported(runningLock.RunningLockType.PROXIMITY_SCREEN_CONTROL) .then(supported => { console.info('is_runninglock_type_supported_test_1 PROXIMITY_SCREEN_CONTROL supported is ' + supported); - expect(supported).assertFalse(); + expect(supported).assertTrue(); console.info('is_runninglock_type_supported_test_1 success'); done(); }) diff --git a/services/native/include/power_mgr_service.h b/services/native/include/power_mgr_service.h index c9137e0a..79fd4388 100644 --- a/services/native/include/power_mgr_service.h +++ b/services/native/include/power_mgr_service.h @@ -113,7 +113,9 @@ public: } void MockProximity(uint32_t status) { + POWER_HILOGE(MODULE_SERVICE, "MockProximity: fun is start"); runningLockMgr_->SetProximity(status); + POWER_HILOGE(MODULE_SERVICE, "MockProximity: fun is end"); } void MockSystemWakeup() { diff --git a/services/native/include/power_state_machine.h b/services/native/include/power_state_machine.h index 67420c4a..697fa36a 100644 --- a/services/native/include/power_state_machine.h +++ b/services/native/include/power_state_machine.h @@ -27,7 +27,7 @@ #include "power_state_machine_info.h" #include "running_lock_info.h" -#define DEFAULT_DISPLAY_OFF_TIME 5000 +#define DEFAULT_DISPLAY_OFF_TIME 30000 #define DEFAULT_SLEEP_TIME 5000 namespace OHOS { diff --git a/services/native/include/running_lock_mgr.h b/services/native/include/running_lock_mgr.h index b9adffcb..6023c590 100644 --- a/services/native/include/running_lock_mgr.h +++ b/services/native/include/running_lock_mgr.h @@ -92,6 +92,7 @@ private: bool IsLocking() { return locking_; }; void EnableMock(std::shared_ptr& mock) { + locking_ = false; action_ = mock; } private: @@ -124,11 +125,14 @@ private: void Enable(); void Disable(); bool IsEnabled() { return enabled_; } + bool IsClose(); void OnClose(); void OnAway(); uint32_t GetStatus() { return status_; } + void Clear(); private: bool enabled_; + bool isClose{false}; uint32_t status_; }; diff --git a/services/native/src/power_state_machine.cpp b/services/native/src/power_state_machine.cpp index 744e0146..60ddf640 100644 --- a/services/native/src/power_state_machine.cpp +++ b/services/native/src/power_state_machine.cpp @@ -528,8 +528,9 @@ void PowerStateMachine::ResetInactiveTimer() CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG); if (this->CheckRunningLock(PowerState::INACTIVE)) { - const uint32_t HALF = 2; - this->SetDelayTimer(this->GetDisplayOffTime() / HALF, + const uint32_t TWO = 2; + const uint32_t THREE = 3; + this->SetDelayTimer(this->GetDisplayOffTime() * TWO / THREE, PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG); } POWER_HILOGD(MODULE_SERVICE, "ResetInactiveTimer: fun is End!"); @@ -576,14 +577,14 @@ void PowerStateMachine::HandleActivityTimeout() POWER_HILOGI(MODULE_SERVICE, "HandleActivityTimeout (%{public}d)", stateAction_->GetDisplayState()); DisplayState dispState = stateAction_->GetDisplayState(); - const uint32_t HALF = 2; + const uint32_t THREE = 3; if (!this->CheckRunningLock(PowerState::INACTIVE)) { POWER_HILOGW(MODULE_SERVICE, "RunningLock is blocking to transit to INACTIVE"); return; } if (dispState == DisplayState::DISPLAY_ON) { stateAction_->SetDisplayState(DisplayState::DISPLAY_DIM); - SetDelayTimer(GetDisplayOffTime() / HALF, + SetDelayTimer(GetDisplayOffTime() / THREE, PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG); } else { POWER_HILOGW(MODULE_SERVICE, @@ -878,10 +879,11 @@ TransitResult PowerStateMachine::StateController::TransitTo( return TransitResult::OTHER_ERR; } POWER_HILOGI(MODULE_SERVICE, - "Transit from %{public}s to %{public}s for %{public}s", + "Transit from %{public}s to %{public}s for %{public}s ignoreLock=%{public}d", GetPowerStateString(owner->currentState_), GetPowerStateString(this->state_), - GetReasonTypeString(reason)); + GetReasonTypeString(reason), + ignoreLock); TransitResult ret = TransitResult::OTHER_ERR; if (!CheckState()) { POWER_HILOGE(MODULE_SERVICE, "TransitTo: already in %{public}d", diff --git a/services/native/src/running_lock_mgr.cpp b/services/native/src/running_lock_mgr.cpp index 3d214a86..31fb5241 100644 --- a/services/native/src/running_lock_mgr.cpp +++ b/services/native/src/running_lock_mgr.cpp @@ -159,14 +159,21 @@ bool RunningLockMgr::InitLocks() if (active) { POWER_HILOGI(MODULE_SERVICE, "RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL active!"); - stateMachine->SetState(PowerState::AWAKE, - StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK); + proximityController_.Enable(); + if (proximityController_.IsClose()) { + POWER_HILOGI(MODULE_SERVICE, "INACTIVE when close"); + stateMachine->SetState(PowerState::INACTIVE, + StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true); + } else { + POWER_HILOGI(MODULE_SERVICE, "AWAKE when away"); + stateMachine->SetState(PowerState::AWAKE, + StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true); + } stateMachine->CancelDelayTimer( PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG); stateMachine->CancelDelayTimer( PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG); pSysLock->Lock(); - proximityController_.Enable(); } else { POWER_HILOGI(MODULE_SERVICE, "RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL inactive!"); @@ -747,17 +754,20 @@ void RunningLockMgr::NotifyHiView(RunningLockChangedType changeType, void RunningLockMgr::EnableMock(IRunningLockAction* mockAction) { + // reset lock list; + runningLocks_.clear(); + for(auto it = lockCounters_.begin(); it != lockCounters_.end(); it++) { + it->second->Clear(); + } + proximityController_.Clear(); + std::shared_ptr mock(mockAction); for(auto it = systemLocks_.begin(); it != systemLocks_.end(); it++) { it->second->EnableMock(mock); } runningLockAction_ = mock; - // reset lock list; - runningLocks_.clear(); - for(auto it = lockCounters_.begin(); it != lockCounters_.end(); it++) { - it->second->Clear(); - } + } static const char* GetRunningLockTypeString(RunningLockType type) @@ -889,9 +899,6 @@ uint32_t RunningLockMgr::LockCounter::Decrease() void RunningLockMgr::LockCounter::Clear() { - if (counter_ > 0) { - activate_(false); - } counter_ = 0; } @@ -914,6 +921,12 @@ void RunningLockMgr::ProximityController::Disable() enabled_ = false; } +bool RunningLockMgr::ProximityController::IsClose() +{ + POWER_HILOGD(MODULE_SERVICE, "IsClose:%{public}d", isClose); + return isClose; +} + void RunningLockMgr::ProximityController::OnClose() { if (!enabled_) { @@ -927,9 +940,15 @@ void RunningLockMgr::ProximityController::OnClose() if (stateMachine == nullptr) { return; } - stateMachine->SetState(PowerState::INACTIVE, - StateChangeReason::STATE_CHANGE_REASON_SENSOR, - true); + isClose = true; + auto runningLock = pms->GetRunningLockMgr(); + if (runningLock->GetValidRunningLockNum( + RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL) > 0) { + POWER_HILOGD(MODULE_SERVICE, "Change to INACITVE when come close"); + stateMachine->SetState(PowerState::INACTIVE, + StateChangeReason::STATE_CHANGE_REASON_SENSOR, + true); + } } void RunningLockMgr::ProximityController::OnAway() @@ -945,9 +964,20 @@ void RunningLockMgr::ProximityController::OnAway() if (stateMachine == nullptr) { return; } - stateMachine->SetState(PowerState::AWAKE, - StateChangeReason::STATE_CHANGE_REASON_SENSOR, - true); + isClose = false; + auto runningLock = pms->GetRunningLockMgr(); + if (runningLock->GetValidRunningLockNum( + RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL) > 0) { + POWER_HILOGD(MODULE_SERVICE, "Change to AWAKE when go away"); + stateMachine->SetState(PowerState::AWAKE, + StateChangeReason::STATE_CHANGE_REASON_SENSOR, + true); + } +} + +void RunningLockMgr::ProximityController::Clear() +{ + isClose = false; } void RunningLockMgr::SetProximity(uint32_t status) diff --git a/services/native/test/unittest/include/power_mgr_mock_test.h b/services/native/test/unittest/include/power_mgr_mock_test.h index 155d350c..125c2138 100644 --- a/services/native/test/unittest/include/power_mgr_mock_test.h +++ b/services/native/test/unittest/include/power_mgr_mock_test.h @@ -32,7 +32,8 @@ constexpr int NEXT_WAIT_TIME_S = 1; constexpr int ASYNC_WAIT_TIME_S = 3; constexpr int REFRESHACTIVITY_WAIT_TIME_S = 8; constexpr int SCREEN_OFF_WAIT_TIME_S = (DEFAULT_DISPLAY_OFF_TIME / 1000); -constexpr int SCREEN_DIM_WAIT_TIME_S = (SCREEN_OFF_WAIT_TIME_S / 2); +constexpr int SCREEN_DIM_WAIT_TIME_S = (SCREEN_OFF_WAIT_TIME_S * 2 / 3); +constexpr int SCREEN_DIM_TO_OFF_TIME_S = (SCREEN_OFF_WAIT_TIME_S / 3); constexpr int SLEEP_WAIT_TIME_S = (DEFAULT_SLEEP_TIME / 1000); class PowerMgrMockTest : public testing::Test { diff --git a/services/native/test/unittest/src/power_mgr_mock_test.cpp b/services/native/test/unittest/src/power_mgr_mock_test.cpp index 33bf2a95..91bf8e8e 100644 --- a/services/native/test/unittest/src/power_mgr_mock_test.cpp +++ b/services/native/test/unittest/src/power_mgr_mock_test.cpp @@ -28,6 +28,7 @@ static MockLockAction* lockAction; static void ResetMockAction() { + POWER_HILOGD(MODULE_SERVICE, "ResetMockAction:Start."); stateAction = new MockStateAction(); powerAction = new MockPowerAction(); lockAction = new MockLockAction(); @@ -59,20 +60,21 @@ void PowerMgrMockTest::TearDown(void) { } + /** - * @tc.name: PowerMgrMock001 + * @tc.name: PowerMgrUnittest001 * @tc.desc: test RebootDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock001, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest001, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock001: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock001:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest001: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest001:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock001: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest001: Failed to get PowerMgrService"; } EXPECT_CALL(*powerAction, Reboot(std::string("test"))).Times(1); @@ -80,24 +82,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock001, TestSize.Level2) sleep(ASYNC_WAIT_TIME_S); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock001:End."); - GTEST_LOG_(INFO) << "PowerMgrMock001: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest001:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest001: end."; } /** - * @tc.name: PowerMgrMock002 + * @tc.name: PowerMgrUnittest002 * @tc.desc: test ShutDownDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock002, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest002, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock002: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock002:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest002: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest002:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock002: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest002: Failed to get PowerMgrService"; } EXPECT_CALL(*powerAction, Shutdown(std::string("test"))).Times(1); @@ -105,55 +107,55 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock002, TestSize.Level2) sleep(ASYNC_WAIT_TIME_S); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock002:End."); - GTEST_LOG_(INFO) << "PowerMgrMock002: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest002:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest002: end."; } /** - * @tc.name: PowerMgrMock003 + * @tc.name: PowerMgrUnittest003 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock003, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest003, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock003: start."; + GTEST_LOG_(INFO) << "PowerMgrUnittest003: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:Start."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest003:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock003: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest003: Failed to get PowerMgrService"; } - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:Start mock."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest003:Start mock."); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:Start suspend."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest003:Start suspend."); pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:end."); - GTEST_LOG_(INFO) << "PowerMgrMock003: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest003:end."); + GTEST_LOG_(INFO) << "PowerMgrUnittest003: end."; } /** - * @tc.name: PowerMgrMock004 + * @tc.name: PowerMgrUnittest004 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock004, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest004, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock004: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock004:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest004: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest004:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock004: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest004: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) @@ -164,24 +166,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock004, TestSize.Level2) pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock004:End ."); - GTEST_LOG_(INFO) << "PowerMgrMock004: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest004:End ."); + GTEST_LOG_(INFO) << "PowerMgrUnittest004: end."; } /** - * @tc.name: PowerMgrMock005 + * @tc.name: PowerMgrUnittest005 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock005, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest005, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock005: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock005:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest005: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest005:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock005: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest005: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) @@ -192,24 +194,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock005, TestSize.Level2) pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT, false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock005:End"); - GTEST_LOG_(INFO) << "PowerMgrMock005: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest005:End"); + GTEST_LOG_(INFO) << "PowerMgrUnittest005: end."; } /** - * @tc.name: PowerMgrMock006 + * @tc.name: PowerMgrUnittest006 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock006, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest006, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock006: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock006:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest006: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest006:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock006: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest006: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) @@ -220,24 +222,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock006, TestSize.Level2) pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH, false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock006:End."); - GTEST_LOG_(INFO) << "PowerMgrMock006: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest006:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest006: end."; } /** - * @tc.name: PowerMgrMock007 + * @tc.name: PowerMgrUnittest007 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock007, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest007, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock007: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock007:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest007: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest007:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock007: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest007: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) @@ -248,24 +250,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock007, TestSize.Level2) pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON, false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock007:End."); - GTEST_LOG_(INFO) << "PowerMgrMock007: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest007:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest007: end."; } /** - * @tc.name: PowerMgrMock008 + * @tc.name: PowerMgrUnittest008 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock008, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest008, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock008: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock008:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest008: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest008:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock008: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest008: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) @@ -276,24 +278,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock008, TestSize.Level2) pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI , false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock008:End."); - GTEST_LOG_(INFO) << "PowerMgrMock008: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest008:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest008: end."; } /** - * @tc.name: PowerMgrMock009 + * @tc.name: PowerMgrUnittest009 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock009, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest009, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock009: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock009:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest009: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest009:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock009: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest009: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) @@ -304,24 +306,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock009, TestSize.Level2) pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON , false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock009:End."); - GTEST_LOG_(INFO) << "PowerMgrMock009: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest009:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest009: end."; } /** - * @tc.name: PowerMgrMock010 + * @tc.name: PowerMgrUnittest010 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock010, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest010, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock010: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock010:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest010: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest010:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock010: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest010: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) @@ -332,24 +334,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock010, TestSize.Level2) pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY , false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock010:End."); - GTEST_LOG_(INFO) << "PowerMgrMock010: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest010:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest010: end."; } /** - * @tc.name: PowerMgrMock011 + * @tc.name: PowerMgrUnittest011 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock011, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest011, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock011: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock011:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest011: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest011:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock011: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest011: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) @@ -360,26 +362,26 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock011, TestSize.Level2) pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND , false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock011:End."); - GTEST_LOG_(INFO) << "PowerMgrMock011: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest011:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest011: end."; } /** - * @tc.name: PowerMgrMock012 + * @tc.name: PowerMgrUnittest012 * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock012, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest012, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock012: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock012:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest012: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest012:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock012: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest012: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -392,24 +394,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock012, TestSize.Level2) pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock012:End."); - GTEST_LOG_(INFO) << "PowerMgrMock012: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest012:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest012: end."; } /** - * @tc.name: PowerMgrMock013 + * @tc.name: PowerMgrUnittest013 * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock013, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest013, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock013: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock013:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest013: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest013:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock013: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest013: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -422,24 +424,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock013, TestSize.Level2) pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock013:End."); - GTEST_LOG_(INFO) << "PowerMgrMock013: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest013:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest013: end."; } /** - * @tc.name: PowerMgrMock014 + * @tc.name: PowerMgrUnittest014 * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock014, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest014, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock014: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock014:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest014: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest014:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock014: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest014: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -452,24 +454,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock014, TestSize.Level2) pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION , std::string("test")); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock014:End."); - GTEST_LOG_(INFO) << "PowerMgrMock014: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest014:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest014: end."; } /** - * @tc.name: PowerMgrMock015 + * @tc.name: PowerMgrUnittest015 * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock015, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest015, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock015: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock015:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest015: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest015:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock015: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest015: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -482,24 +484,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock015, TestSize.Level2) pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN , std::string("test")); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock015:End."); - GTEST_LOG_(INFO) << "PowerMgrMock015: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest015:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest015: end."; } /** - * @tc.name: PowerMgrMock016 + * @tc.name: PowerMgrUnittest016 * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock016, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest016, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock016: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock016:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest016: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest016:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock016: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest016: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -512,24 +514,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock016, TestSize.Level2) pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_GESTURE , std::string("test")); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock016:End."); - GTEST_LOG_(INFO) << "PowerMgrMock016: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest016:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest016: end."; } /** - * @tc.name: PowerMgrMock017 + * @tc.name: PowerMgrUnittest017 * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock017, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest017, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock017: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock017:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest017: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest017:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock017: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest017: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -542,24 +544,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock017, TestSize.Level2) pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH , std::string("test")); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock017:End."); - GTEST_LOG_(INFO) << "PowerMgrMock017: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest017:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest017: end."; } /** - * @tc.name: PowerMgrMock018 + * @tc.name: PowerMgrUnittest018 * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock018, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest018, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock018: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock018:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest018: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest018:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock018: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest018: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -572,24 +574,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock018, TestSize.Level2) pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY , std::string("test")); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock018:End."); - GTEST_LOG_(INFO) << "PowerMgrMock018: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest018:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest018: end."; } /** - * @tc.name: PowerMgrMock019 + * @tc.name: PowerMgrUnittest019 * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock019, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest019, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock019: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock019:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest019: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest019:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock019: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest019: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -602,24 +604,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock019, TestSize.Level2) pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION , std::string("test")); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock019:End."); - GTEST_LOG_(INFO) << "PowerMgrMock019: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest019:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest019: end."; } /** - * @tc.name: PowerMgrMock020 + * @tc.name: PowerMgrUnittest020 * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock020, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest020, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock020: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock020:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest020: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest020:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock020: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest020: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -632,24 +634,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock020, TestSize.Level2) pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_HDMI , std::string("test")); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock020:End."); - GTEST_LOG_(INFO) << "PowerMgrMock020: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest020:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest020: end."; } /** - * @tc.name: PowerMgrMock021 + * @tc.name: PowerMgrUnittest021 * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock021, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest021, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock021: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock021:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest021: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest021:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock021: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest021: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -662,24 +664,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock021, TestSize.Level2) pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID , std::string("test")); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock021:End."); - GTEST_LOG_(INFO) << "PowerMgrMock021: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest021:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest021: end."; } /** - * @tc.name: PowerMgrMock022 + * @tc.name: PowerMgrUnittest022 * @tc.desc: test SuspendDevice and auto sleep by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock022, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest022, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock022: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock022:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest022: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest022:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock022: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest022: Failed to get PowerMgrService"; } pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); @@ -697,24 +699,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock022, TestSize.Level2) sleep(SLEEP_WAIT_TIME_S + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock022:End."); - GTEST_LOG_(INFO) << "PowerMgrMock022: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest022:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest022: end."; } /** - * @tc.name: PowerMgrMock023 + * @tc.name: PowerMgrUnittest023 * @tc.desc: test WakeupDevice and auto suspend and sleep by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock023, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest023, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock023: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock023:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest023: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest023:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock023: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest023: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) @@ -723,33 +725,33 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock023, TestSize.Level2) ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID , std::string("test")); - sleep(SCREEN_DIM_WAIT_TIME_S + 1); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); - sleep(SLEEP_WAIT_TIME_S + 1); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); sleep(SLEEP_WAIT_TIME_S + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock023:End."); - GTEST_LOG_(INFO) << "PowerMgrMock023: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest023:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest023: end."; } /** - * @tc.name: PowerMgrMock024 + * @tc.name: PowerMgrUnittest024 * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock024, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest024, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock024: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock024:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest024: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest024:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock024: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest024: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, GetDisplayState()) @@ -764,24 +766,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock024, TestSize.Level2) sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock024:End."); - GTEST_LOG_(INFO) << "PowerMgrMock024: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest024:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest024: end."; } /** - * @tc.name: PowerMgrMock025 + * @tc.name: PowerMgrUnittest025 * @tc.desc: test IsScreenOn by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock025, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest025, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock025: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock025:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest025: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest025:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock025: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest025: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, GetDisplayState()) @@ -790,24 +792,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock025, TestSize.Level2) EXPECT_EQ(pms->IsScreenOn(), true); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock025:End."); - GTEST_LOG_(INFO) << "PowerMgrMock025: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest025:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest025: end."; } /** - * @tc.name: PowerMgrMock026 + * @tc.name: PowerMgrUnittest026 * @tc.desc: test IsScreenOn by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock026, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest026, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock026: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock026:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest026: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest026:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock026: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest026: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, GetDisplayState()) @@ -816,24 +818,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock026, TestSize.Level2) EXPECT_EQ(pms->IsScreenOn(), true); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock026:End"); - GTEST_LOG_(INFO) << "PowerMgrMock026: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest026:End"); + GTEST_LOG_(INFO) << "PowerMgrUnittest026: end."; } /** - * @tc.name: PowerMgrMock027 + * @tc.name: PowerMgrUnittest027 * @tc.desc: test IsScreenOn by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock027, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest027, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock027: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock027:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest027: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest027:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock027: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest027: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, GetDisplayState()) @@ -842,24 +844,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock027, TestSize.Level2) EXPECT_EQ(pms->IsScreenOn(), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock027:End."); - GTEST_LOG_(INFO) << "PowerMgrMock027: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest027:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest027: end."; } /** - * @tc.name: PowerMgrMock028 + * @tc.name: PowerMgrUnittest028 * @tc.desc: test IsScreenOn by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock028, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest028, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock028: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock028:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest028: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest028:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock028: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest028: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, GetDisplayState()) @@ -868,24 +870,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock028, TestSize.Level2) EXPECT_EQ(pms->IsScreenOn(), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock028:End."); - GTEST_LOG_(INFO) << "PowerMgrMock028: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest028:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest028: end."; } /** - * @tc.name: PowerMgrMock029 + * @tc.name: PowerMgrUnittest029 * @tc.desc: test ForceSuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock029, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest029, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock029: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock029:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest029: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest029:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock029: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest029: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) @@ -894,24 +896,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock029, TestSize.Level2) EXPECT_EQ(pms->ForceSuspendDevice(0), true); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock029:End."); - GTEST_LOG_(INFO) << "PowerMgrMock029: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest029:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest029: end."; } /** - * @tc.name: PowerMgrMock030 + * @tc.name: PowerMgrUnittest030 * @tc.desc: test Screen on RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock030, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest030, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock030: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock030:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest030: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest030:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock030: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest030: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -927,24 +929,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock030, TestSize.Level2) EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock030:End."); - GTEST_LOG_(INFO) << "PowerMgrMock030: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest030:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest030: end."; } /** - * @tc.name: PowerMgrMock031 + * @tc.name: PowerMgrUnittest031 * @tc.desc: test background RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock031, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest031, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock031: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock031:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest031: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest031:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock031: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest031: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -964,24 +966,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock031, TestSize.Level2) EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock031:End."); - GTEST_LOG_(INFO) << "PowerMgrMock031: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest031:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest031: end."; } /** - * @tc.name: PowerMgrMock032 + * @tc.name: PowerMgrUnittest032 * @tc.desc: test proximity RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock032, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest032, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock032: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock032:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest032: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest032:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock032: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest032: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); @@ -1001,24 +1003,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock032, TestSize.Level2) EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock032:End."); - GTEST_LOG_(INFO) << "PowerMgrMock032: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest032:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest032: end."; } /** - * @tc.name: PowerMgrMock033 + * @tc.name: PowerMgrUnittest033 * @tc.desc: test RunningLock release by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock033, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest033, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock033: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock033:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest033: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest033:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock033: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest033: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -1031,24 +1033,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock033, TestSize.Level2) EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock033:End."); - GTEST_LOG_(INFO) << "PowerMgrMock033: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest033:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest033: end."; } /** - * @tc.name: PowerMgrMock034 + * @tc.name: PowerMgrUnittest034 * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock034, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest034, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock034: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock034:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest034: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest034:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock034: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest034: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, GetDisplayState()) @@ -1063,24 +1065,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock034, TestSize.Level2) sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock034:End."); - GTEST_LOG_(INFO) << "PowerMgrMock034: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest034:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest034: end."; } /** - * @tc.name: PowerMgrMock035 + * @tc.name: PowerMgrUnittest035 * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock035, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest035, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock035: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock035:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest035: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest035:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock035: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest035: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, GetDisplayState()) @@ -1095,24 +1097,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock035, TestSize.Level2) sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock035:End."); - GTEST_LOG_(INFO) << "PowerMgrMock035: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest035:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest035: end."; } /** - * @tc.name: PowerMgrMock036 + * @tc.name: PowerMgrUnittest036 * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock036, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest036, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock036: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock036:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest036: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest036:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock036: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest036: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, GetDisplayState()) @@ -1127,24 +1129,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock036, TestSize.Level2) sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock036:End."); - GTEST_LOG_(INFO) << "PowerMgrMock036: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest036:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest036: end."; } /** - * @tc.name: PowerMgrMock037 + * @tc.name: PowerMgrUnittest037 * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock037, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest037, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock037: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock037:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest037: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest037:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock037: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest037: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, GetDisplayState()) @@ -1159,24 +1161,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock037, TestSize.Level2) sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock037:End."); - GTEST_LOG_(INFO) << "PowerMgrMock037: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest037:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest037: end."; } /** - * @tc.name: PowerMgrMock038 + * @tc.name: PowerMgrUnittest038 * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock038, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest038, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock038: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock038:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest038: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest038:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock038: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest038: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, GetDisplayState()) @@ -1191,25 +1193,25 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock038, TestSize.Level2) sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock038:End."); - GTEST_LOG_(INFO) << "PowerMgrMock038: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest038:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest038: end."; } /** - * @tc.name: PowerMgrMock039 + * @tc.name: PowerMgrUnittest039 * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock039, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest039, TestSize.Level2) { UserActivityType abnormaltype={}; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock039: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock039:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest039: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest039:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock039: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest039: Failed to get PowerMgrService"; } pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); @@ -1224,58 +1226,61 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock039, TestSize.Level2) EXPECT_EQ(pms->IsScreenOn(), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock039:End."); - GTEST_LOG_(INFO) << "PowerMgrMock039: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest039:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest039: end."; } /** - * @tc.name: PowerMgrMock040 + * @tc.name: PowerMgrUnittest040 * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock040, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest040, TestSize.Level2) { UserActivityType abnormaltype=UserActivityType(6); sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock040: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock040:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest040: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest040:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock040: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest040: Failed to get PowerMgrService"; } pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); - EXPECT_CALL(*stateAction, GetDisplayState()) - .Times(::testing::AtLeast(1)) - .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); EXPECT_CALL(*stateAction, RefreshActivity(0, _, _)).Times(0); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); pms->RefreshActivity(0, abnormaltype, true); - - sleep(SLEEP_WAIT_TIME_S + 1); - EXPECT_EQ(pms->IsScreenOn(), false); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock040:End."); - GTEST_LOG_(INFO) << "PowerMgrMock040: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest040:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest040: end."; } /** - * @tc.name: PowerMgrMock041 + * @tc.name: PowerMgrUnittest041 * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock041, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest041, TestSize.Level2) { WakeupDeviceType abnormaltype=WakeupDeviceType(10); sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock041: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock041:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest041: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest041:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock041: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest041: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -1288,25 +1293,25 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock041, TestSize.Level2) EXPECT_EQ(pms->IsScreenOn(), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock041:End."); - GTEST_LOG_(INFO) << "PowerMgrMock041: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest041:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest041: end."; } /** - * @tc.name: PowerMgrMock042 + * @tc.name: PowerMgrUnittest042 * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock042, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest042, TestSize.Level2) { WakeupDeviceType abnormaltype=WakeupDeviceType(999); sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock042: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock042:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest042: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest042:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock042: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest042: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -1319,59 +1324,59 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock042, TestSize.Level2) EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock042:End."); - GTEST_LOG_(INFO) << "PowerMgrMock042: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest042:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest042: end."; } /** - * @tc.name: PowerMgrMock043 + * @tc.name: PowerMgrUnittest043 * @tc.desc: test WakeupDevice and auto suspend by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock043, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest043, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock043: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock043:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest043: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest043:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock043: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest043: Failed to get PowerMgrService"; } - // EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - // .Times(::testing::AtLeast(1)) - // .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); - sleep(SCREEN_DIM_WAIT_TIME_S + 1); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); - sleep(SCREEN_OFF_WAIT_TIME_S + 1); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock043:End."); - GTEST_LOG_(INFO) << "PowerMgrMock043: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest043:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest043: end."; } /** - * @tc.name: PowerMgrMock044 + * @tc.name: PowerMgrUnittest044 * @tc.desc: test WakeupDevice and auto suspend by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock044, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest044, TestSize.Level2) { WakeupDeviceType abnormaltype = WakeupDeviceType(10); sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock044: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock044:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest044: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest044:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock044: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest044: Failed to get PowerMgrService"; } pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); @@ -1380,66 +1385,66 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock044, TestSize.Level2) .WillOnce(::testing::Return(ActionResult::SUCCESS)); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - //EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)).Times(0) - sleep(SCREEN_DIM_WAIT_TIME_S/2); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3)/2); pms->WakeupDevice(0, abnormaltype , std::string("test")); - sleep(SCREEN_DIM_WAIT_TIME_S/2 + 1); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3)/2 + 1); ResetMockAction(); - GTEST_LOG_(INFO) << "PowerMgrMock044: end."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock044:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest044: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest044:End."); } /** - * @tc.name: PowerMgrMock045 + * @tc.name: PowerMgrUnittest045 * @tc.desc: test WakeupDevice and auto suspend by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock045, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest045, TestSize.Level2) { WakeupDeviceType abnormaltype = WakeupDeviceType(999); sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock045: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock045:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest045: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest045:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock045: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest045: Failed to get PowerMgrService"; } pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); - // EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - // .Times(::testing::AtLeast(1)) - // .WillOnce(::testing::Return(ActionResult::SUCCESS)); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - //EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)).Times(0) + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); - sleep(SCREEN_OFF_WAIT_TIME_S/2); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) /2); pms->WakeupDevice(0, abnormaltype , std::string("test")); - sleep(SCREEN_OFF_WAIT_TIME_S/2 + 1); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3)/2 + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock045:End."); - GTEST_LOG_(INFO) << "PowerMgrMock045: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest045:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest045: end."; } /** - * @tc.name: PowerMgrMock046 + * @tc.name: PowerMgrUnittest046 * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock046, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest046, TestSize.Level2) { UserActivityType abnormaltype = UserActivityType(6); sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock046: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock046:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest046: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest046:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock046: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest046: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, GetDisplayState()) @@ -1452,25 +1457,25 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock046, TestSize.Level2) sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2 + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock046:End."); - GTEST_LOG_(INFO) << "PowerMgrMock046: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest046:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest046: end."; } /** - * @tc.name: PowerMgrMock047 + * @tc.name: PowerMgrUnittest047 * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock047, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest047, TestSize.Level2) { UserActivityType abnormaltype = {}; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock047: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock047:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest047: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest047:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock047: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest047: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, GetDisplayState()) @@ -1483,24 +1488,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock047, TestSize.Level2) sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2 + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock047:End."); - GTEST_LOG_(INFO) << "PowerMgrMock047: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest047:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest047: end."; } /** - * @tc.name: PowerMgrMock048 + * @tc.name: PowerMgrUnittest048 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock048, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest048, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock048: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock048:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest048: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest048:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock048: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest048: Failed to get PowerMgrService"; } pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); @@ -1518,55 +1523,54 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock048, TestSize.Level2) EXPECT_EQ(PowerState::SLEEP,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock048:End"); - GTEST_LOG_(INFO) << "PowerMgrMock048: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest048:End"); + GTEST_LOG_(INFO) << "PowerMgrUnittest048: end."; } /** - * @tc.name: PowerMgrMock049 + * @tc.name: PowerMgrUnittest049 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock049, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest049, TestSize.Level2) { SuspendDeviceType abnormaltype = SuspendDeviceType(10); sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock049: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock049:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest049: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest049:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock049: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest049: Failed to get PowerMgrService"; } pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); EXPECT_CALL(*stateAction, Suspend(0, _, false)).Times(0); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); - //EXPECT_CALL(*stateAction,Suspend(0, _ , false)).Times(0); pms->SuspendDevice(0, abnormaltype, false); EXPECT_EQ(PowerState::AWAKE,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock049:End."); - GTEST_LOG_(INFO) << "PowerMgrMock049: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest049:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest049: end."; } /** - * @tc.name: PowerMgrMock050 + * @tc.name: PowerMgrUnittest050 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock050, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest050, TestSize.Level2) { SuspendDeviceType abnormaltype = SuspendDeviceType(999); sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock050: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock050:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest050: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest050:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock050: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest050: Failed to get PowerMgrService"; } pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); @@ -1577,24 +1581,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock050, TestSize.Level2) EXPECT_EQ(PowerState::AWAKE,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock050:End."); - GTEST_LOG_(INFO) << "PowerMgrMock050: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest050:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest050: end."; } /** - * @tc.name: PowerMgrMock051 + * @tc.name: PowerMgrUnittest051 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock051, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest051, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock051: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock051:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest051: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest051:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock051: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest051: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -1612,25 +1616,25 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock051, TestSize.Level2) EXPECT_EQ(PowerState::SLEEP,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock051:End."); - GTEST_LOG_(INFO) << "PowerMgrMock051: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest051:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest051: end."; } /** - * @tc.name: PowerMgrMock052 + * @tc.name: PowerMgrUnittest052 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock052, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest052, TestSize.Level2) { SuspendDeviceType abnormaltype = SuspendDeviceType(10); sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock052: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock052:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest052: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest052:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock052: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest052: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -1640,25 +1644,25 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock052, TestSize.Level2) EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock052:End."); - GTEST_LOG_(INFO) << "PowerMgrMock052: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest052:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest052: end."; } /** - * @tc.name: PowerMgrMock053 + * @tc.name: PowerMgrUnittest053 * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock053, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest053, TestSize.Level2) { SuspendDeviceType abnormaltype = {}; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock053: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock053:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest053: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest053:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock053: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest053: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -1668,26 +1672,26 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock053, TestSize.Level2) EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock053:End."); - GTEST_LOG_(INFO) << "PowerMgrMock053: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest053:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest053: end."; } /** - * @tc.name: PowerMgrMock054 + * @tc.name: PowerMgrUnittest054 * @tc.desc: test ForceSuspendDevice by mock during Inactive * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock054, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest054, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock054: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock054:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest054: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest054:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock054: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest054: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -1699,24 +1703,59 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock054, TestSize.Level2) EXPECT_EQ(PowerState::SLEEP,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock054:End."); - GTEST_LOG_(INFO) << "PowerMgrMock054: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest054:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest054: end."; +} + +/** + * @tc.name: PowerMgrUnittest055 + * @tc.desc: test auto suspend by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest055, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrUnittest055: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest055:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrUnittest055: Failed to get PowerMgrService"; + } + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID , std::string("test")); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM )) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF )) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest055:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest055: end."; } /** - * @tc.name: PowerMgrMock056 + * @tc.name: PowerMgrUnittest056 * @tc.desc: test SCREEN_ON RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock056, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest056, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock056: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock056:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest056: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest056:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock056: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest056: Failed to get PowerMgrService"; } EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); @@ -1728,7 +1767,7 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock056, TestSize.Level2) EXPECT_EQ(pms->IsUsed(token), true); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); - sleep(SCREEN_DIM_WAIT_TIME_S + 1); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); EXPECT_EQ(PowerState::AWAKE,pms->GetState()); @@ -1736,24 +1775,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock056, TestSize.Level2) pms->UnLock(token); EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock056:End."); - GTEST_LOG_(INFO) << "PowerMgrMock056: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest056:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest056: end."; } /** - * @tc.name: PowerMgrMock057 + * @tc.name: PowerMgrUnittest057 * @tc.desc: test SCREEN_ON RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock057, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest057, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock057: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock057:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest057: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest057:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock057: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest057: Failed to get PowerMgrService"; } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); @@ -1770,26 +1809,57 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock057, TestSize.Level2) pms->UnLock(token); EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock057:End."); - GTEST_LOG_(INFO) << "PowerMgrMock057: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest057:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest057: end."; } +/** + * @tc.name: PowerMgrUnittest058 + * @tc.desc: test Auto DIM by mock after 10min + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest058, TestSize.Level2) +{ + int64_t time =600000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrUnittest058: start."; + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrUnittest058: Failed to get PowerMgrService"; + } + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000-2); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(3); + ResetMockAction(); +pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrUnittest058: end."; +} /** - * @tc.name: PowerMgrMock059 + * @tc.name: PowerMgrUnittest059 * @tc.desc: test Screen RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock059, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest059, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock059: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock059:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest059: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest059:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock059: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest059: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -1803,33 +1873,26 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock059, TestSize.Level2) pms->UnLock(token); EXPECT_EQ(pms->IsUsed(token), false); - ON_CALL(*stateAction, GetDisplayState()) - .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - sleep(SCREEN_OFF_WAIT_TIME_S+1); - EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock059:End."); - GTEST_LOG_(INFO) << "PowerMgrMock059: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest059:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest059: end."; } /** - * @tc.name: PowerMgrMock060 + * @tc.name: PowerMgrUnittest060 * @tc.desc: test Screen RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock060, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest060, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock060: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock060:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest060: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest060:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock060: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest060: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -1846,25 +1909,25 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock060, TestSize.Level2) ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock060:End."); - GTEST_LOG_(INFO) << "PowerMgrMock060: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest060:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest060: end."; } /** - * @tc.name: PowerMgrMock061 + * @tc.name: PowerMgrUnittest061 * @tc.desc: test Screen on RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock061, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest061, TestSize.Level2) { int i; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock061: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock061:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest061: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest061:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock061: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest061: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -1884,24 +1947,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock061, TestSize.Level2) EXPECT_EQ(PowerState::AWAKE,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock061:End."); - GTEST_LOG_(INFO) << "PowerMgrMock061: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest061:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest061: end."; } /** - * @tc.name: PowerMgrMock062 + * @tc.name: PowerMgrUnittest062 * @tc.desc: test Screen RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock062, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest062, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock062: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock062:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest062: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest062:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock062: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest062: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -1925,24 +1988,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock062, TestSize.Level2) EXPECT_EQ(PowerState::SLEEP,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock062:End."); - GTEST_LOG_(INFO) << "PowerMgrMock062: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest062:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest062: end."; } /** - * @tc.name: PowerMgrMock063 + * @tc.name: PowerMgrUnittest063 * @tc.desc: test Screen RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock063, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest063, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock063: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock063:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest063: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest063:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock063: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest063: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -1957,7 +2020,6 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock063, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_EQ(pms->ForceSuspendDevice(0), true); - //pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); sleep(SLEEP_WAIT_TIME_S + 1); pms->UnLock(token); @@ -1965,24 +2027,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock063, TestSize.Level2) EXPECT_EQ(PowerState::SLEEP,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock063:End."); - GTEST_LOG_(INFO) << "PowerMgrMock063: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest063:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest063: end."; } /** - * @tc.name: PowerMgrMock064 + * @tc.name: PowerMgrUnittest064 * @tc.desc: test Screen RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock064, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest064, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock064: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock063:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest064: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest063:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock064: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest064: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -2003,24 +2065,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock064, TestSize.Level2) EXPECT_EQ(PowerState::AWAKE,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock064:End."); - GTEST_LOG_(INFO) << "PowerMgrMock064: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest064:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest064: end."; } /** - * @tc.name: PowerMgrMock065 + * @tc.name: PowerMgrUnittest065 * @tc.desc: test background RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock065, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest065, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock065: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock065:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest065: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest065:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock065: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest065: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -2040,24 +2102,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock065, TestSize.Level2) pms->UnLock(token); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock065:End."); - GTEST_LOG_(INFO) << "PowerMgrMock065: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest065:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest065: end."; } /** - * @tc.name: PowerMgrMock066 + * @tc.name: PowerMgrUnittest066 * @tc.desc: test background RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock066, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest066, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock066: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock066:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest066: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest066:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock066: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest066: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -2072,10 +2134,10 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock066, TestSize.Level2) pms->UnLock(token); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - sleep(SCREEN_DIM_WAIT_TIME_S+1); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); - sleep(SCREEN_OFF_WAIT_TIME_S+1); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); EXPECT_EQ(pms->IsUsed(token), false); @@ -2084,24 +2146,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock066, TestSize.Level2) EXPECT_EQ(PowerState::SLEEP,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock066:End."); - GTEST_LOG_(INFO) << "PowerMgrMock066: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest066:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest066: end."; } /** - * @tc.name: PowerMgrMock067 + * @tc.name: PowerMgrUnittest067 * @tc.desc: test background RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock067, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest067, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock067: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock067:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest067: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest067:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock067: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest067: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -2111,14 +2173,14 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock067, TestSize.Level2) EXPECT_EQ(pms->IsUsed(token), true); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - sleep(SCREEN_DIM_WAIT_TIME_S+1); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - sleep(SCREEN_OFF_WAIT_TIME_S+1); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); sleep(SLEEP_WAIT_TIME_S*10); @@ -2127,32 +2189,32 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock067, TestSize.Level2) ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock067:End."); - GTEST_LOG_(INFO) << "PowerMgrMock067: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest067:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest067: end."; } /** - * @tc.name: PowerMgrMock068 + * @tc.name: PowerMgrUnittest068 * @tc.desc: test background RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock068, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest068, TestSize.Level2) { int i; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock068: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock068:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest068: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest068:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock068: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest068: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - sleep(SCREEN_DIM_WAIT_TIME_S+1); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); pms->CreateRunningLock(token, info); @@ -2160,6 +2222,12 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock068, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); for(i=0;i<10;i++){ pms->Lock(token, info, 0); EXPECT_EQ(pms->IsUsed(token), true); @@ -2172,24 +2240,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock068, TestSize.Level2) EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock068:End."); - GTEST_LOG_(INFO) << "PowerMgrMock068: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest068:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest068: end."; } /** - * @tc.name: PowerMgrMock069 + * @tc.name: PowerMgrUnittest069 * @tc.desc: test background RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock069, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest069, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock069: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock069:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest069: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest069:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock069: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest069: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -2202,15 +2270,6 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock069, TestSize.Level2) pms->Lock(token, info, 0); EXPECT_EQ(pms->IsUsed(token), true); - // ON_CALL(*stateAction, GetDisplayState()) - // .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - // sleep(SCREEN_DIM_WAIT_TIME_S+1); - // ON_CALL(*stateAction, GetDisplayState()) - // .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); - // sleep(SCREEN_OFF_WAIT_TIME_S+1); - // EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - // .Times(1) - // .WillOnce(::testing::Return(ActionResult::SUCCESS)); sleep(SLEEP_WAIT_TIME_S + 1); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) .Times(1) @@ -2225,33 +2284,30 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock069, TestSize.Level2) EXPECT_EQ(PowerState::AWAKE,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock069:End"); - GTEST_LOG_(INFO) << "PowerMgrMock069: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest069:End"); + GTEST_LOG_(INFO) << "PowerMgrUnittest069: end."; } /** - * @tc.name: PowerMgrMock070 + * @tc.name: PowerMgrUnittest070 * @tc.desc: test background RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock070, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest070, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock070: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest070: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest070:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock070: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest070: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); pms->CreateRunningLock(token, info); - // EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - // .Times(1) - // .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); pms->Lock(token, info, 0); @@ -2270,24 +2326,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock070, TestSize.Level2) EXPECT_EQ(PowerState::SLEEP,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070:End."); - GTEST_LOG_(INFO) << "PowerMgrMock070: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest070:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest070: end."; } /** - * @tc.name: PowerMgrMock071 + * @tc.name: PowerMgrUnittest071 * @tc.desc: test proximity screen control RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock071, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest071, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock071: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock071:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest071: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest071:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock071: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest071: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -2310,25 +2366,25 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock071, TestSize.Level2) EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock071:End."); - GTEST_LOG_(INFO) << "PowerMgrMock071: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest071:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest071: end."; } /** - * @tc.name: PowerMgrMock072 + * @tc.name: PowerMgrUnittest072 * @tc.desc: test proximity screen control RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock072, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest072, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock072: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock072:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest072: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest072:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock072: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest072: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -2353,24 +2409,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock072, TestSize.Level2) ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock072:End."); - GTEST_LOG_(INFO) << "PowerMgrMock072: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest072:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest072: end."; } /** - * @tc.name: PowerMgrMock073 + * @tc.name: PowerMgrUnittest073 * @tc.desc: test proximity screen control RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock073, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest073, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock073: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock073:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest073: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest073:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock073: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest073: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -2383,16 +2439,15 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock073, TestSize.Level2) pms->UnLock(token); EXPECT_EQ(pms->IsUsed(token), false); - //sleep(SCREEN_DIM_WAIT_TIME_S+1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - sleep(SCREEN_DIM_WAIT_TIME_S+1); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) .Times(::testing::AtLeast(1)) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - sleep(SCREEN_OFF_WAIT_TIME_S + 1); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) .Times(1) @@ -2403,34 +2458,34 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock073, TestSize.Level2) EXPECT_EQ(PowerState::SLEEP,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock073:End."); - GTEST_LOG_(INFO) << "PowerMgrMock073: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest073:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest073: end."; } /** - * @tc.name: PowerMgrMock074 + * @tc.name: PowerMgrUnittest074 * @tc.desc: test proximity RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock074, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest074, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock074: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock074:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest074: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest074:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock074: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest074: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); pms->CreateRunningLock(token, info); - pms->ReleaseRunningLock(token); + //pms->ReleaseRunningLock(token); - EXPECT_CALL(*lockAction, Lock(_, _)).Times(0); + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(pms->IsUsed(token), true); sleep(SCREEN_OFF_WAIT_TIME_S+1); EXPECT_EQ(PowerState::AWAKE,pms->GetState()); @@ -2441,28 +2496,28 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock074, TestSize.Level2) EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); + // pms->UnLock(token); + // EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock074:End."); - GTEST_LOG_(INFO) << "PowerMgrMock074: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest074:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest074: end."; } /** - * @tc.name: PowerMgrMock075 + * @tc.name: PowerMgrUnittest075 * @tc.desc: test proximity RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock075, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest075, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock075: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock075:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest075: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest075:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock075: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest075: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -2472,39 +2527,38 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock075, TestSize.Level2) EXPECT_EQ(pms->IsUsed(token), true); sleep(SLEEP_WAIT_TIME_S*10); EXPECT_EQ(PowerState::AWAKE,pms->GetState()); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); - sleep(SLEEP_WAIT_TIME_S+1); + //sleep(SLEEP_WAIT_TIME_S+1); EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); + //pms->UnLock(token); + //EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock075:End."); - GTEST_LOG_(INFO) << "PowerMgrMock075: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest075:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest075: end."; } /** - * @tc.name: PowerMgrMock076 + * @tc.name: PowerMgrUnittest076 * @tc.desc: test proximity RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock076, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest076, TestSize.Level2) { int i; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock076: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock076:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest076: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest076:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock076: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest076: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -2529,29 +2583,26 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock076, TestSize.Level2) EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); - - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock076:End."); - GTEST_LOG_(INFO) << "PowerMgrMock076: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest076:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest076: end."; } /** - * @tc.name: PowerMgrMock077 + * @tc.name: PowerMgrUnittest077 * @tc.desc: test proximity RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock077, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest077, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock077: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock077:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest077: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest077:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock077: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest077: Failed to get PowerMgrService"; } sptr token = new RunningLockTokenStub(); @@ -2572,37 +2623,33 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock077, TestSize.Level2) sleep(SLEEP_WAIT_TIME_S + 1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - sleep(SCREEN_DIM_WAIT_TIME_S+1); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); - sleep(SCREEN_OFF_WAIT_TIME_S+1); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); EXPECT_EQ(PowerState::SLEEP,pms->GetState()); - EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); - ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock077:End."); - GTEST_LOG_(INFO) << "PowerMgrMock077: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest077:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest077: end."; } /** - * @tc.name: PowerMgrMock078 + * @tc.name: PowerMgrUnittest078 * @tc.desc: test proximity RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock078, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest078, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock078: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock078:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest078: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest078:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock078: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest078: Failed to get PowerMgrService"; } //pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); @@ -2614,9 +2661,6 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock078, TestSize.Level2) pms->Lock(token, info, 0); EXPECT_EQ(pms->IsUsed(token), true); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); @@ -2628,27 +2672,27 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock078, TestSize.Level2) EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock078:End."); - GTEST_LOG_(INFO) << "PowerMgrMock078: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest078:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest078: end."; } /** - * @tc.name: PowerMgrMock079 + * @tc.name: PowerMgrUnittest079 * @tc.desc: test proximity RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock079, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest079, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock079: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock079:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest079: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest079:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock079: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest079: Failed to get PowerMgrService"; } - //pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); sptr token = new RunningLockTokenStub(); RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); pms->CreateRunningLock(token, info); @@ -2657,51 +2701,41 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock079, TestSize.Level2) pms->Lock(token, info, 0); EXPECT_EQ(pms->IsUsed(token), true); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, - Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , - std::string("test"), _)).Times(1); pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); EXPECT_EQ(PowerState::AWAKE,pms->GetState()); - EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); - ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock079:End."); - GTEST_LOG_(INFO) << "PowerMgrMock079: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest079:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest079: end."; } /** - * @tc.name: PowerMgrMock080 + * @tc.name: PowerMgrUnittest080 * @tc.desc: test Auto SuspendDevice by mock after 15s * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock080, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest080, TestSize.Level2) { int64_t time =15000; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock080: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock080:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest080: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest080:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock080: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest080: Failed to get PowerMgrService"; } pms->SetDisplayOffTime(time); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - sleep(SCREEN_DIM_WAIT_TIME_S+1); + sleep(((time/1000)*2/3)+1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) + .Times(::testing::AtLeast(1)) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - sleep(time/1000+1); + sleep(time/1000*1/3+1); EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) .Times(1) @@ -2713,38 +2747,38 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock080, TestSize.Level2) ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock080:End."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest080:End."); pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); - GTEST_LOG_(INFO) << "PowerMgrMock080: end."; + GTEST_LOG_(INFO) << "PowerMgrUnittest080: end."; } /** - * @tc.name: PowerMgrMock081 + * @tc.name: PowerMgrUnittest081 * @tc.desc: test Auto SuspendDevice by mock after 30s * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock081, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest081, TestSize.Level2) { int64_t time =30000; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock081: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock081:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest081: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest081:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock081: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest081: Failed to get PowerMgrService"; } pms->SetDisplayOffTime(time); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - sleep(SCREEN_DIM_WAIT_TIME_S+1); + sleep(((time/1000)*2/3)+1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) + .Times(::testing::AtLeast(1)) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - sleep(time/1000+1); + sleep(((time/1000)*1/3)+1); EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); @@ -2753,154 +2787,187 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock081, TestSize.Level2) sleep(SLEEP_WAIT_TIME_S+1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock081:End"); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest081:End"); pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); - GTEST_LOG_(INFO) << "PowerMgrMock081: end."; + GTEST_LOG_(INFO) << "PowerMgrUnittest081: end."; } /** - * @tc.name: PowerMgrMock082 + * @tc.name: PowerMgrUnittest082 * @tc.desc: test Auto SuspendDevice by mock after 1min * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock082, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest082, TestSize.Level2) { int64_t time =60000; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock082: start."; + GTEST_LOG_(INFO) << "PowerMgrUnittest082: start."; sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock082: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest082: Failed to get PowerMgrService"; } + pms->SetDisplayOffTime(time); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(((time/1000)*2/3)+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) + .Times(::testing::AtLeast(1)) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + sleep(time/1000*1/3+1); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->SetDisplayOffTime(time); - sleep(time/1000+1); + // EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); sleep(SLEEP_WAIT_TIME_S+1); ResetMockAction(); -pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); - GTEST_LOG_(INFO) << "PowerMgrMock082: end."; + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrUnittest082: end."; } /** - * @tc.name: PowerMgrMock083 + * @tc.name: PowerMgrUnittest083 * @tc.desc: test Auto SuspendDevice by mock after 2mins * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock083, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest083, TestSize.Level2) { int64_t time =120000; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock083: start."; + GTEST_LOG_(INFO) << "PowerMgrUnittest083: start."; sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock083: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest083: Failed to get PowerMgrService"; } + pms->SetDisplayOffTime(time); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(((time/1000)*2/3)+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) + .Times(::testing::AtLeast(1)) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + sleep(time/1000*1/3+1); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->SetDisplayOffTime(time); - sleep(time/1000+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); sleep(SLEEP_WAIT_TIME_S+1); ResetMockAction(); -pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); - GTEST_LOG_(INFO) << "PowerMgrMock083: end."; + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrUnittest083: end."; } /** - * @tc.name: PowerMgrMock084 + * @tc.name: PowerMgrUnittest084 * @tc.desc: test Auto SuspendDevice by mock after 5mins * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock084, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest084, TestSize.Level2) { int64_t time =300000; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock084: start."; + GTEST_LOG_(INFO) << "PowerMgrUnittest084: start."; sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock084: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest084: Failed to get PowerMgrService"; } + pms->SetDisplayOffTime(time); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(((time/1000)*2/3)+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) + .Times(::testing::AtLeast(1)) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + sleep(time/1000*1/3+1); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->SetDisplayOffTime(time); - sleep(time/1000+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); sleep(SLEEP_WAIT_TIME_S+1); ResetMockAction(); -pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); - GTEST_LOG_(INFO) << "PowerMgrMock084: end."; + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrUnittest084: end."; } /** - * @tc.name: PowerMgrMock085 + * @tc.name: PowerMgrUnittest085 * @tc.desc: test Auto SuspendDevice by mock after 10mins * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock085, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest085, TestSize.Level2) { int64_t time =600000; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock085: start."; + GTEST_LOG_(INFO) << "PowerMgrUnittest085: start."; sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock085: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest085: Failed to get PowerMgrService"; } + pms->SetDisplayOffTime(time); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(((time/1000)*2/3)+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) + .Times(::testing::AtLeast(1)) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + sleep(time/1000*1/3+1); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->SetDisplayOffTime(time); - sleep(time/1000+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); sleep(SLEEP_WAIT_TIME_S+1); ResetMockAction(); pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); - GTEST_LOG_(INFO) << "PowerMgrMock085: end."; + GTEST_LOG_(INFO) << "PowerMgrUnittest085: end."; } /** - * @tc.name: PowerMgrMock086 + * @tc.name: PowerMgrUnittest086 * @tc.desc: test Auto DIM by mock after 15s * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock086, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest086, TestSize.Level2) { int64_t time =15000; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock086: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest086: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest086:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock086: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest086: Failed to get PowerMgrService"; } pms->SetDisplayOffTime(time); pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086:DeviceStateAction::SetDisplayState."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest086:DeviceStateAction::SetDisplayState."); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) @@ -2910,33 +2977,33 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock086, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086:Start sleep."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest086:Start sleep."); sleep(time/1000-2); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); sleep(3); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086: sleep end."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest086: sleep end."); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086:End."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest086:End."); pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); - GTEST_LOG_(INFO) << "PowerMgrMock086: end."; + GTEST_LOG_(INFO) << "PowerMgrUnittest086: end."; } /** - * @tc.name: PowerMgrMock087 + * @tc.name: PowerMgrUnittest087 * @tc.desc: test Auto DIM by mock after 30s * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock087, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest087, TestSize.Level2) { int64_t time =30000; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock087: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0087:Start."); + GTEST_LOG_(INFO) << "PowerMgrUnittest087: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest0087:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock087: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest087: Failed to get PowerMgrService"; } ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); @@ -2952,25 +3019,25 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock087, TestSize.Level2) .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); sleep(3); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock087:End."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest087:End."); pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); - GTEST_LOG_(INFO) << "PowerMgrMock087: end."; + GTEST_LOG_(INFO) << "PowerMgrUnittest087: end."; } /** - * @tc.name: PowerMgrMock088 + * @tc.name: PowerMgrUnittest088 * @tc.desc: test Auto DIM by mock after 60s * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock088, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest088, TestSize.Level2) { int64_t time =60000; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock088: start."; + GTEST_LOG_(INFO) << "PowerMgrUnittest088: start."; sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock088: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest088: Failed to get PowerMgrService"; } ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); @@ -2987,23 +3054,23 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock088, TestSize.Level2) sleep(3); ResetMockAction(); pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); - GTEST_LOG_(INFO) << "PowerMgrMock088: end."; + GTEST_LOG_(INFO) << "PowerMgrUnittest088: end."; } /** - * @tc.name: PowerMgrMock089 + * @tc.name: PowerMgrUnittest089 * @tc.desc: test Auto DIM by mock after 2min * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock089, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest089, TestSize.Level2) { int64_t time =120000; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock089: start."; + GTEST_LOG_(INFO) << "PowerMgrUnittest089: start."; sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock089: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest089: Failed to get PowerMgrService"; } ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); @@ -3020,23 +3087,23 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock089, TestSize.Level2) sleep(3); ResetMockAction(); pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); - GTEST_LOG_(INFO) << "PowerMgrMock089: end."; + GTEST_LOG_(INFO) << "PowerMgrUnittest089: end."; } /** - * @tc.name: PowerMgrMock090 + * @tc.name: PowerMgrUnittest090 * @tc.desc: test Auto DIM by mock after 5min * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock090, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest090, TestSize.Level2) { int64_t time =300000; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock090: start."; + GTEST_LOG_(INFO) << "PowerMgrUnittest090: start."; sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock090: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest090: Failed to get PowerMgrService"; } ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); @@ -3053,38 +3120,53 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock090, TestSize.Level2) sleep(3); ResetMockAction(); pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); - GTEST_LOG_(INFO) << "PowerMgrMock090: end."; + GTEST_LOG_(INFO) << "PowerMgrUnittest090: end."; } + + /** - * @tc.name: PowerMgrMock091 - * @tc.desc: test Auto DIM by mock after 10min + * @tc.name: PowerMgrUnittest091 + * @tc.desc: test proximity screen control RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock091, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrUnittest091, TestSize.Level2) { - int64_t time =600000; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock091: start."; + GTEST_LOG_(INFO) << "PowerMgrUnittest091: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest091:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock091: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrUnittest091: Failed to get PowerMgrService"; } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep(SLEEP_WAIT_TIME_S ); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->SetDisplayOffTime(time); - sleep(time/1000-2); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3)+1); ON_CALL(*stateAction, GetDisplayState()) .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); - sleep(3); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + ResetMockAction(); -pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); - GTEST_LOG_(INFO) << "PowerMgrMock091: end."; -} \ No newline at end of file + POWER_HILOGD(MODULE_SERVICE, "PowerMgrUnittest091:End."); + GTEST_LOG_(INFO) << "PowerMgrUnittest091: end."; +} + + + + diff --git a/test/systemtest/BUILD.gn b/test/systemtest/BUILD.gn index 843feafd..5c940130 100644 --- a/test/systemtest/BUILD.gn +++ b/test/systemtest/BUILD.gn @@ -25,6 +25,35 @@ config("module_private_config") { "mock", "//utils/system/safwk/native/include", "//third_party/googletest/googletest/include", + "//base/powermgr/power_manager/services/native/include", + "//base/powermgr/power_manager/services/native/src", + "//foundation/communication/ipc/interfaces/innerkits/ipc_core/include", + "//utils/native/base/include", + "//foundation/distributedschedule/safwk/services/safwk/include", + "//base/powermgr/power_manager/interfaces/innerkits/native/include", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler/include", + "//base/notification/ces_standard/cesfwk/kits/native/include", + "//foundation/aafwk/standard/interfaces/innerkits/want/include", + "//foundation/distributedschedule/dmsfwk/services/dtbschedmgr/include", + "//foundation/aafwk/standard/interfaces/innerkits/base/include", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base/include", + "//base/powermgr/power_manager/services/zidl/include", + "//base/powermgr/battery_manager/utils/native/include", + "//foundation/aafwk/standard/interfaces/innerkits/want/include/ohos/aafwk/content", + "//base/powermgr/power_manager/services/native/src/actions/default", + "//base/powermgr/display_manager/interfaces/innerkits/native/include", + "//base/powermgr/display_manager/service/native/include", + "//base/powermgr/display_manager/service/zidl/include", + "//drivers/peripheral/display/interfaces/include", + "//foundation/graphic/standard/utils/include", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + "//base/powermgr/power_manager/utils/native/include", + "//base/powermgr/power_manager/services/native/test/unittest/include", + "//base/hiviewdfx/hilog/interfaces/native/innerkits/include", + "//foundation/aafwk/standard/interfaces/innerkits/intent/include", + "//base/notification/ces_standard/cesfwk/innerkits/include", + "//base/notification/ces_standard/cesfwk/services/include", + "//base/notification/ces_standard/common/log/include", ] } @@ -66,9 +95,46 @@ ohos_systemtest("test_power_st_mgr_mock") { external_deps = deps_ex } +################################powersavemode################################ + +ohos_systemtest("test_power_mgr_powersavemode") { + module_out_path = module_output_path + + sources = [ + "src/power_mgr_powersavemode_test.cpp", + ] + + configs = [ + "${powermgr_utils_path}:utils_config", + ":module_private_config", + ] + + deps = [ + "${powermgr_native_innerkits_path}:powermgr_client", + "${powermgr_service_path}:powermgrservice", + "${powermgr_service_path}/native/src/actions:powermgr_actions", + "${powermgr_utils_path}:powermgr_utils", + "//third_party/googletest:gtest_main", + "//third_party/googletest:gmock_main", + "//utils/native/base:utils", + ] + + external_deps = [ "hiviewdfx_hilog_native:libhilog", + "aafwk_standard:base", + "aafwk_standard:want", + "appexecfwk_standard:appexecfwk_base", + "appexecfwk_standard:libeventhandler", + "ipc:ipc_core", + "ces_standard:cesfwk_kits", + "safwk:system_ability_fwk", + "samgr_L2:samgr_proxy", + ] +} + group("systemtest_powermgr") { testonly = true deps = [ + ":test_power_mgr_powersavemode", ":test_power_st_mgr_mock", ] -} +} \ No newline at end of file diff --git a/test/systemtest/include/power_mgr_powersavemode_test.h b/test/systemtest/include/power_mgr_powersavemode_test.h new file mode 100644 index 00000000..f8031fa2 --- /dev/null +++ b/test/systemtest/include/power_mgr_powersavemode_test.h @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2021 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 POWERMGR_POWERSAVEMODE_TEST_H +#define POWERMGR_POWERSAVEMODE_TEST_H + +#include + +#include "power_mgr_client.h" +#include "power_mgr_service.h" +#include "power_mode_callback_stub.h" + +namespace OHOS { +namespace PowerMgr { + +constexpr int SLEEP_WAIT_TIME_S = 6; +constexpr int REFRESHACTIVITY_WAIT_TIME_S = 8; +constexpr int SCREEN_OFF_WAIT_TIME_S = 15; + +class PowerMgrPowerSavemodeTest : public testing::Test{ +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + // class PowerStateTest1Callback : public PowerStateCallbackStub { + // public: + // PowerStateTest1Callback() {}; + // virtual ~PowerStateTest1Callback() {}; + // virtual void OnPowerStateChanged(PowerState state) override; + // }; + class PowerModeTest1Callback : public PowerModeCallbackStub { + public: + PowerModeTest1Callback() {}; + virtual ~PowerModeTest1Callback() {}; + virtual void PowerModeCallback() override; + }; + +}; +// class PowerRegisterCallbackModeTest : public testing::Test { +// public: + +// class PowerModeTest1Callback : public PowerModeCallbackStub { +// public: +// PowerModeTest1Callback() {}; +// virtual ~PowerModeTest1Callback() {}; +// virtual void PowerModeCallback() override; +// }; +// }; +} // namespace PowerMgr +} // namespace OHOS +#endif diff --git a/test/systemtest/src/power_mgr_powersavemode_test.cpp b/test/systemtest/src/power_mgr_powersavemode_test.cpp new file mode 100644 index 00000000..d9f6be58 --- /dev/null +++ b/test/systemtest/src/power_mgr_powersavemode_test.cpp @@ -0,0 +1,599 @@ +/* + * Copyright (c) 2021 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 "power_mgr_powersavemode_test.h" + +#include +#include +#include +#include +#include +#include +#include "power_common.h" +#include "power_mgr_client.h" +#include "power_mgr_service.h" +#include "power_state_machine.h" +#include "sys_param.h" +#include "power_state_machine_info.h" +#include "display_info.h" +#include "running_lock_info.h" +#include "running_lock.h" +#include "ipower_mode_callback.h" + +#include "common_event_manager.h" +#define private public +#define protected public +#include "common_event_manager_service.h" +#undef private +#undef protected +#include "common_event_subscriber.h" +#include "common_event_support.h" +#include "event_log_wrapper.h" + +using namespace testing::ext; +using namespace OHOS::PowerMgr; +using namespace OHOS::EventFwk; +using namespace OHOS; +using namespace std; + +void PowerMgrPowerSavemodeTest::PowerModeTest1Callback::PowerModeCallback() +{ + POWER_HILOGD(MODULE_SERVICE, "PowerModeTest1Callback::PowerModeCallback."); +} + +void PowerMgrPowerSavemodeTest::SetUpTestCase(void) +{ +} + +void PowerMgrPowerSavemodeTest::TearDownTestCase(void) +{ +} + +void PowerMgrPowerSavemodeTest::SetUp(void) +{ +} + +void PowerMgrPowerSavemodeTest::TearDown(void) +{ +} + +/** + * @tc.name: PowerSavemode_001 + * @tc.desc: test SetDeviceMode in proxy + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_001, TestSize.Level2) +{ + sleep(SLEEP_WAIT_TIME_S); + + GTEST_LOG_(INFO) << "PowerSavemode_001: SetDeviceMode start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + uint32_t mode = 601; + uint32_t mode1 = 601; + powerMgrClient.SetDeviceMode(mode); + sleep(6); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_EQ(mode,mode1) << "PowerSavemode_001 fail to SetDeviceMode"; + GTEST_LOG_(INFO) << "PowerSavemode_001: SetDeviceMode end."; +} + +/** + * @tc.name: PowerSavemode_002 + * @tc.desc: test SetDeviceMode in proxy + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_002, TestSize.Level2) +{ + sleep(SLEEP_WAIT_TIME_S); + + GTEST_LOG_(INFO) << "PowerSavemode_002: SetDeviceMode start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + uint32_t mode = 602; + uint32_t mode1 = 602; + powerMgrClient.SetDeviceMode(mode); + sleep(3); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_EQ(mode,mode1) << "PowerSavemode_002 fail to SetDeviceMode"; + + GTEST_LOG_(INFO) << "PowerSavemode_002: SetDeviceMode end." << mode; +} + +/** + * @tc.name: PowerSavemode_003 + * @tc.desc: test SetDeviceMode in proxy + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_003, TestSize.Level2) +{ + sleep(SLEEP_WAIT_TIME_S); + + GTEST_LOG_(INFO) << "PowerSavemode_003: SetDeviceMode start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + uint32_t mode = 603; + uint32_t mode1 = 603; + powerMgrClient.SetDeviceMode(mode); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_EQ(mode,mode1) << "PowerSavemode_003 fail to SetDeviceMode"; + + GTEST_LOG_(INFO) << "PowerSavemode_003: SetDeviceMode end."; +} + +/** + * @tc.name: PowerSavemode_028 + * @tc.desc: test SetDeviceMode in proxy + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_028, TestSize.Level2) +{ + sleep(SLEEP_WAIT_TIME_S); + + GTEST_LOG_(INFO) << "PowerSavemode_028: SetDeviceMode start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + uint32_t mode = 1; + uint32_t mode1 = 1; + powerMgrClient.SetDeviceMode(mode); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_NE(mode,mode1) << "PowerSavemode_028 fail to SetDeviceMode abnormal"; + + GTEST_LOG_(INFO) << "PowerSavemode_028: SetDeviceMode end."; +} + +/** + * @tc.name: PowerSavemode_029 + * @tc.desc: test SetDeviceMode in proxy + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_029, TestSize.Level2) +{ + sleep(SLEEP_WAIT_TIME_S); + + GTEST_LOG_(INFO) << "PowerSavemode_029: SetDeviceMode start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + uint32_t mode = 603; + uint32_t mode1 = 603; + for(int i=0;i<100;i++) + { + powerMgrClient.SetDeviceMode(mode); + } + mode = powerMgrClient.GetDeviceMode(); + EXPECT_EQ(mode,mode1) << "PowerSavemode_029 fail to SetDeviceMode"; + + GTEST_LOG_(INFO) << "PowerSavemode_029: SetDeviceMode end."; +} + +/** + * @tc.name: PowerSavemode_004 + * @tc.desc: test GetDeviceMode in proxy + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_004, TestSize.Level2) +{ + sleep(SLEEP_WAIT_TIME_S); + + GTEST_LOG_(INFO) << "PowerSavemode_004: GetDeviceMode start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + uint32_t mode = 601; + uint32_t mode1 = 601; + powerMgrClient.SetDeviceMode(mode); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_EQ(mode,mode1) << "PowerSavemode_004 fail to GetDeviceMode"; + + GTEST_LOG_(INFO) << "PowerSavemode_004: GetDeviceMode end. mode == " << mode; +} + +/** + * @tc.name: PowerSavemode_005 + * @tc.desc: test GetDeviceMode in proxy + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_005, TestSize.Level2) +{ + sleep(SLEEP_WAIT_TIME_S); + + GTEST_LOG_(INFO) << "PowerSavemode_005: GetDeviceMode start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + uint32_t mode = 602; + uint32_t mode1 = 602; + powerMgrClient.SetDeviceMode(mode); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_EQ(mode,mode1) << "PowerSavemode_005 fail to GetDeviceMode"; + + GTEST_LOG_(INFO) << "PowerSavemode_005: GetDeviceMode end. mode == " << mode; +} + +/** + * @tc.name: PowerSavemode_006 + * @tc.desc: test GetDeviceMode in proxy + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_006, TestSize.Level2) +{ + sleep(SLEEP_WAIT_TIME_S); + + GTEST_LOG_(INFO) << "PowerSavemode_006: GetDeviceMode start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + uint32_t mode = 603; + uint32_t mode1 = 603; + powerMgrClient.SetDeviceMode(mode); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_EQ(mode,mode1) << "PowerSavemode_006 fail to GetDeviceMode"; + + GTEST_LOG_(INFO) << "PowerSavemode_006: GetDeviceMode end. mode == " << mode; +} + +/** + * @tc.name: PowerSavemode_030 + * @tc.desc: test GetDeviceMode in proxy + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_030, TestSize.Level2) +{ + sleep(SLEEP_WAIT_TIME_S); + + GTEST_LOG_(INFO) << "PowerSavemode_030: GetDeviceMode start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + uint32_t mode = 0; + uint32_t mode1 = 601; + mode = powerMgrClient.GetDeviceMode(); + EXPECT_NE(mode,mode1) << "PowerSavemode_030 fail to GetDeviceMode"; + + GTEST_LOG_(INFO) << "PowerSavemode_030: GetDeviceMode end. mode == " << mode; +} + +/** + * @tc.name: PowerSavemode_031 + * @tc.desc: test GetDeviceMode in proxy + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_031, TestSize.Level2) +{ + sleep(SLEEP_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerSavemode_031: GetDeviceMode start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + uint32_t mode = 601; + uint32_t mode1 = 601; + powerMgrClient.SetDeviceMode(mode); + for(int i=0;i<100;i++) + { + mode = powerMgrClient.GetDeviceMode(); + } + EXPECT_EQ(mode,mode1) << "PowerSavemode_031 fail to GetDeviceMode"; + + GTEST_LOG_(INFO) << "PowerSavemode_031: GetDeviceMode end. mode == " << mode; +} + +/** + * @tc.name: PowerSavemode_032 + * @tc.desc: test PowerModeCallback + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_032, TestSize.Level0) +{ + GTEST_LOG_(INFO) << "PowerSavemode_032: RegisterPowerModeCallback start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + const sptr cb1 = new PowerModeTest1Callback(); + powerMgrClient.RegisterPowerModeCallback(cb1); + sleep(SLEEP_WAIT_TIME_S); + uint32_t mode = 601; + uint32_t mode1 = 601; + powerMgrClient.SetDeviceMode(mode); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_EQ(mode,mode1) << "PowerSavemode_032 fail to PowerModeCallback"; + + POWER_HILOGD(MODULE_SERVICE, "PowerSavemode_032 1."); +} + +/** + * @tc.name: PowerSavemode_033 + * @tc.desc: test PowerModeCallback + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_033, TestSize.Level0) +{ + GTEST_LOG_(INFO) << "PowerSavemode_033: RegisterPowerModeCallback start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + POWER_HILOGD(MODULE_SERVICE, "PowerSavemode_033 Start."); + const sptr cb1 = new PowerModeTest1Callback(); + powerMgrClient.RegisterPowerModeCallback(cb1); + sleep(SLEEP_WAIT_TIME_S); + uint32_t mode = 1; + uint32_t mode1 = 1; + powerMgrClient.SetDeviceMode(mode); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_NE(mode,mode1) << "PowerSavemode_033 fail to PowerModeCallback"; + + POWER_HILOGD(MODULE_SERVICE, "PowerSavemode_033 1."); +} + +/** + * @tc.name: PowerSavemode_034 + * @tc.desc: test PowerModeCallback + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_034, TestSize.Level0) +{ + GTEST_LOG_(INFO) << "PowerSavemode_034: RegisterPowerModeCallback start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + const sptr cb1 = new PowerModeTest1Callback(); + powerMgrClient.RegisterPowerModeCallback(cb1); + sleep(SLEEP_WAIT_TIME_S); + uint32_t mode = 601; + uint32_t mode1 = 601; + powerMgrClient.SetDeviceMode(mode); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_EQ(mode,mode1) << "PowerSavemode_034 fail to PowerModeCallback"; + + POWER_HILOGD(MODULE_SERVICE, "PowerSavemode_034 1."); +} + +/** + * @tc.name: PowerSavemode_035 + * @tc.desc: test PowerModeCallback + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_035, TestSize.Level0) +{ + GTEST_LOG_(INFO) << "PowerSavemode_035: RegisterPowerModeCallback start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + const sptr cb1 = new PowerModeTest1Callback(); + for(int i=0;i<100;i++) + { + powerMgrClient.RegisterPowerModeCallback(cb1); + } + sleep(SLEEP_WAIT_TIME_S); + uint32_t mode = 601; + uint32_t mode1 = 601; + powerMgrClient.SetDeviceMode(mode); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_EQ(mode,mode1) << "PowerSavemode_035 fail to PowerModeCallback"; + + POWER_HILOGD(MODULE_SERVICE, "PowerSavemode_035 1."); +} + +/** + * @tc.name: PowerSavemode_036 + * @tc.desc: test PowerModeCallback + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_036, TestSize.Level0) +{ + GTEST_LOG_(INFO) << "PowerSavemode_036: UnRegisterPowerModeCallback start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + const sptr cb1 = new PowerModeTest1Callback(); + powerMgrClient.UnRegisterPowerModeCallback(cb1); + sleep(SLEEP_WAIT_TIME_S); + uint32_t mode = 601; + uint32_t mode1 = 601; + powerMgrClient.SetDeviceMode(mode); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_EQ(mode,mode1) << "PowerSavemode_036 fail to PowerModeCallback"; + + POWER_HILOGD(MODULE_SERVICE, "PowerSavemode_036 1."); +} + +/** + * @tc.name: PowerSavemode_037 + * @tc.desc: test PowerModeCallback + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_037, TestSize.Level0) +{ + GTEST_LOG_(INFO) << "PowerSavemode_037: UnRegisterPowerModeCallback start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + const sptr cb1 = new PowerModeTest1Callback(); + powerMgrClient.UnRegisterPowerModeCallback(cb1); + sleep(SLEEP_WAIT_TIME_S); + uint32_t mode = 1; + uint32_t mode1 = 1; + powerMgrClient.SetDeviceMode(mode); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_NE(mode,mode1) << "PowerSavemode_036 fail to PowerModeCallback"; + + POWER_HILOGD(MODULE_SERVICE, "PowerSavemode_037 1."); +} + +/** + * @tc.name: PowerSavemode_038 + * @tc.desc: test PowerModeCallback + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_038, TestSize.Level0) +{ + GTEST_LOG_(INFO) << "PowerSavemode_038: UnRegisterPowerModeCallback start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + const sptr cb1 = new PowerModeTest1Callback(); + powerMgrClient.UnRegisterPowerModeCallback(cb1); + sleep(SLEEP_WAIT_TIME_S); + uint32_t mode = 601; + uint32_t mode1 = 601; + powerMgrClient.SetDeviceMode(mode); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_EQ(mode,mode1) << "PowerSavemode_036 fail to PowerModeCallback"; + + POWER_HILOGD(MODULE_SERVICE, "PowerSavemode_038 1."); +} + +/** + * @tc.name: PowerSavemode_039 + * @tc.desc: test PowerModeCallback + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrPowerSavemodeTest, PowerSavemode_039, TestSize.Level0) +{ + GTEST_LOG_(INFO) << "PowerSavemode_039: UnRegisterPowerModeCallback start."; + + auto& powerMgrClient = PowerMgrClient::GetInstance(); + const sptr cb1 = new PowerModeTest1Callback(); + for(int i=0;i<100;i++) + { + powerMgrClient.UnRegisterPowerModeCallback(cb1); + } + sleep(SLEEP_WAIT_TIME_S); + uint32_t mode = 601; + uint32_t mode1 = 601; + powerMgrClient.SetDeviceMode(mode); + mode = powerMgrClient.GetDeviceMode(); + EXPECT_EQ(mode,mode1) << "PowerSavemode_036 fail to PowerModeCallback"; + + POWER_HILOGD(MODULE_SERVICE, "PowerSavemode_039 1."); +} + +class CommonEventServicesSystemTest : public CommonEventSubscriber { +public: + CommonEventServicesSystemTest(const CommonEventSubscribeInfo &subscriberInfo); + virtual ~CommonEventServicesSystemTest(){}; + virtual void OnReceiveEvent(const CommonEventData &data); +}; + +CommonEventServicesSystemTest::CommonEventServicesSystemTest(const CommonEventSubscribeInfo &subscriberInfo) + : CommonEventSubscriber(subscriberInfo) +{} + +uint32_t i = 0; + +void CommonEventServicesSystemTest::OnReceiveEvent(const CommonEventData &data) +{ + std::string action = data.GetWant().GetAction(); + if (action == CommonEventSupport::COMMON_EVENT_DEVICE_IDLE_MODE_CHANGED) { + POWER_HILOGD(MODULE_SERVICE, "CommonEventServicesSystemTest::OnReceiveEvent."); + i = 2; + } + uint32_t j = 2; + EXPECT_EQ(i,j) << "PowerSavemode_022 fail to PowerModeCallback";; + POWER_HILOGD(MODULE_SERVICE, "CommonEventServicesSystemTest::OnReceiveEvent other."); +} + +/** + * @tc.name: PowerSavemode_022 + * @tc.desc: ReceiveEvent + * @tc.type: FUNC + */ +HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_022, TestSize.Level0) +{ + GTEST_LOG_(INFO) << "PowerSavemode_022: UnRegisterPowerModeCallback start."; + + bool result = false; + MatchingSkills matchingSkills; + matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_DEVICE_IDLE_MODE_CHANGED); + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + auto subscriberPtr = std::make_shared(subscribeInfo); + result = CommonEventManager::SubscribeCommonEvent(subscriberPtr); + EXPECT_TRUE(result); + GTEST_LOG_(INFO) << "PowerSavemode_022: ShutDownDevice start."; + auto& powerMgrClient = PowerMgrClient::GetInstance(); + uint32_t mode = 602; + powerMgrClient.SetDeviceMode(mode); + sleep(SLEEP_WAIT_TIME_S); + CommonEventManager::UnSubscribeCommonEvent(subscriberPtr); + + POWER_HILOGD(MODULE_SERVICE, "PowerSavemode_022 1."); +} + +/** + * @tc.name: PowerSavemode_023 + * @tc.desc: ReceiveEvent + * @tc.type: FUNC + */ +HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_023, TestSize.Level0) +{ + GTEST_LOG_(INFO) << "PowerSavemode_023: UnRegisterPowerModeCallback start."; + + bool result = false; + MatchingSkills matchingSkills; + matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_DEVICE_IDLE_MODE_CHANGED); + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + auto subscriberPtr = std::make_shared(subscribeInfo); + result = CommonEventManager::SubscribeCommonEvent(subscriberPtr); + EXPECT_TRUE(result); + GTEST_LOG_(INFO) << "PowerSavemode_023: ShutDownDevice start."; + auto& powerMgrClient = PowerMgrClient::GetInstance(); + uint32_t mode = 603; + powerMgrClient.SetDeviceMode(mode); + sleep(SLEEP_WAIT_TIME_S); + CommonEventManager::UnSubscribeCommonEvent(subscriberPtr); + + POWER_HILOGD(MODULE_SERVICE, "PowerSavemode_023 1."); +} + +/** + * @tc.name: PowerSavemode_024 + * @tc.desc: ReceiveEvent + * @tc.type: FUNC + */ +HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_024, TestSize.Level0) +{ + GTEST_LOG_(INFO) << "PowerSavemode_024: UnRegisterPowerModeCallback start."; + + bool result = false; + MatchingSkills matchingSkills; + matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_DEVICE_IDLE_MODE_CHANGED); + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + auto subscriberPtr = std::make_shared(subscribeInfo); + result = CommonEventManager::SubscribeCommonEvent(subscriberPtr); + EXPECT_TRUE(result); + GTEST_LOG_(INFO) << "PowerSavemode_024: ShutDownDevice start."; + auto& powerMgrClient = PowerMgrClient::GetInstance(); + uint32_t mode = 602; + powerMgrClient.SetDeviceMode(mode); + sleep(SLEEP_WAIT_TIME_S); + CommonEventManager::UnSubscribeCommonEvent(subscriberPtr); + + POWER_HILOGD(MODULE_SERVICE, "PowerSavemode_024 1."); +} + +/** + * @tc.name: PowerSavemode_025 + * @tc.desc: ReceiveEvent + * @tc.type: FUNC + */ +HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_025, TestSize.Level0) +{ + GTEST_LOG_(INFO) << "PowerSavemode_025: UnRegisterPowerModeCallback start."; + + bool result = false; + MatchingSkills matchingSkills; + matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_DEVICE_IDLE_MODE_CHANGED); + CommonEventSubscribeInfo subscribeInfo(matchingSkills); + auto subscriberPtr = std::make_shared(subscribeInfo); + result = CommonEventManager::SubscribeCommonEvent(subscriberPtr); + EXPECT_TRUE(result); + GTEST_LOG_(INFO) << "PowerSavemode_025: ShutDownDevice start."; + auto& powerMgrClient = PowerMgrClient::GetInstance(); + uint32_t mode = 603; + powerMgrClient.SetDeviceMode(mode); + sleep(SLEEP_WAIT_TIME_S); + CommonEventManager::UnSubscribeCommonEvent(subscriberPtr); + + POWER_HILOGD(MODULE_SERVICE, "PowerSavemode_025 1."); +} \ No newline at end of file diff --git a/test/systemtest/src/power_mgr_st_mock_test.cpp b/test/systemtest/src/power_mgr_st_mock_test.cpp index 0beea3a1..b8d5888a 100644 --- a/test/systemtest/src/power_mgr_st_mock_test.cpp +++ b/test/systemtest/src/power_mgr_st_mock_test.cpp @@ -28,6 +28,7 @@ static MockLockAction* lockAction; static void ResetMockAction() { + POWER_HILOGD(MODULE_SERVICE, "ResetMockAction:Start."); stateAction = new MockStateAction(); powerAction = new MockPowerAction(); lockAction = new MockLockAction(); @@ -59,9 +60,10 @@ void PowerMgrMockTest::TearDown(void) { } + /** * @tc.name: PowerMgrMock001 - * @tc.desc: test SuspendDevice by mock + * @tc.desc: test RebootDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock001, TestSize.Level2) @@ -75,21 +77,18 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock001, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock001: Failed to get PowerMgrService"; } - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, - Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, false)); - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, false); + EXPECT_CALL(*powerAction, Reboot(std::string("test"))).Times(1); + pms->RebootDevice(std::string("test")); + sleep(ASYNC_WAIT_TIME_S); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock001:End ."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock001:End."); GTEST_LOG_(INFO) << "PowerMgrMock001: end."; } /** * @tc.name: PowerMgrMock002 - * @tc.desc: test SuspendDevice by mock + * @tc.desc: test ShutDownDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock002, TestSize.Level2) @@ -103,18 +102,16 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock002, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock002: Failed to get PowerMgrService"; } - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, - Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT, false)); - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT, false); + EXPECT_CALL(*powerAction, Shutdown(std::string("test"))).Times(1); + pms->ShutDownDevice(std::string("test")); + sleep(ASYNC_WAIT_TIME_S); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock002:End"); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock002:End."); GTEST_LOG_(INFO) << "PowerMgrMock002: end."; } + /** * @tc.name: PowerMgrMock003 * @tc.desc: test SuspendDevice by mock @@ -124,22 +121,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock003, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock003: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:Start."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { GTEST_LOG_(INFO) << "PowerMgrMock003: Failed to get PowerMgrService"; } + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:Start mock."); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH, false)); - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH, false); + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:Start suspend."); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:End."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock003:end."); GTEST_LOG_(INFO) << "PowerMgrMock003: end."; } @@ -163,11 +162,11 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock004, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON, false)); - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON, false); + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN, false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock004:End."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock004:End ."); GTEST_LOG_(INFO) << "PowerMgrMock004: end."; } @@ -191,11 +190,11 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock005, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI , false)); - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI , false); + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT, false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT, false); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock005:End."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock005:End"); GTEST_LOG_(INFO) << "PowerMgrMock005: end."; } @@ -219,8 +218,8 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock006, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON , false)); - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON , false); + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH, false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH, false); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock006:End."); @@ -247,8 +246,8 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock007, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY , false)); - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY , false); + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON, false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON, false); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock007:End."); @@ -275,25 +274,23 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock008, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND , false)); - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND , false); + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI , false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI , false); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock008:End."); GTEST_LOG_(INFO) << "PowerMgrMock008: end."; } - - /** * @tc.name: PowerMgrMock009 - * @tc.desc: test WakeupDevice by mock + * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock009, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock009: start."; + GTEST_LOG_(INFO) << "PowerMgrMock009: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock009:Start."); sptr pms = DelayedSpSingleton::GetInstance(); @@ -301,14 +298,12 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock009, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock009: Failed to get PowerMgrService"; } - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , - std::string("test"), _)).Times(1); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON , false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON , false); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock009:End."); @@ -317,13 +312,13 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock009, TestSize.Level2) /** * @tc.name: PowerMgrMock010 - * @tc.desc: test WakeupDevice by mock + * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock010, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock010: start."; + GTEST_LOG_(INFO) << "PowerMgrMock010: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock010:Start."); sptr pms = DelayedSpSingleton::GetInstance(); @@ -331,14 +326,12 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock010, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock010: Failed to get PowerMgrService"; } - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , - std::string("test"), _)).Times(1); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY , false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY , false); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock010:End."); @@ -347,13 +340,13 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock010, TestSize.Level2) /** * @tc.name: PowerMgrMock011 - * @tc.desc: test WakeupDevice by mock + * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock011, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock011: start."; + GTEST_LOG_(INFO) << "PowerMgrMock011: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock011:Start."); sptr pms = DelayedSpSingleton::GetInstance(); @@ -361,20 +354,20 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock011, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock011: Failed to get PowerMgrService"; } - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN , - std::string("test"), _)).Times(1); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN , std::string("test")); + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND , false)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND , false); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock011:End."); GTEST_LOG_(INFO) << "PowerMgrMock011: end."; } + + /** * @tc.name: PowerMgrMock012 * @tc.desc: test WakeupDevice by mock @@ -396,9 +389,9 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock012, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_GESTURE , + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test"), _)).Times(1); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_GESTURE , std::string("test")); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock012:End."); @@ -426,9 +419,9 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock013, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH , + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test"), _)).Times(1); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH , std::string("test")); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock013:End."); @@ -456,9 +449,9 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock014, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY , + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION , std::string("test"), _)).Times(1); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY , std::string("test")); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_APPLICATION , std::string("test")); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock014:End."); @@ -486,9 +479,9 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock015, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION , + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN , std::string("test"), _)).Times(1); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION , std::string("test")); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN , std::string("test")); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock015:End."); @@ -516,9 +509,9 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock016, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_HDMI , + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_GESTURE , std::string("test"), _)).Times(1); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_HDMI , std::string("test")); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_GESTURE , std::string("test")); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock016:End."); @@ -546,26 +539,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock017, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_LID , + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH , std::string("test"), _)).Times(1); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID , std::string("test")); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH , std::string("test")); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock017:End."); GTEST_LOG_(INFO) << "PowerMgrMock017: end."; } - - /** * @tc.name: PowerMgrMock018 - * @tc.desc: test WakeupDevice and auto suspend and sleep by mock + * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock018, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock018: start."; + GTEST_LOG_(INFO) << "PowerMgrMock018: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock018:Start."); sptr pms = DelayedSpSingleton::GetInstance(); @@ -573,20 +564,14 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock018, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock018: Failed to get PowerMgrService"; } - EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - ON_CALL(*stateAction, GetDisplayState()) - .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID , std::string("test")); - sleep(SCREEN_DIM_WAIT_TIME_S + 1); - ON_CALL(*stateAction, GetDisplayState()) - .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - sleep(SCREEN_DIM_WAIT_TIME_S + 1); - ON_CALL(*stateAction, GetDisplayState()) - .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); - sleep(SLEEP_WAIT_TIME_S + 1); - sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY , std::string("test")); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock018:End."); @@ -595,13 +580,13 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock018, TestSize.Level2) /** * @tc.name: PowerMgrMock019 - * @tc.desc: test RunningLock release by mock + * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock019, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock019: start."; + GTEST_LOG_(INFO) << "PowerMgrMock019: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock019:Start."); sptr pms = DelayedSpSingleton::GetInstance(); @@ -609,14 +594,14 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock019, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock019: Failed to get PowerMgrService"; } - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); - pms->CreateRunningLock(token, info); - pms->ReleaseRunningLock(token); - - EXPECT_CALL(*lockAction, Lock(_, _)).Times(0); - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), false); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION , std::string("test")); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock019:End."); @@ -625,13 +610,13 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock019, TestSize.Level2) /** * @tc.name: PowerMgrMock020 - * @tc.desc: test RefreshActivity by mock + * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock020, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock020: start."; + GTEST_LOG_(INFO) << "PowerMgrMock020: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock020:Start."); sptr pms = DelayedSpSingleton::GetInstance(); @@ -639,17 +624,15 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock020, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock020: Failed to get PowerMgrService"; } - EXPECT_CALL(*stateAction, GetDisplayState()) - .Times(::testing::AtLeast(1)) - .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_OTHER, _)).Times(1); - pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_OTHER, true); + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_HDMI , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_HDMI , std::string("test")); - sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock020:End."); GTEST_LOG_(INFO) << "PowerMgrMock020: end."; @@ -657,13 +640,13 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock020, TestSize.Level2) /** * @tc.name: PowerMgrMock021 - * @tc.desc: test RefreshActivity by mock + * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock021, TestSize.Level2) { sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock021: start."; + GTEST_LOG_(INFO) << "PowerMgrMock021: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock021:Start."); sptr pms = DelayedSpSingleton::GetInstance(); @@ -671,17 +654,15 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock021, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock021: Failed to get PowerMgrService"; } - EXPECT_CALL(*stateAction, GetDisplayState()) - .Times(::testing::AtLeast(1)) - .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_BUTTON, _)).Times(1); - pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_BUTTON, true); + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_LID , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID , std::string("test")); - sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock021:End."); GTEST_LOG_(INFO) << "PowerMgrMock021: end."; @@ -689,7 +670,7 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock021, TestSize.Level2) /** * @tc.name: PowerMgrMock022 - * @tc.desc: test RefreshActivity by mock + * @tc.desc: test SuspendDevice and auto sleep by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock022, TestSize.Level2) @@ -703,17 +684,20 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock022, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock022: Failed to get PowerMgrService"; } - EXPECT_CALL(*stateAction, GetDisplayState()) + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) .Times(::testing::AtLeast(1)) - .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) - .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY, _)).Times(1); - pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY, true); + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sleep(SLEEP_WAIT_TIME_S + 1); - sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock022:End."); GTEST_LOG_(INFO) << "PowerMgrMock022: end."; @@ -721,7 +705,7 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock022, TestSize.Level2) /** * @tc.name: PowerMgrMock023 - * @tc.desc: test RefreshActivity by mock + * @tc.desc: test WakeupDevice and auto suspend and sleep by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock023, TestSize.Level2) @@ -735,17 +719,20 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock023, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock023: Failed to get PowerMgrService"; } - EXPECT_CALL(*stateAction, GetDisplayState()) - .Times(::testing::AtLeast(1)) - .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, - RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ATTENTION, _)).Times(1); - pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ATTENTION, true); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID , std::string("test")); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + sleep(SLEEP_WAIT_TIME_S + 1); - sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock023:End."); GTEST_LOG_(INFO) << "PowerMgrMock023: end."; @@ -774,8 +761,8 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock024, TestSize.Level2) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE, _)).Times(1); - pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE, true); + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_TOUCH, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_TOUCH, true); sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); @@ -785,12 +772,11 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock024, TestSize.Level2) /** * @tc.name: PowerMgrMock025 - * @tc.desc: test RefreshActivity by mock + * @tc.desc: test IsScreenOn by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock025, TestSize.Level2) { - UserActivityType abnormaltype={}; sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock025: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock025:Start."); @@ -799,17 +785,11 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock025, TestSize.Level2) if (pms == nullptr) { GTEST_LOG_(INFO) << "PowerMgrMock025: Failed to get PowerMgrService"; } - - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_CALL(*stateAction, GetDisplayState()) .Times(::testing::AtLeast(1)) - .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); - EXPECT_CALL(*stateAction, - RefreshActivity(0, _, _)).Times(1); - pms->RefreshActivity(0, abnormaltype, true); - - sleep(SLEEP_WAIT_TIME_S + 1); - EXPECT_EQ(pms->IsScreenOn(), false); + .WillOnce(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_EQ(pms->IsScreenOn(), true); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock025:End."); @@ -818,12 +798,11 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock025, TestSize.Level2) /** * @tc.name: PowerMgrMock026 - * @tc.desc: test RefreshActivity by mock + * @tc.desc: test IsScreenOn by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock026, TestSize.Level2) { - UserActivityType abnormaltype=UserActivityType(6); sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock026: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock026:Start."); @@ -832,33 +811,26 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock026, TestSize.Level2) if (pms == nullptr) { GTEST_LOG_(INFO) << "PowerMgrMock026: Failed to get PowerMgrService"; } - - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_CALL(*stateAction, GetDisplayState()) .Times(::testing::AtLeast(1)) .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); - EXPECT_CALL(*stateAction, - RefreshActivity(0, _, _)).Times(0); - pms->RefreshActivity(0, abnormaltype, true); - - sleep(SLEEP_WAIT_TIME_S + 1); - EXPECT_EQ(pms->IsScreenOn(), false); + EXPECT_EQ(pms->IsScreenOn(), true); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock026:End."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock026:End"); GTEST_LOG_(INFO) << "PowerMgrMock026: end."; } /** * @tc.name: PowerMgrMock027 - * @tc.desc: test WakeupDevice by mock + * @tc.desc: test IsScreenOn by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock027, TestSize.Level2) { - WakeupDeviceType abnormaltype=WakeupDeviceType(10); sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock027: start."; + GTEST_LOG_(INFO) << "PowerMgrMock027: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock027:Start."); sptr pms = DelayedSpSingleton::GetInstance(); @@ -866,13 +838,9 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock027, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock027: Failed to get PowerMgrService"; } - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) - .Times(0); - EXPECT_CALL(*stateAction, - Wakeup(0, _ , - std::string("test"), _)).Times(0); - pms->WakeupDevice(0, abnormaltype , std::string("test")); + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_OFF)); EXPECT_EQ(pms->IsScreenOn(), false); ResetMockAction(); @@ -882,14 +850,13 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock027, TestSize.Level2) /** * @tc.name: PowerMgrMock028 - * @tc.desc: test WakeupDevice by mock + * @tc.desc: test IsScreenOn by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock028, TestSize.Level2) { - WakeupDeviceType abnormaltype=WakeupDeviceType(999); sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock028: start."; + GTEST_LOG_(INFO) << "PowerMgrMock028: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock028:Start."); sptr pms = DelayedSpSingleton::GetInstance(); @@ -897,25 +864,19 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock028, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock028: Failed to get PowerMgrService"; } - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) - .Times(0); - EXPECT_CALL(*stateAction, - Wakeup(0, _ , - std::string("test"), _)).Times(0); - pms->WakeupDevice(0, abnormaltype , std::string("test")); - EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_SUSPEND)); + EXPECT_EQ(pms->IsScreenOn(), false); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock028:End."); GTEST_LOG_(INFO) << "PowerMgrMock028: end."; } - - /** * @tc.name: PowerMgrMock029 - * @tc.desc: test WakeupDevice and auto suspend by mock + * @tc.desc: test ForceSuspendDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock029, TestSize.Level2) @@ -929,16 +890,10 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock029, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock029: Failed to get PowerMgrService"; } - // EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - // .Times(::testing::AtLeast(1)) - // .WillOnce(::testing::Return(ActionResult::SUCCESS)); - ON_CALL(*stateAction, GetDisplayState()) - .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); - sleep(SCREEN_DIM_WAIT_TIME_S + 1); - ON_CALL(*stateAction, GetDisplayState()) - .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); - sleep(SCREEN_OFF_WAIT_TIME_S + 1); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_EQ(pms->ForceSuspendDevice(0), true); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock029:End."); @@ -947,12 +902,11 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock029, TestSize.Level2) /** * @tc.name: PowerMgrMock030 - * @tc.desc: test WakeupDevice and auto suspend by mock + * @tc.desc: test Screen on RunningLock by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock030, TestSize.Level2) { - WakeupDeviceType abnormaltype = WakeupDeviceType(10); sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock030: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock030:Start."); @@ -962,30 +916,30 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock030, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock030: Failed to get PowerMgrService"; } - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) - .Times(::testing::AtLeast(1)) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - ON_CALL(*stateAction, GetDisplayState()) - .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - //EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)).Times(0) - sleep(SCREEN_DIM_WAIT_TIME_S/2); - pms->WakeupDevice(0, abnormaltype , std::string("test")); - sleep(SCREEN_DIM_WAIT_TIME_S/2 + 1); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sleep(SCREEN_DIM_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); - GTEST_LOG_(INFO) << "PowerMgrMock030: end."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock030:End."); + GTEST_LOG_(INFO) << "PowerMgrMock030: end."; } /** * @tc.name: PowerMgrMock031 - * @tc.desc: test WakeupDevice and auto suspend by mock + * @tc.desc: test background RunningLock by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock031, TestSize.Level2) { - WakeupDeviceType abnormaltype = WakeupDeviceType(999); sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock031: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock031:Start."); @@ -995,16 +949,21 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock031, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock031: Failed to get PowerMgrService"; } - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) - .Times(::testing::AtLeast(1)) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - ON_CALL(*stateAction, GetDisplayState()) - .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - //EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)).Times(0) - sleep(SCREEN_DIM_WAIT_TIME_S/2); - pms->WakeupDevice(0, abnormaltype , std::string("test")); - sleep(SCREEN_DIM_WAIT_TIME_S/2 + 1); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sleep(SLEEP_WAIT_TIME_S + 1); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock031:End."); @@ -1013,12 +972,11 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock031, TestSize.Level2) /** * @tc.name: PowerMgrMock032 - * @tc.desc: test RefreshActivity by mock + * @tc.desc: test proximity RunningLock by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock032, TestSize.Level2) { - UserActivityType abnormaltype = UserActivityType(6); sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock032: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock032:Start."); @@ -1028,15 +986,22 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock032, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock032: Failed to get PowerMgrService"; } - EXPECT_CALL(*stateAction, GetDisplayState()) - .Times(::testing::AtLeast(1)) - .WillOnce(::testing::Return(DisplayState::DISPLAY_OFF)); - EXPECT_CALL(*stateAction, - RefreshActivity(0, _, true)).Times(0); - sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2); - pms->RefreshActivity(0, abnormaltype, true); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sleep(SCREEN_DIM_WAIT_TIME_S + 1); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); - sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2 + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock032:End."); GTEST_LOG_(INFO) << "PowerMgrMock032: end."; @@ -1044,12 +1009,11 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock032, TestSize.Level2) /** * @tc.name: PowerMgrMock033 - * @tc.desc: test RefreshActivity by mock + * @tc.desc: test RunningLock release by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock033, TestSize.Level2) { - UserActivityType abnormaltype = {}; sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock033: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock033:Start."); @@ -1059,15 +1023,15 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock033, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock033: Failed to get PowerMgrService"; } - EXPECT_CALL(*stateAction, GetDisplayState()) - .Times(::testing::AtLeast(1)) - .WillOnce(::testing::Return(DisplayState::DISPLAY_OFF)); - EXPECT_CALL(*stateAction, - RefreshActivity(0, _, true)).Times(0); - sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2); - pms->RefreshActivity(0, abnormaltype, true); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + pms->ReleaseRunningLock(token); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(0); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), false); - sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2 + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock033:End."); GTEST_LOG_(INFO) << "PowerMgrMock033: end."; @@ -1075,7 +1039,7 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock033, TestSize.Level2) /** * @tc.name: PowerMgrMock034 - * @tc.desc: test SuspendDevice by mock + * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock034, TestSize.Level2) @@ -1089,33 +1053,29 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock034, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock034: Failed to get PowerMgrService"; } - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + EXPECT_CALL(*stateAction, GetDisplayState()) .Times(::testing::AtLeast(1)) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, - Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, _)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); - EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); - sleep(SLEEP_WAIT_TIME_S+1); - EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + EXPECT_CALL(*stateAction, + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_OTHER, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_OTHER, true); + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock034:End"); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock034:End."); GTEST_LOG_(INFO) << "PowerMgrMock034: end."; } /** * @tc.name: PowerMgrMock035 - * @tc.desc: test SuspendDevice by mock + * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock035, TestSize.Level2) { - SuspendDeviceType abnormaltype = SuspendDeviceType(10); sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock035: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock035:Start."); @@ -1125,14 +1085,17 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock035, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock035: Failed to get PowerMgrService"; } - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Suspend(0, _, false)).Times(0); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); - //EXPECT_CALL(*stateAction,Suspend(0, _ , false)).Times(0); - pms->SuspendDevice(0, abnormaltype, false); - EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_BUTTON, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_BUTTON, true); + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock035:End."); GTEST_LOG_(INFO) << "PowerMgrMock035: end."; @@ -1140,12 +1103,11 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock035, TestSize.Level2) /** * @tc.name: PowerMgrMock036 - * @tc.desc: test SuspendDevice by mock + * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock036, TestSize.Level2) { - SuspendDeviceType abnormaltype = SuspendDeviceType(999); sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock036: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock036:Start."); @@ -1155,13 +1117,17 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock036, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock036: Failed to get PowerMgrService"; } - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Suspend(0, _, false)).Times(0); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); - pms->SuspendDevice(0, abnormaltype, false); - EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY, true); + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock036:End."); GTEST_LOG_(INFO) << "PowerMgrMock036: end."; @@ -1169,7 +1135,7 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock036, TestSize.Level2) /** * @tc.name: PowerMgrMock037 - * @tc.desc: test SuspendDevice by mock + * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock037, TestSize.Level2) @@ -1183,20 +1149,17 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock037, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock037: Failed to get PowerMgrService"; } - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); - EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); - sleep(SLEEP_WAIT_TIME_S+1); - EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ATTENTION, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_ATTENTION, true); + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock037:End."); GTEST_LOG_(INFO) << "PowerMgrMock037: end."; @@ -1204,12 +1167,11 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock037, TestSize.Level2) /** * @tc.name: PowerMgrMock038 - * @tc.desc: test SuspendDevice by mock + * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock038, TestSize.Level2) { - SuspendDeviceType abnormaltype = SuspendDeviceType(10); sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock038: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock038:Start."); @@ -1219,12 +1181,17 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock038, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock038: Failed to get PowerMgrService"; } - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Suspend(0, _, false)).Times(0); - pms->SuspendDevice(0, abnormaltype, false); - EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE, _)).Times(1); + pms->RefreshActivity(0, UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE, true); + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock038:End."); GTEST_LOG_(INFO) << "PowerMgrMock038: end."; @@ -1232,12 +1199,12 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock038, TestSize.Level2) /** * @tc.name: PowerMgrMock039 - * @tc.desc: test SuspendDevice by mock + * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock039, TestSize.Level2) { - SuspendDeviceType abnormaltype = {}; + UserActivityType abnormaltype={}; sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock039: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock039:Start."); @@ -1246,27 +1213,31 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock039, TestSize.Level2) if (pms == nullptr) { GTEST_LOG_(INFO) << "PowerMgrMock039: Failed to get PowerMgrService"; } - - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_DIM)); EXPECT_CALL(*stateAction, - Suspend(0, _, false)); - pms->SuspendDevice(0, abnormaltype, false); - EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + RefreshActivity(0, _, _)).Times(1); + pms->RefreshActivity(0, abnormaltype, true); + + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_EQ(pms->IsScreenOn(), false); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock039:End."); GTEST_LOG_(INFO) << "PowerMgrMock039: end."; } - - /** * @tc.name: PowerMgrMock040 - * @tc.desc: test ForceSuspendDevice by mock during Inactive + * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock040, TestSize.Level2) { + UserActivityType abnormaltype=UserActivityType(6); sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock040: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock040:Start."); @@ -1275,17 +1246,20 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock040, TestSize.Level2) if (pms == nullptr) { GTEST_LOG_(INFO) << "PowerMgrMock040: Failed to get PowerMgrService"; } - - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, _)) + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, _, _)).Times(0); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) .Times(::testing::AtLeast(1)) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->ForceSuspendDevice(0); - sleep(SLEEP_WAIT_TIME_S+1); - EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + pms->RefreshActivity(0, abnormaltype, true); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock040:End."); @@ -1294,13 +1268,14 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock040, TestSize.Level2) /** * @tc.name: PowerMgrMock041 - * @tc.desc: test SCREEN_ON RunningLock by mock + * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock041, TestSize.Level2) { + WakeupDeviceType abnormaltype=WakeupDeviceType(10); sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock041: start."; + GTEST_LOG_(INFO) << "PowerMgrMock041: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock041:Start."); sptr pms = DelayedSpSingleton::GetInstance(); @@ -1308,22 +1283,15 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock041, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock041: Failed to get PowerMgrService"; } - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); - pms->CreateRunningLock(token, info); - - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); - sleep(SCREEN_DIM_WAIT_TIME_S + 1); - ON_CALL(*stateAction, GetDisplayState()) - .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); - EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(0); + EXPECT_CALL(*stateAction, + Wakeup(0, _ , + std::string("test"), _)).Times(0); + pms->WakeupDevice(0, abnormaltype , std::string("test")); + EXPECT_EQ(pms->IsScreenOn(), false); - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock041:End."); GTEST_LOG_(INFO) << "PowerMgrMock041: end."; @@ -1331,13 +1299,14 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock041, TestSize.Level2) /** * @tc.name: PowerMgrMock042 - * @tc.desc: test SCREEN_ON RunningLock by mock + * @tc.desc: test WakeupDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock042, TestSize.Level2) { + WakeupDeviceType abnormaltype=WakeupDeviceType(999); sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock042: start."; + GTEST_LOG_(INFO) << "PowerMgrMock042: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock042:Start."); sptr pms = DelayedSpSingleton::GetInstance(); @@ -1346,30 +1315,24 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock042, TestSize.Level2) } pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); - //EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); - pms->CreateRunningLock(token, info); - - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - //sleep(SCREEN_DIM_WAIT_TIME_S + 1); - EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + .Times(0); + EXPECT_CALL(*stateAction, + Wakeup(0, _ , + std::string("test"), _)).Times(0); + pms->WakeupDevice(0, abnormaltype , std::string("test")); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock042:End."); GTEST_LOG_(INFO) << "PowerMgrMock042: end."; } + + /** * @tc.name: PowerMgrMock043 - * @tc.desc: test Screen RunningLock by mock + * @tc.desc: test WakeupDevice and auto suspend by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock043, TestSize.Level2) @@ -1383,24 +1346,16 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock043, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock043: Failed to get PowerMgrService"; } - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); - pms->CreateRunningLock(token, info); - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); - sleep(SCREEN_DIM_WAIT_TIME_S + 1); - - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); - - sleep(SCREEN_OFF_WAIT_TIME_S+1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) + .Times(::testing::AtLeast(1)) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); - + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock043:End."); @@ -1409,11 +1364,12 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock043, TestSize.Level2) /** * @tc.name: PowerMgrMock044 - * @tc.desc: test Screen RunningLock by mock + * @tc.desc: test WakeupDevice and auto suspend by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock044, TestSize.Level2) { + WakeupDeviceType abnormaltype = WakeupDeviceType(10); sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock044: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock044:Start."); @@ -1423,32 +1379,29 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock044, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock044: Failed to get PowerMgrService"; } - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); - pms->CreateRunningLock(token, info); - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); - sleep(SLEEP_WAIT_TIME_S*10); - - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); - EXPECT_EQ(PowerState::AWAKE,pms->GetState()); - + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3)/2); + pms->WakeupDevice(0, abnormaltype , std::string("test")); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3)/2 + 1); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock044:End."); GTEST_LOG_(INFO) << "PowerMgrMock044: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock044:End."); } /** * @tc.name: PowerMgrMock045 - * @tc.desc: test Screen on RunningLock by mock + * @tc.desc: test WakeupDevice and auto suspend by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock045, TestSize.Level2) { - int i; + WakeupDeviceType abnormaltype = WakeupDeviceType(999); sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock045: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock045:Start."); @@ -1458,21 +1411,19 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock045, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock045: Failed to get PowerMgrService"; } - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); - pms->CreateRunningLock(token, info); - for(i=0;i<10;i++){ - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); - sleep(SCREEN_OFF_WAIT_TIME_S + 1); - - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); - EXPECT_EQ(PowerState::AWAKE,pms->GetState()); - } - EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) /2); + pms->WakeupDevice(0, abnormaltype , std::string("test")); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3)/2 + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock045:End."); @@ -1481,11 +1432,12 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock045, TestSize.Level2) /** * @tc.name: PowerMgrMock046 - * @tc.desc: test Screen RunningLock by mock + * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock046, TestSize.Level2) { + UserActivityType abnormaltype = UserActivityType(6); sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock046: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock046:Start."); @@ -1495,26 +1447,15 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock046, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock046: Failed to get PowerMgrService"; } - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); - pms->CreateRunningLock(token, info); - - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - - EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(1); - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); - sleep(SLEEP_WAIT_TIME_S + 1); - - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); - sleep(SLEEP_WAIT_TIME_S + 1); - EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_OFF)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, _, true)).Times(0); + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2); + pms->RefreshActivity(0, abnormaltype, true); + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2 + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock046:End."); GTEST_LOG_(INFO) << "PowerMgrMock046: end."; @@ -1522,11 +1463,12 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock046, TestSize.Level2) /** * @tc.name: PowerMgrMock047 - * @tc.desc: test Screen RunningLock by mock + * @tc.desc: test RefreshActivity by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock047, TestSize.Level2) { + UserActivityType abnormaltype = {}; sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock047: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock047:Start."); @@ -1536,28 +1478,15 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock047, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock047: Failed to get PowerMgrService"; } - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); - pms->CreateRunningLock(token, info); - - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - - EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_EQ(pms->ForceSuspendDevice(0), true); - //pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); - sleep(SLEEP_WAIT_TIME_S + 1); - - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); - EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + EXPECT_CALL(*stateAction, GetDisplayState()) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(DisplayState::DISPLAY_OFF)); + EXPECT_CALL(*stateAction, + RefreshActivity(0, _, true)).Times(0); + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2); + pms->RefreshActivity(0, abnormaltype, true); + sleep(SCREEN_OFF_WAIT_TIME_S + SLEEP_WAIT_TIME_S/2 + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock047:End."); GTEST_LOG_(INFO) << "PowerMgrMock047: end."; @@ -1565,7 +1494,7 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock047, TestSize.Level2) /** * @tc.name: PowerMgrMock048 - * @tc.desc: test Screen RunningLock by mock + * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock048, TestSize.Level2) @@ -1579,35 +1508,33 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock048, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock048: Failed to get PowerMgrService"; } - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); - pms->CreateRunningLock(token, info); - - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - - EXPECT_CALL(*stateAction, Suspend(_, _, _)).Times(0); - + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, - Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , - std::string("test"), _)).Times(1); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); - - pms->UnLock(token); - EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + sleep(SLEEP_WAIT_TIME_S+1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock048:End."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock048:End"); GTEST_LOG_(INFO) << "PowerMgrMock048: end."; } /** * @tc.name: PowerMgrMock049 - * @tc.desc: test background RunningLock by mock + * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock049, TestSize.Level2) { + SuspendDeviceType abnormaltype = SuspendDeviceType(10); sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock049: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock049:Start."); @@ -1617,21 +1544,12 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock049, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock049: Failed to get PowerMgrService"; } - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); - pms->CreateRunningLock(token, info); - - EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_EQ(pms->ForceSuspendDevice(0), true); - EXPECT_EQ(PowerState::SLEEP,pms->GetState()); - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - - EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); - EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); - pms->UnLock(token); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); + EXPECT_CALL(*stateAction, + Suspend(0, _, false)).Times(0); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + pms->SuspendDevice(0, abnormaltype, false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock049:End."); @@ -1640,11 +1558,12 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock049, TestSize.Level2) /** * @tc.name: PowerMgrMock050 - * @tc.desc: test background RunningLock by mock + * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock050, TestSize.Level2) { + SuspendDeviceType abnormaltype = SuspendDeviceType(999); sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock050: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock050:Start."); @@ -1654,21 +1573,12 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock050, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock050: Failed to get PowerMgrService"; } - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); - pms->CreateRunningLock(token, info); - - EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - - EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); - - sleep(SLEEP_WAIT_TIME_S + 1); - EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(1); - EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON , std::string("test")); + EXPECT_CALL(*stateAction, + Suspend(0, _, false)).Times(0); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + pms->SuspendDevice(0, abnormaltype, false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock050:End."); @@ -1677,7 +1587,7 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock050, TestSize.Level2) /** * @tc.name: PowerMgrMock051 - * @tc.desc: test background RunningLock by mock + * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock051, TestSize.Level2) @@ -1691,36 +1601,33 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock051, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock051: Failed to get PowerMgrService"; } - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); - pms->CreateRunningLock(token, info); - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - - //EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); - sleep(SLEEP_WAIT_TIME_S*10); - - EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); - EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); - - - ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock051:End."); - GTEST_LOG_(INFO) << "PowerMgrMock051: end."; -} + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, + Suspend(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + sleep(SLEEP_WAIT_TIME_S+1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock051:End."); + GTEST_LOG_(INFO) << "PowerMgrMock051: end."; +} /** * @tc.name: PowerMgrMock052 - * @tc.desc: test background RunningLock by mock + * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock052, TestSize.Level2) { - int i; + SuspendDeviceType abnormaltype = SuspendDeviceType(10); sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock052: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock052:Start."); @@ -1730,22 +1637,10 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock052, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock052: Failed to get PowerMgrService"; } - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); - pms->CreateRunningLock(token, info); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); - for(i=0;i<10;i++){ - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - sleep(SCREEN_OFF_WAIT_TIME_S + 1); - - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); - EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); - } + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, + Suspend(0, _, false)).Times(0); + pms->SuspendDevice(0, abnormaltype, false); EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); ResetMockAction(); @@ -1755,11 +1650,12 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock052, TestSize.Level2) /** * @tc.name: PowerMgrMock053 - * @tc.desc: test background RunningLock by mock + * @tc.desc: test SuspendDevice by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock053, TestSize.Level2) { + SuspendDeviceType abnormaltype = {}; sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock053: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock053:Start."); @@ -1769,38 +1665,22 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock053, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock053: Failed to get PowerMgrService"; } - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); - pms->CreateRunningLock(token, info); - - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - - sleep(SLEEP_WAIT_TIME_S + 1); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); - sleep(SLEEP_WAIT_TIME_S + 1); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); - - EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); - EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, + Suspend(0, _, false)); + pms->SuspendDevice(0, abnormaltype, false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock053:End"); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock053:End."); GTEST_LOG_(INFO) << "PowerMgrMock053: end."; } + + /** * @tc.name: PowerMgrMock054 - * @tc.desc: test background RunningLock by mock + * @tc.desc: test ForceSuspendDevice by mock during Inactive * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock054, TestSize.Level2) @@ -1814,28 +1694,12 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock054, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock054: Failed to get PowerMgrService"; } - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); - pms->CreateRunningLock(token, info); - - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); - - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - - sleep(SLEEP_WAIT_TIME_S + 1); - EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) - .Times(1) + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)) + .Times(::testing::AtLeast(1)) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_EQ(pms->ForceSuspendDevice(0), true); - sleep(SLEEP_WAIT_TIME_S + 1); - - EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); + pms->ForceSuspendDevice(0); + sleep(SLEEP_WAIT_TIME_S+1); EXPECT_EQ(PowerState::SLEEP,pms->GetState()); ResetMockAction(); @@ -1845,7 +1709,7 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock054, TestSize.Level2) /** * @tc.name: PowerMgrMock055 - * @tc.desc: test proximity screen control RunningLock by mock + * @tc.desc: test auto suspend by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock055, TestSize.Level2) @@ -1859,34 +1723,28 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock055, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock055: Failed to get PowerMgrService"; } - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); - pms->CreateRunningLock(token, info); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_LID , std::string("test")); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM )) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF )) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - sleep(SCREEN_OFF_WAIT_TIME_S + 1); - EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - EXPECT_EQ(PowerState::AWAKE,pms->GetState()); - - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); - + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock055:End."); GTEST_LOG_(INFO) << "PowerMgrMock055: end."; } - /** * @tc.name: PowerMgrMock056 - * @tc.desc: test proximity screen control RunningLock by mock + * @tc.desc: test SCREEN_ON RunningLock by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock056, TestSize.Level2) @@ -1900,27 +1758,22 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock056, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock056: Failed to get PowerMgrService"; } + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); pms->CreateRunningLock(token, info); - EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_EQ(pms->ForceSuspendDevice(0), true); - - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - sleep(SCREEN_OFF_WAIT_TIME_S + 1); - EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + pms->Lock(token, info, 0); EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); EXPECT_EQ(PowerState::AWAKE,pms->GetState()); pms->UnLock(token); EXPECT_EQ(pms->IsUsed(token), false); - - ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock056:End."); GTEST_LOG_(INFO) << "PowerMgrMock056: end."; @@ -1928,7 +1781,7 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock056, TestSize.Level2) /** * @tc.name: PowerMgrMock057 - * @tc.desc: test proximity screen control RunningLock by mock + * @tc.desc: test SCREEN_ON RunningLock by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock057, TestSize.Level2) @@ -1942,29 +1795,19 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock057, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock057: Failed to get PowerMgrService"; } + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); pms->CreateRunningLock(token, info); - EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->Lock(token, info, 0); EXPECT_EQ(pms->IsUsed(token), true); - + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); pms->UnLock(token); EXPECT_EQ(pms->IsUsed(token), false); - sleep(SCREEN_OFF_WAIT_TIME_S + 1); - EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); - sleep(SLEEP_WAIT_TIME_S + 1); - EXPECT_EQ(PowerState::SLEEP,pms->GetState()); - - ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock057:End."); GTEST_LOG_(INFO) << "PowerMgrMock057: end."; @@ -1972,49 +1815,40 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock057, TestSize.Level2) /** * @tc.name: PowerMgrMock058 - * @tc.desc: test proximity RunningLock by mock + * @tc.desc: test Auto DIM by mock after 10min * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock058, TestSize.Level2) { + int64_t time =600000; sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock058: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock058:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { GTEST_LOG_(INFO) << "PowerMgrMock058: Failed to get PowerMgrService"; } - - sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); - pms->CreateRunningLock(token, info); - pms->ReleaseRunningLock(token); - - EXPECT_CALL(*lockAction, Lock(_, _)).Times(0); - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), false); - - sleep(SCREEN_OFF_WAIT_TIME_S+1); - EXPECT_EQ(PowerState::AWAKE,pms->GetState()); - + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); - pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); - - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); - + pms->SetDisplayOffTime(time); + sleep(time/1000-2); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(3); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock058:End."); +pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); GTEST_LOG_(INFO) << "PowerMgrMock058: end."; } /** * @tc.name: PowerMgrMock059 - * @tc.desc: test proximity RunningLock by mock + * @tc.desc: test Screen RunningLock by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock059, TestSize.Level2) @@ -2029,25 +1863,17 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock059, TestSize.Level2) } sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); pms->CreateRunningLock(token, info); pms->Lock(token, info, 0); EXPECT_EQ(pms->IsUsed(token), true); - sleep(SLEEP_WAIT_TIME_S*10); - EXPECT_EQ(PowerState::AWAKE,pms->GetState()); - - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); - pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); - sleep(SLEEP_WAIT_TIME_S+1); - EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); - + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sleep(SCREEN_DIM_WAIT_TIME_S + 1); + pms->UnLock(token); EXPECT_EQ(pms->IsUsed(token), false); - + ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock059:End."); GTEST_LOG_(INFO) << "PowerMgrMock059: end."; @@ -2055,12 +1881,11 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock059, TestSize.Level2) /** * @tc.name: PowerMgrMock060 - * @tc.desc: test proximity RunningLock by mock + * @tc.desc: test Screen RunningLock by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock060, TestSize.Level2) { - int i; sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock060: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock060:Start."); @@ -2071,28 +1896,18 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock060, TestSize.Level2) } sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); pms->CreateRunningLock(token, info); - - for(i=0;i<10;i++){ - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - sleep(SCREEN_OFF_WAIT_TIME_S + 1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); - EXPECT_EQ(PowerState::AWAKE,pms->GetState()); - } - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); - pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); - EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + sleep(SLEEP_WAIT_TIME_S*10); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); - ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock060:End."); GTEST_LOG_(INFO) << "PowerMgrMock060: end."; @@ -2100,11 +1915,12 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock060, TestSize.Level2) /** * @tc.name: PowerMgrMock061 - * @tc.desc: test proximity RunningLock by mock + * @tc.desc: test Screen on RunningLock by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock061, TestSize.Level2) { + int i; sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock061: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock061:Start."); @@ -2115,26 +1931,20 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock061, TestSize.Level2) } sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); pms->CreateRunningLock(token, info); + for(i=0;i<10;i++){ + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); - EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); - pms->Lock(token, info, 0); - EXPECT_EQ(pms->IsUsed(token), true); - - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); - sleep(SLEEP_WAIT_TIME_S + 1); - EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)).Times(0); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); - EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); - pms->UnLock(token); - EXPECT_EQ(pms->IsUsed(token), false); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + } + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock061:End."); @@ -2143,7 +1953,7 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock061, TestSize.Level2) /** * @tc.name: PowerMgrMock062 - * @tc.desc: test proximity RunningLock by mock + * @tc.desc: test Screen RunningLock by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock062, TestSize.Level2) @@ -2157,27 +1967,25 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock062, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock062: Failed to get PowerMgrService"; } - //pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); pms->CreateRunningLock(token, info); - EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); pms->Lock(token, info, 0); EXPECT_EQ(pms->IsUsed(token), true); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) - .Times(1) + .Times(::testing::AtLeast(1)) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->ForceSuspendDevice(0); - EXPECT_EQ(PowerState::SLEEP,pms->GetState()); - EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(1); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sleep(SLEEP_WAIT_TIME_S + 1); + pms->UnLock(token); EXPECT_EQ(pms->IsUsed(token), false); + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock062:End."); @@ -2186,7 +1994,7 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock062, TestSize.Level2) /** * @tc.name: PowerMgrMock063 - * @tc.desc: test proximity RunningLock by mock + * @tc.desc: test Screen RunningLock by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock063, TestSize.Level2) @@ -2200,27 +2008,23 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock063, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock063: Failed to get PowerMgrService"; } - //pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); sptr token = new RunningLockTokenStub(); - RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); pms->CreateRunningLock(token, info); - EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); pms->Lock(token, info, 0); EXPECT_EQ(pms->IsUsed(token), true); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, - Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , - std::string("test"), _)).Times(1); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); - EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + EXPECT_EQ(pms->ForceSuspendDevice(0), true); + sleep(SLEEP_WAIT_TIME_S + 1); - EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); pms->UnLock(token); EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock063:End."); @@ -2229,46 +2033,49 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock063, TestSize.Level2) /** * @tc.name: PowerMgrMock064 - * @tc.desc: test Auto SuspendDevice by mock after 15s + * @tc.desc: test Screen RunningLock by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock064, TestSize.Level2) { - int64_t time =15000; sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock064: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock064:Start."); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock063:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { GTEST_LOG_(INFO) << "PowerMgrMock064: Failed to get PowerMgrService"; } - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->SetDisplayOffTime(time); - sleep(time/1000+1); - sleep(SLEEP_WAIT_TIME_S+1); - + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_SCREEN); + pms->CreateRunningLock(token, info); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, Suspend(_, _, _)).Times(0); + + EXPECT_CALL(*stateAction, + Wakeup(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , + std::string("test"), _)).Times(1); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + + pms->UnLock(token); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); ResetMockAction(); POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock064:End."); - pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); GTEST_LOG_(INFO) << "PowerMgrMock064: end."; } /** * @tc.name: PowerMgrMock065 - * @tc.desc: test Auto SuspendDevice by mock after 30s + * @tc.desc: test background RunningLock by mock * @tc.type: FUNC */ HWTEST_F (PowerMgrMockTest, PowerMgrMock065, TestSize.Level2) { - int64_t time =30000; sleep(NEXT_WAIT_TIME_S); GTEST_LOG_(INFO) << "PowerMgrMock065: start."; POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock065:Start."); @@ -2278,346 +2085,1084 @@ HWTEST_F (PowerMgrMockTest, PowerMgrMock065, TestSize.Level2) GTEST_LOG_(INFO) << "PowerMgrMock065: Failed to get PowerMgrService"; } - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) .Times(1) .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->SetDisplayOffTime(time); - sleep(time/1000+1); - sleep(SLEEP_WAIT_TIME_S+1); + EXPECT_EQ(pms->ForceSuspendDevice(0), true); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); ResetMockAction(); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock065:End"); - pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock065:End."); GTEST_LOG_(INFO) << "PowerMgrMock065: end."; } -// /** -// * @tc.name: PowerMgrMock066 -// * @tc.desc: test Auto SuspendDevice by mock after 1min -// * @tc.type: FUNC -// */ -// HWTEST_F (PowerMgrMockTest, PowerMgrMock066, TestSize.Level2) -// { -// int64_t time =60000; -// sleep(NEXT_WAIT_TIME_S); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock066:Start"); -// GTEST_LOG_(INFO) << "PowerMgrMock066: start."; - -// sptr pms = DelayedSpSingleton::GetInstance(); -// if (pms == nullptr) { -// GTEST_LOG_(INFO) << "PowerMgrMock066: Failed to get PowerMgrService"; -// } - -// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// pms->SetDisplayOffTime(time); -// sleep(time/1000+1); -// sleep(SLEEP_WAIT_TIME_S+1); - -// ResetMockAction(); -// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock066:End"); -// GTEST_LOG_(INFO) << "PowerMgrMock066: end."; -// } - -// /** -// * @tc.name: PowerMgrMock067 -// * @tc.desc: test Auto SuspendDevice by mock after 2mins -// * @tc.type: FUNC -// */ -// HWTEST_F (PowerMgrMockTest, PowerMgrMock067, TestSize.Level2) -// { -// int64_t time =120000; -// sleep(NEXT_WAIT_TIME_S); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock067:Start"); -// GTEST_LOG_(INFO) << "PowerMgrMock067: start."; - -// sptr pms = DelayedSpSingleton::GetInstance(); -// if (pms == nullptr) { -// GTEST_LOG_(INFO) << "PowerMgrMock067: Failed to get PowerMgrService"; -// } - -// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// pms->SetDisplayOffTime(time); -// sleep(time/1000+1); -// sleep(SLEEP_WAIT_TIME_S+1); - -// ResetMockAction(); -// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock067:End"); -// GTEST_LOG_(INFO) << "PowerMgrMock067: end."; -// } - -// /** -// * @tc.name: PowerMgrMock068 -// * @tc.desc: test Auto SuspendDevice by mock after 5mins -// * @tc.type: FUNC -// */ -// HWTEST_F (PowerMgrMockTest, PowerMgrMock068, TestSize.Level2) -// { -// int64_t time =300000; -// sleep(NEXT_WAIT_TIME_S); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock068:Start"); -// GTEST_LOG_(INFO) << "PowerMgrMock068: start."; - -// sptr pms = DelayedSpSingleton::GetInstance(); -// if (pms == nullptr) { -// GTEST_LOG_(INFO) << "PowerMgrMock068: Failed to get PowerMgrService"; -// } - -// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// pms->SetDisplayOffTime(time); -// sleep(time/1000+1); -// sleep(SLEEP_WAIT_TIME_S+1); - -// ResetMockAction(); -// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock068:End"); -// GTEST_LOG_(INFO) << "PowerMgrMock068: end."; -// } - -// /** -// * @tc.name: PowerMgrMock069 -// * @tc.desc: test Auto SuspendDevice by mock after 10mins -// * @tc.type: FUNC -// */ -// HWTEST_F (PowerMgrMockTest, PowerMgrMock069, TestSize.Level2) -// { -// int64_t time =600000; -// sleep(NEXT_WAIT_TIME_S); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock069:Start"); -// GTEST_LOG_(INFO) << "PowerMgrMock069: start."; - -// sptr pms = DelayedSpSingleton::GetInstance(); -// if (pms == nullptr) { -// GTEST_LOG_(INFO) << "PowerMgrMock069: Failed to get PowerMgrService"; -// } - -// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// pms->SetDisplayOffTime(time); -// sleep(time/1000+1); -// sleep(SLEEP_WAIT_TIME_S+1); - -// ResetMockAction(); -// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock069:End"); -// GTEST_LOG_(INFO) << "PowerMgrMock069: end."; -// } +/** + * @tc.name: PowerMgrMock066 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock066, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock066: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock066:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock066: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(1); + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock066:End."); + GTEST_LOG_(INFO) << "PowerMgrMock066: end."; +} /** - * @tc.name: PowerMgrMock070 - * @tc.desc: test Auto DIM by mock after 15s + * @tc.name: PowerMgrMock067 + * @tc.desc: test background RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock070, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrMock067, TestSize.Level2) { - int64_t time =15000; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock070: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070:Start."); + GTEST_LOG_(INFO) << "PowerMgrMock067: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock067:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock070: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrMock067: Failed to get PowerMgrService"; } - pms->SetDisplayOffTime(time); - pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070:DeviceStateAction::SetDisplayState."); - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + sleep(SLEEP_WAIT_TIME_S*10); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070:Start sleep."); - sleep(time/1000-2); - sleep(3); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070: sleep end."); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + ResetMockAction(); - pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070:End."); - GTEST_LOG_(INFO) << "PowerMgrMock070: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock067:End."); + GTEST_LOG_(INFO) << "PowerMgrMock067: end."; } /** - * @tc.name: PowerMgrMock071 - * @tc.desc: test Auto DIM by mock after 30s + * @tc.name: PowerMgrMock068 + * @tc.desc: test background RunningLock by mock * @tc.type: FUNC */ -HWTEST_F (PowerMgrMockTest, PowerMgrMock071, TestSize.Level2) +HWTEST_F (PowerMgrMockTest, PowerMgrMock068, TestSize.Level2) { - int64_t time =30000; + int i; sleep(NEXT_WAIT_TIME_S); - GTEST_LOG_(INFO) << "PowerMgrMock071: start."; - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0071:Start."); + GTEST_LOG_(INFO) << "PowerMgrMock068: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock068:Start."); sptr pms = DelayedSpSingleton::GetInstance(); if (pms == nullptr) { - GTEST_LOG_(INFO) << "PowerMgrMock071: Failed to get PowerMgrService"; + GTEST_LOG_(INFO) << "PowerMgrMock068: Failed to get PowerMgrService"; } - EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + pms->CreateRunningLock(token, info); EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) - .Times(1) - .WillOnce(::testing::Return(ActionResult::SUCCESS)); - pms->SetDisplayOffTime(time); - sleep(time/1000-2); - sleep(3); + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + for(i=0;i<10;i++){ + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + } + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + ResetMockAction(); - pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); - POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock071:End."); - GTEST_LOG_(INFO) << "PowerMgrMock071: end."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock068:End."); + GTEST_LOG_(INFO) << "PowerMgrMock068: end."; } -// /** -// * @tc.name: PowerMgrMock072 -// * @tc.desc: test Auto DIM by mock after 60s -// * @tc.type: FUNC -// */ -// HWTEST_F (PowerMgrMockTest, PowerMgrMock072, TestSize.Level2) -// { -// int64_t time =60000; -// sleep(NEXT_WAIT_TIME_S); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0072:Start."); -// GTEST_LOG_(INFO) << "PowerMgrMock072: start."; - -// sptr pms = DelayedSpSingleton::GetInstance(); -// if (pms == nullptr) { -// GTEST_LOG_(INFO) << "PowerMgrMock072: Failed to get PowerMgrService"; -// } - -// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// pms->SetDisplayOffTime(time); -// sleep(time/1000-2); -// sleep(3); -// ResetMockAction(); -// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0072:End."); -// GTEST_LOG_(INFO) << "PowerMgrMock072: end."; -// } - -// /** -// * @tc.name: PowerMgrMock073 -// * @tc.desc: test Auto DIM by mock after 2min -// * @tc.type: FUNC -// */ -// HWTEST_F (PowerMgrMockTest, PowerMgrMock073, TestSize.Level2) -// { -// int64_t time =120000; -// sleep(NEXT_WAIT_TIME_S); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0073:Start."); -// GTEST_LOG_(INFO) << "PowerMgrMock073: start."; - -// sptr pms = DelayedSpSingleton::GetInstance(); -// if (pms == nullptr) { -// GTEST_LOG_(INFO) << "PowerMgrMock073: Failed to get PowerMgrService"; -// } - -// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// pms->SetDisplayOffTime(time); -// sleep(time/1000-2); -// sleep(3); -// ResetMockAction(); -// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0073:End."); -// GTEST_LOG_(INFO) << "PowerMgrMock073: end."; -// } - -// /** -// * @tc.name: PowerMgrMock074 -// * @tc.desc: test Auto DIM by mock after 5min -// * @tc.type: FUNC -// */ -// HWTEST_F (PowerMgrMockTest, PowerMgrMock074, TestSize.Level2) -// { -// int64_t time =300000; -// sleep(NEXT_WAIT_TIME_S); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0074:Start."); -// GTEST_LOG_(INFO) << "PowerMgrMock074: start."; - -// sptr pms = DelayedSpSingleton::GetInstance(); -// if (pms == nullptr) { -// GTEST_LOG_(INFO) << "PowerMgrMock074: Failed to get PowerMgrService"; -// } - -// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// pms->SetDisplayOffTime(time); -// sleep(time/1000-2); -// sleep(3); -// ResetMockAction(); -// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0074:End."); -// GTEST_LOG_(INFO) << "PowerMgrMock074: end."; -// } - -// /** -// * @tc.name: PowerMgrMock075 -// * @tc.desc: test Auto DIM by mock after 10min -// * @tc.type: FUNC -// */ -// HWTEST_F (PowerMgrMockTest, PowerMgrMock075, TestSize.Level2) -// { -// int64_t time =600000; -// sleep(NEXT_WAIT_TIME_S); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0075:Start."); -// GTEST_LOG_(INFO) << "PowerMgrMock075: start."; - -// sptr pms = DelayedSpSingleton::GetInstance(); -// if (pms == nullptr) { -// GTEST_LOG_(INFO) << "PowerMgrMock075: Failed to get PowerMgrService"; -// } - -// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) -// .Times(1) -// .WillOnce(::testing::Return(ActionResult::SUCCESS)); -// pms->SetDisplayOffTime(time); -// sleep(time/1000-2); -// sleep(3); -// ResetMockAction(); -// pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); -// POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0075:End."); -// GTEST_LOG_(INFO) << "PowerMgrMock075: end."; -// } \ No newline at end of file +/** + * @tc.name: PowerMgrMock069 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock069, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock069: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock069:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock069: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sleep(SLEEP_WAIT_TIME_S ); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)).Times(0); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock069:End"); + GTEST_LOG_(INFO) << "PowerMgrMock069: end."; +} + +/** + * @tc.name: PowerMgrMock070 + * @tc.desc: test background RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock070, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock070: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock070: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_BACKGROUND); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_EQ(pms->ForceSuspendDevice(0), true); + sleep(SLEEP_WAIT_TIME_S + 1); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock070:End."); + GTEST_LOG_(INFO) << "PowerMgrMock070: end."; +} + +/** + * @tc.name: PowerMgrMock071 + * @tc.desc: test proximity screen control RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock071, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock071: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock071:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock071: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock071:End."); + GTEST_LOG_(INFO) << "PowerMgrMock071: end."; +} + + +/** + * @tc.name: PowerMgrMock072 + * @tc.desc: test proximity screen control RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock072, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock072: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock072:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock072: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_EQ(pms->ForceSuspendDevice(0), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_ON)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock072:End."); + GTEST_LOG_(INFO) << "PowerMgrMock072: end."; +} + +/** + * @tc.name: PowerMgrMock073 + * @tc.desc: test proximity screen control RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock073, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock073: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock073:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock073: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep(SLEEP_WAIT_TIME_S ); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + sleep(SLEEP_WAIT_TIME_S + 1); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock073:End."); + GTEST_LOG_(INFO) << "PowerMgrMock073: end."; +} + +/** + * @tc.name: PowerMgrMock074 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock074, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock074: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock074:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock074: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + //pms->ReleaseRunningLock(token); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + sleep(SCREEN_OFF_WAIT_TIME_S+1); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); + + // pms->UnLock(token); + // EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock074:End."); + GTEST_LOG_(INFO) << "PowerMgrMock074: end."; +} + +/** + * @tc.name: PowerMgrMock075 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock075, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock075: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock075:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock075: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep(SLEEP_WAIT_TIME_S*10); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock075:End."); + GTEST_LOG_(INFO) << "PowerMgrMock075: end."; +} + +/** + * @tc.name: PowerMgrMock076 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock076, TestSize.Level2) +{ + int i; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock076: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock076:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock076: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + for(i=0;i<10;i++){ + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep(SCREEN_OFF_WAIT_TIME_S + 1); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + } + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, _)).Times(0); + pms->MockProximity(RunningLockMgr::PROXIMITY_CLOSE); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock076:End."); + GTEST_LOG_(INFO) << "PowerMgrMock076: end."; +} + +/** + * @tc.name: PowerMgrMock077 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock077, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock077: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock077:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock077: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sleep(SLEEP_WAIT_TIME_S + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock077:End."); + GTEST_LOG_(INFO) << "PowerMgrMock077: end."; +} + +/** + * @tc.name: PowerMgrMock078 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock078, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock078: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock078:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock078: Failed to get PowerMgrService"; + } + + //pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, true)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->ForceSuspendDevice(0); + EXPECT_EQ(PowerState::SLEEP,pms->GetState()); + + EXPECT_CALL(*lockAction, Unlock(_, _)).Times(1); + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock078:End."); + GTEST_LOG_(INFO) << "PowerMgrMock078: end."; +} + +/** + * @tc.name: PowerMgrMock079 + * @tc.desc: test proximity RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock079, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock079: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock079:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock079: Failed to get PowerMgrService"; + } + + pms->SuspendDevice(0, SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false); + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + EXPECT_CALL(*lockAction, Lock(_, _)).Times(1); + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock079:End."); + GTEST_LOG_(INFO) << "PowerMgrMock079: end."; +} + +/** + * @tc.name: PowerMgrMock080 + * @tc.desc: test Auto SuspendDevice by mock after 15s + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock080, TestSize.Level2) +{ + int64_t time =15000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock080: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock080:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock080: Failed to get PowerMgrService"; + } + + pms->SetDisplayOffTime(time); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(((time/1000)*2/3)+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(time/1000*1/3+1); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + // EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + sleep(SLEEP_WAIT_TIME_S+1); + + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock080:End."); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock080: end."; +} + +/** + * @tc.name: PowerMgrMock081 + * @tc.desc: test Auto SuspendDevice by mock after 30s + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock081, TestSize.Level2) +{ + int64_t time =30000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock081: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock081:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock081: Failed to get PowerMgrService"; + } + + pms->SetDisplayOffTime(time); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(((time/1000)*2/3)+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(((time/1000)*1/3)+1); + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + sleep(SLEEP_WAIT_TIME_S+1); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock081:End"); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock081: end."; +} + +/** + * @tc.name: PowerMgrMock082 + * @tc.desc: test Auto SuspendDevice by mock after 1min + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock082, TestSize.Level2) +{ + int64_t time =60000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock082: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock082: Failed to get PowerMgrService"; + } + + pms->SetDisplayOffTime(time); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(((time/1000)*2/3)+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(time/1000*1/3+1); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + // EXPECT_EQ(PowerState::AWAKE,pms->GetState()); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + sleep(SLEEP_WAIT_TIME_S+1); + + ResetMockAction(); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock082: end."; +} + +/** + * @tc.name: PowerMgrMock083 + * @tc.desc: test Auto SuspendDevice by mock after 2mins + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock083, TestSize.Level2) +{ + int64_t time =120000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock083: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock083: Failed to get PowerMgrService"; + } + + pms->SetDisplayOffTime(time); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(((time/1000)*2/3)+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(time/1000*1/3+1); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + sleep(SLEEP_WAIT_TIME_S+1); + + ResetMockAction(); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock083: end."; +} + +/** + * @tc.name: PowerMgrMock084 + * @tc.desc: test Auto SuspendDevice by mock after 5mins + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock084, TestSize.Level2) +{ + int64_t time =300000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock084: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock084: Failed to get PowerMgrService"; + } + + pms->SetDisplayOffTime(time); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(((time/1000)*2/3)+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(time/1000*1/3+1); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + sleep(SLEEP_WAIT_TIME_S+1); + + ResetMockAction(); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock084: end."; +} + +/** + * @tc.name: PowerMgrMock085 + * @tc.desc: test Auto SuspendDevice by mock after 10mins + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock085, TestSize.Level2) +{ + int64_t time =600000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock085: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock085: Failed to get PowerMgrService"; + } + + pms->SetDisplayOffTime(time); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep(((time/1000)*2/3)+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep(time/1000*1/3+1); + + EXPECT_CALL(*stateAction, GoToSleep(_, _, false)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_OFF)); + sleep(SLEEP_WAIT_TIME_S+1); + + ResetMockAction(); +pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock085: end."; +} + +/** + * @tc.name: PowerMgrMock086 + * @tc.desc: test Auto DIM by mock after 15s + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock086, TestSize.Level2) +{ + int64_t time =15000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock086: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock086: Failed to get PowerMgrService"; + } + pms->SetDisplayOffTime(time); + pms->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN , std::string("test")); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086:DeviceStateAction::SetDisplayState."); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086:Start sleep."); + sleep(time/1000-2); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(3); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086: sleep end."); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock086:End."); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock086: end."; +} + +/** + * @tc.name: PowerMgrMock087 + * @tc.desc: test Auto DIM by mock after 30s + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock087, TestSize.Level2) +{ + int64_t time =30000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock087: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock0087:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock087: Failed to get PowerMgrService"; + } + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000-2); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(3); + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock087:End."); + pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock087: end."; +} + +/** + * @tc.name: PowerMgrMock088 + * @tc.desc: test Auto DIM by mock after 60s + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock088, TestSize.Level2) +{ + int64_t time =60000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock088: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock088: Failed to get PowerMgrService"; + } + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000-2); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(3); + ResetMockAction(); +pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock088: end."; +} + +/** + * @tc.name: PowerMgrMock089 + * @tc.desc: test Auto DIM by mock after 2min + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock089, TestSize.Level2) +{ + int64_t time =120000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock089: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock089: Failed to get PowerMgrService"; + } + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000-2); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(3); + ResetMockAction(); +pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock089: end."; +} + +/** + * @tc.name: PowerMgrMock090 + * @tc.desc: test Auto DIM by mock after 5min + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock090, TestSize.Level2) +{ + int64_t time =300000; + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock090: start."; + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock090: Failed to get PowerMgrService"; + } + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_DIM)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(1) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + pms->SetDisplayOffTime(time); + sleep(time/1000-2); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + sleep(3); + ResetMockAction(); +pms->SetDisplayOffTime(DEFAULT_DISPLAY_OFF_TIME ); + GTEST_LOG_(INFO) << "PowerMgrMock090: end."; +} + + + +/** + * @tc.name: PowerMgrMock091 + * @tc.desc: test proximity screen control RunningLock by mock + * @tc.type: FUNC + */ +HWTEST_F (PowerMgrMockTest, PowerMgrMock091, TestSize.Level2) +{ + sleep(NEXT_WAIT_TIME_S); + GTEST_LOG_(INFO) << "PowerMgrMock091: start."; + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock091:Start."); + + sptr pms = DelayedSpSingleton::GetInstance(); + if (pms == nullptr) { + GTEST_LOG_(INFO) << "PowerMgrMock091: Failed to get PowerMgrService"; + } + + sptr token = new RunningLockTokenStub(); + RunningLockInfo info("test1", RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL); + pms->CreateRunningLock(token, info); + + pms->Lock(token, info, 0); + EXPECT_EQ(pms->IsUsed(token), true); + sleep(SLEEP_WAIT_TIME_S ); + + pms->UnLock(token); + EXPECT_EQ(pms->IsUsed(token), false); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_ON)); + sleep((SCREEN_OFF_WAIT_TIME_S*2/3)+1); + ON_CALL(*stateAction, GetDisplayState()) + .WillByDefault(::testing::Return(DisplayState::DISPLAY_DIM)); + EXPECT_CALL(*stateAction, SetDisplayState(DisplayState::DISPLAY_OFF)) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(ActionResult::SUCCESS)); + sleep((SCREEN_OFF_WAIT_TIME_S*1/3) + 1); + EXPECT_EQ(PowerState::INACTIVE,pms->GetState()); + + ResetMockAction(); + POWER_HILOGD(MODULE_SERVICE, "PowerMgrMock091:End."); + GTEST_LOG_(INFO) << "PowerMgrMock091: end."; +} + + + + -- Gitee From ebab5e3493ee23378ea7f03f7520ea4f35e4b076 Mon Sep 17 00:00:00 2001 From: Du Jiang Date: Thu, 9 Sep 2021 18:47:39 +0800 Subject: [PATCH 10/11] Fix build error in systemtest Change-Id: I832283098bae56c8bdb2a342da58fec958d2768a --- test/systemtest/BUILD.gn | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/test/systemtest/BUILD.gn b/test/systemtest/BUILD.gn index 5c940130..d42a0e18 100644 --- a/test/systemtest/BUILD.gn +++ b/test/systemtest/BUILD.gn @@ -125,7 +125,6 @@ ohos_systemtest("test_power_mgr_powersavemode") { "appexecfwk_standard:appexecfwk_base", "appexecfwk_standard:libeventhandler", "ipc:ipc_core", - "ces_standard:cesfwk_kits", "safwk:system_ability_fwk", "samgr_L2:samgr_proxy", ] @@ -137,4 +136,4 @@ group("systemtest_powermgr") { ":test_power_mgr_powersavemode", ":test_power_st_mgr_mock", ] -} \ No newline at end of file +} -- Gitee From 2cb79b868f5fbcd2eb67cb6ed91c43ecaedb0368 Mon Sep 17 00:00:00 2001 From: Du Jiang Date: Mon, 13 Sep 2021 16:44:20 +0800 Subject: [PATCH 11/11] Fix test build error in power save mode Change-Id: I195fafd7971add10344b592f3238ec4e6d97eec1 --- test/systemtest/BUILD.gn | 2 ++ test/systemtest/src/power_mgr_powersavemode_test.cpp | 8 +------- 2 files changed, 3 insertions(+), 7 deletions(-) diff --git a/test/systemtest/BUILD.gn b/test/systemtest/BUILD.gn index d42a0e18..7affa2ec 100644 --- a/test/systemtest/BUILD.gn +++ b/test/systemtest/BUILD.gn @@ -62,6 +62,7 @@ deps_ex = [ "aafwk_standard:want", "appexecfwk_standard:appexecfwk_base", "appexecfwk_standard:libeventhandler", + "ces_standard:cesfwk_innerkits", "ipc:ipc_core", "hiviewdfx_hilog_native:libhilog", "safwk:system_ability_fwk", @@ -124,6 +125,7 @@ ohos_systemtest("test_power_mgr_powersavemode") { "aafwk_standard:want", "appexecfwk_standard:appexecfwk_base", "appexecfwk_standard:libeventhandler", + "ces_standard:cesfwk_innerkits", "ipc:ipc_core", "safwk:system_ability_fwk", "samgr_L2:samgr_proxy", diff --git a/test/systemtest/src/power_mgr_powersavemode_test.cpp b/test/systemtest/src/power_mgr_powersavemode_test.cpp index d9f6be58..95a84ffa 100644 --- a/test/systemtest/src/power_mgr_powersavemode_test.cpp +++ b/test/systemtest/src/power_mgr_powersavemode_test.cpp @@ -35,14 +35,8 @@ #include "ipower_mode_callback.h" #include "common_event_manager.h" -#define private public -#define protected public -#include "common_event_manager_service.h" -#undef private -#undef protected #include "common_event_subscriber.h" #include "common_event_support.h" -#include "event_log_wrapper.h" using namespace testing::ext; using namespace OHOS::PowerMgr; @@ -596,4 +590,4 @@ HWTEST_F(PowerMgrPowerSavemodeTest, PowerSavemode_025, TestSize.Level0) CommonEventManager::UnSubscribeCommonEvent(subscriberPtr); POWER_HILOGD(MODULE_SERVICE, "PowerSavemode_025 1."); -} \ No newline at end of file +} -- Gitee