1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "device_state_action.h"
17
18 #include "display_manager.h"
19 #include "display_power_mgr_client.h"
20 #include "power_state_machine_info.h"
21 #include "system_suspend_controller.h"
22 #include "hilog_wrapper.h"
23
24 using namespace std;
25
26 namespace OHOS {
27 namespace PowerMgr {
28 using namespace DisplayPowerMgr;
29 using namespace Rosen;
30
DeviceStateAction()31 DeviceStateAction::DeviceStateAction()
32 {
33 dispCallback_ = nullptr;
34 }
35
~DeviceStateAction()36 DeviceStateAction::~DeviceStateAction()
37 {
38 }
39
Suspend(int64_t callTimeMs,SuspendDeviceType type,uint32_t flags)40 void DeviceStateAction::Suspend(int64_t callTimeMs, SuspendDeviceType type, uint32_t flags)
41 {
42 // Display is controlled by PowerStateMachine
43 // Don't suspend until GoToSleep is called
44 }
45
ForceSuspend()46 void DeviceStateAction::ForceSuspend()
47 {
48 GoToSleep(nullptr, nullptr, true);
49 }
50
Wakeup(int64_t callTimeMs,WakeupDeviceType type,const string & details,const string & pkgName)51 void DeviceStateAction::Wakeup(int64_t callTimeMs, WakeupDeviceType type, const string& details,
52 const string& pkgName)
53 {
54 SystemSuspendController::GetInstance().Wakeup();
55 }
56
GetDisplayState()57 DisplayState DeviceStateAction::GetDisplayState()
58 {
59 DisplayPowerMgr::DisplayState state = DisplayPowerMgrClient::GetInstance().GetDisplayState();
60 POWER_HILOGI(MODULE_SERVICE, "GetDisplayState: %{public}d", state);
61 DisplayState ret = DisplayState::DISPLAY_ON;
62 switch (state) {
63 case DisplayPowerMgr::DisplayState::DISPLAY_ON:
64 ret = DisplayState::DISPLAY_ON;
65 break;
66 case DisplayPowerMgr::DisplayState::DISPLAY_DIM:
67 ret = DisplayState::DISPLAY_DIM;
68 break;
69 case DisplayPowerMgr::DisplayState::DISPLAY_OFF:
70 ret = DisplayState::DISPLAY_OFF;
71 break;
72 case DisplayPowerMgr::DisplayState::DISPLAY_SUSPEND:
73 ret = DisplayState::DISPLAY_SUSPEND;
74 break;
75 default:
76 break;
77 }
78 return ret;
79 }
80
SetDisplayState(const DisplayState state,StateChangeReason reason)81 uint32_t DeviceStateAction::SetDisplayState(const DisplayState state, StateChangeReason reason)
82 {
83 POWER_HILOGI(MODULE_SERVICE, "Action: SetDisplayState: %{public}d, %{public}d",
84 static_cast<uint32_t>(state), static_cast<uint32_t>(reason));
85
86 DisplayState currentState = GetDisplayState();
87 if (state == currentState) {
88 POWER_HILOGI(MODULE_SERVICE, "Already in state: %{public}d", static_cast<uint32_t>(state));
89 return ActionResult::SUCCESS;
90 }
91
92 if (dispCallback_ == nullptr) {
93 POWER_HILOGI(MODULE_SERVICE, "Register Callback");
94 dispCallback_ = new DisplayPowerCallback();
95 DisplayPowerMgrClient::GetInstance().RegisterCallback(dispCallback_);
96 }
97
98 DisplayPowerMgr::DisplayState dispState = DisplayPowerMgr::DisplayState::DISPLAY_ON;
99 switch (state) {
100 case DisplayState::DISPLAY_ON: {
101 dispState = DisplayPowerMgr::DisplayState::DISPLAY_ON;
102 if (currentState == DisplayState::DISPLAY_OFF) {
103 DisplayManager::GetInstance().WakeUpBegin(PowerStateChangeReason::POWER_BUTTON);
104 }
105 break;
106 }
107 case DisplayState::DISPLAY_DIM:
108 dispState = DisplayPowerMgr::DisplayState::DISPLAY_DIM;
109 break;
110 case DisplayState::DISPLAY_OFF: {
111 dispState = DisplayPowerMgr::DisplayState::DISPLAY_OFF;
112 if (currentState == DisplayState::DISPLAY_ON
113 || currentState == DisplayState::DISPLAY_DIM) {
114 DisplayManager::GetInstance().SuspendBegin(PowerStateChangeReason::POWER_BUTTON);
115 }
116 break;
117 }
118 case DisplayState::DISPLAY_SUSPEND:
119 dispState = DisplayPowerMgr::DisplayState::DISPLAY_SUSPEND;
120 break;
121 default:
122 break;
123 }
124 dispCallback_->notify_ = actionCallback_;
125 bool ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(dispState, reason);
126 POWER_HILOGI(MODULE_SERVICE, "SetDisplayState: %{public}d", ret);
127 return ret ? ActionResult::SUCCESS : ActionResult::FAILED;
128 }
129
GoToSleep(const std::function<void ()> onSuspend,const std::function<void ()> onWakeup,bool force)130 uint32_t DeviceStateAction::GoToSleep(const std::function<void()> onSuspend,
131 const std::function<void()> onWakeup, bool force)
132 {
133 SystemSuspendController::GetInstance().Suspend(onSuspend, onWakeup, force);
134 return ActionResult::SUCCESS;
135 }
136
RegisterCallback(std::function<void (uint32_t)> & callback)137 void DeviceStateAction::RegisterCallback(std::function<void(uint32_t)>& callback)
138 {
139 actionCallback_ = callback;
140 }
141
OnDisplayStateChanged(uint32_t displayId,DisplayPowerMgr::DisplayState state)142 void DeviceStateAction::DisplayPowerCallback::OnDisplayStateChanged(uint32_t displayId,
143 DisplayPowerMgr::DisplayState state)
144 {
145 POWER_HILOGI(MODULE_SERVICE, "Callback: OnDisplayStateChanged");
146 int32_t mainDisp = DisplayPowerMgrClient::GetInstance().GetMainDisplayId();
147 if (mainDisp < 0 || static_cast<uint32_t>(mainDisp) != displayId) {
148 POWER_HILOGI(MODULE_SERVICE, "It's not main display, skip!");
149 return;
150 }
151 switch (state) {
152 case DisplayPowerMgr::DisplayState::DISPLAY_ON: {
153 DisplayManager::GetInstance().WakeUpEnd();
154 NotifyDisplayActionDone(DISPLAY_ON_DONE);
155 std::string name = LOCK_TAG_DISPLAY_POWER;
156 SystemSuspendController::GetInstance().AcquireRunningLock(name);
157 break;
158 }
159 case DisplayPowerMgr::DisplayState::DISPLAY_OFF: {
160 DisplayManager::GetInstance().SuspendEnd();
161 NotifyDisplayActionDone(DISPLAY_OFF_DONE);
162 std::string name = LOCK_TAG_DISPLAY_POWER;
163 SystemSuspendController::GetInstance().ReleaseRunningLock(name);
164 break;
165 }
166 default:
167 break;
168 }
169 return;
170 }
171
NotifyDisplayActionDone(uint32_t event)172 void DeviceStateAction::DisplayPowerCallback::NotifyDisplayActionDone(uint32_t event)
173 {
174 if (notify_ != nullptr) {
175 notify_(event);
176 }
177 }
178 } // namespace PowerMgr
179 } // namespace OHOS
180