1 /*
2 * Copyright (c) 2021-2023 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 <ipc_skeleton.h>
19 #include "display_manager.h"
20 #include "display_power_mgr_client.h"
21 #include "power_log.h"
22 #include "power_state_machine_info.h"
23 #include "system_suspend_controller.h"
24
25 using namespace std;
26
27 namespace OHOS {
28 namespace PowerMgr {
29 using namespace DisplayPowerMgr;
30 using namespace Rosen;
31
DeviceStateAction()32 DeviceStateAction::DeviceStateAction()
33 {
34 dispCallback_ = new DisplayPowerCallback();
35 }
36
~DeviceStateAction()37 DeviceStateAction::~DeviceStateAction()
38 {
39 dispCallback_ = nullptr;
40 }
41
Suspend(int64_t callTimeMs,SuspendDeviceType type,uint32_t flags)42 void DeviceStateAction::Suspend(int64_t callTimeMs, SuspendDeviceType type, uint32_t flags)
43 {
44 // Display is controlled by PowerStateMachine
45 // Don't suspend until GoToSleep is called
46 }
47
ForceSuspend()48 void DeviceStateAction::ForceSuspend()
49 {
50 GoToSleep(nullptr, nullptr, true);
51 }
52
Wakeup(int64_t callTimeMs,WakeupDeviceType type,const string & details,const string & pkgName)53 void DeviceStateAction::Wakeup(int64_t callTimeMs, WakeupDeviceType type, const string& details,
54 const string& pkgName)
55 {
56 SystemSuspendController::GetInstance().Wakeup();
57 }
58
GetDisplayState()59 DisplayState DeviceStateAction::GetDisplayState()
60 {
61 DisplayPowerMgr::DisplayState state = DisplayPowerMgrClient::GetInstance().GetDisplayState();
62 POWER_HILOGD(FEATURE_POWER_STATE, "Get display state: %{public}d", state);
63 DisplayState ret = DisplayState::DISPLAY_UNKNOWN;
64 switch (state) {
65 case DisplayPowerMgr::DisplayState::DISPLAY_ON:
66 ret = DisplayState::DISPLAY_ON;
67 break;
68 case DisplayPowerMgr::DisplayState::DISPLAY_DIM:
69 ret = DisplayState::DISPLAY_DIM;
70 break;
71 case DisplayPowerMgr::DisplayState::DISPLAY_OFF:
72 ret = DisplayState::DISPLAY_OFF;
73 break;
74 case DisplayPowerMgr::DisplayState::DISPLAY_SUSPEND:
75 ret = DisplayState::DISPLAY_SUSPEND;
76 break;
77 case DisplayPowerMgr::DisplayState::DISPLAY_UNKNOWN:
78 ret = DisplayState::DISPLAY_UNKNOWN;
79 break;
80 default:
81 break;
82 }
83 return ret;
84 }
85
SetDisplayState(const DisplayState state,StateChangeReason reason)86 uint32_t DeviceStateAction::SetDisplayState(const DisplayState state, StateChangeReason reason)
87 {
88 POWER_HILOGD(FEATURE_POWER_STATE,
89 "Action: SetDisplayState: DisplayState=%{public}d, StateChangeReason=%{public}d, Coordinated=%{public}d",
90 static_cast<uint32_t>(state), static_cast<uint32_t>(reason), coordinated_);
91
92 DisplayState currentState = GetDisplayState();
93 if (state == currentState) {
94 POWER_HILOGD(FEATURE_POWER_STATE, "Already in state: %{public}d", static_cast<uint32_t>(state));
95 return ActionResult::SUCCESS;
96 }
97
98 if (!isRegister_) {
99 isRegister_ = DisplayPowerMgrClient::GetInstance().RegisterCallback(dispCallback_);
100 POWER_HILOGI(FEATURE_POWER_STATE, "Register Callback is %{public}d", isRegister_);
101 }
102
103 DisplayPowerMgr::DisplayState dispState = DisplayPowerMgr::DisplayState::DISPLAY_ON;
104 PowerStateChangeReason dispReason = IsTimedOutWhileCoordinated(reason) ?
105 PowerStateChangeReason::STATE_CHANGE_REASON_COLLABORATION : static_cast<PowerStateChangeReason>(reason);
106 switch (state) {
107 case DisplayState::DISPLAY_ON: {
108 dispState = DisplayPowerMgr::DisplayState::DISPLAY_ON;
109 if (currentState == DisplayState::DISPLAY_OFF) {
110 std::string identity = IPCSkeleton::ResetCallingIdentity();
111 DisplayManager::GetInstance().WakeUpBegin(dispReason);
112 IPCSkeleton::SetCallingIdentity(identity);
113 }
114 break;
115 }
116 case DisplayState::DISPLAY_DIM:
117 dispState = DisplayPowerMgr::DisplayState::DISPLAY_DIM;
118 break;
119 case DisplayState::DISPLAY_OFF: {
120 dispState = DisplayPowerMgr::DisplayState::DISPLAY_OFF;
121 if ((currentState == DisplayState::DISPLAY_ON || currentState == DisplayState::DISPLAY_DIM) &&
122 reason != StateChangeReason::STATE_CHANGE_REASON_SENSOR) {
123 std::string identity = IPCSkeleton::ResetCallingIdentity();
124 DisplayManager::GetInstance().SuspendBegin(dispReason);
125 IPCSkeleton::SetCallingIdentity(identity);
126 }
127 break;
128 }
129 case DisplayState::DISPLAY_SUSPEND:
130 dispState = DisplayPowerMgr::DisplayState::DISPLAY_SUSPEND;
131 break;
132 default:
133 break;
134 }
135 dispCallback_->notify_ = actionCallback_;
136 bool ret = DisplayPowerMgrClient::GetInstance().SetDisplayState(dispState, reason);
137 POWER_HILOGI(FEATURE_POWER_STATE, "Set display state finished, ret=%{public}d", ret);
138 return ret ? ActionResult::SUCCESS : ActionResult::FAILED;
139 }
140
SetCoordinated(bool coordinated)141 void DeviceStateAction::SetCoordinated(bool coordinated)
142 {
143 coordinated_ = coordinated;
144 bool ret = DisplayPowerMgrClient::GetInstance().SetCoordinated(coordinated_);
145 POWER_HILOGI(FEATURE_POWER_STATE, "Set coordinated=%{public}d, ret=%{public}d", coordinated_, ret);
146 }
147
IsTimedOutWhileCoordinated(StateChangeReason reason)148 bool DeviceStateAction::IsTimedOutWhileCoordinated(StateChangeReason reason)
149 {
150 return coordinated_ && reason == StateChangeReason::STATE_CHANGE_REASON_TIMEOUT;
151 }
152
GoToSleep(const std::function<void ()> onSuspend,const std::function<void ()> onWakeup,bool force)153 uint32_t DeviceStateAction::GoToSleep(const std::function<void()> onSuspend,
154 const std::function<void()> onWakeup, bool force)
155 {
156 SystemSuspendController::GetInstance().Suspend(onSuspend, onWakeup, force);
157 return ActionResult::SUCCESS;
158 }
159
RegisterCallback(std::function<void (uint32_t)> & callback)160 void DeviceStateAction::RegisterCallback(std::function<void(uint32_t)>& callback)
161 {
162 actionCallback_ = callback;
163 }
164
OnDisplayStateChanged(uint32_t displayId,DisplayPowerMgr::DisplayState state,uint32_t reason)165 void DeviceStateAction::DisplayPowerCallback::OnDisplayStateChanged(uint32_t displayId,
166 DisplayPowerMgr::DisplayState state, uint32_t reason)
167 {
168 POWER_HILOGD(FEATURE_POWER_STATE, "Callback: OnDisplayStateChanged");
169 int32_t mainDisp = DisplayPowerMgrClient::GetInstance().GetMainDisplayId();
170 if (mainDisp < 0 || static_cast<uint32_t>(mainDisp) != displayId) {
171 POWER_HILOGI(FEATURE_POWER_STATE, "It's not main display, skip!");
172 return;
173 }
174 switch (state) {
175 case DisplayPowerMgr::DisplayState::DISPLAY_ON: {
176 std::string identity = IPCSkeleton::ResetCallingIdentity();
177 DisplayManager::GetInstance().WakeUpEnd();
178 IPCSkeleton::SetCallingIdentity(identity);
179 NotifyDisplayActionDone(DISPLAY_ON_DONE);
180 break;
181 }
182 case DisplayPowerMgr::DisplayState::DISPLAY_OFF: {
183 if (StateChangeReason(reason) != StateChangeReason::STATE_CHANGE_REASON_SENSOR) {
184 std::string identity = IPCSkeleton::ResetCallingIdentity();
185 DisplayManager::GetInstance().SuspendEnd();
186 IPCSkeleton::SetCallingIdentity(identity);
187 }
188 NotifyDisplayActionDone(DISPLAY_OFF_DONE);
189 break;
190 }
191 default:
192 break;
193 }
194 return;
195 }
196
NotifyDisplayActionDone(uint32_t event)197 void DeviceStateAction::DisplayPowerCallback::NotifyDisplayActionDone(uint32_t event)
198 {
199 std::lock_guard lock(notifyMutex_);
200 if (notify_ != nullptr) {
201 notify_(event);
202 }
203 }
204 } // namespace PowerMgr
205 } // namespace OHOS
206