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 "screen_action.h"
17 #include <datetime_ex.h>
18 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
19 #include <hisysevent.h>
20 #endif
21 #include <ipc_skeleton.h>
22
23 #include "display_log.h"
24 #include "power_state_machine_info.h"
25 #include "screen_manager_lite.h"
26
27 namespace OHOS {
28 namespace DisplayPowerMgr {
ScreenAction(uint32_t displayId)29 ScreenAction::ScreenAction(uint32_t displayId) : displayId_(displayId)
30 {}
31
GetDefaultDisplayId()32 uint32_t ScreenAction::GetDefaultDisplayId()
33 {
34 std::string identity = IPCSkeleton::ResetCallingIdentity();
35 uint64_t defaultId = Rosen::DisplayManagerLite::GetInstance().GetDefaultDisplayId();
36 IPCSkeleton::SetCallingIdentity(identity);
37 return static_cast<uint32_t>(defaultId);
38 }
39
GetAllDisplayId()40 std::vector<uint32_t> ScreenAction::GetAllDisplayId()
41 {
42 std::string identity = IPCSkeleton::ResetCallingIdentity();
43 std::vector<uint64_t> allIds = Rosen::DisplayManagerLite::GetInstance().GetAllDisplayIds();
44 IPCSkeleton::SetCallingIdentity(identity);
45 std::vector<uint32_t> displayIds;
46 std::transform(allIds.begin(), allIds.end(), back_inserter(displayIds), [](uint64_t id) {
47 return static_cast<uint32_t>(id);
48 });
49 return displayIds;
50 }
51
GetDisplayId()52 uint32_t ScreenAction::GetDisplayId()
53 {
54 return displayId_;
55 }
56
GetDisplayState()57 DisplayState ScreenAction::GetDisplayState()
58 {
59 DisplayState state = DisplayState::DISPLAY_UNKNOWN;
60 Rosen::ScreenPowerState powerState = Rosen::ScreenManagerLite::GetInstance().GetScreenPower(displayId_);
61 DISPLAY_HILOGI(FEAT_STATE, "ScreenPowerState=%{public}d", static_cast<uint32_t>(powerState));
62 switch (powerState) {
63 case Rosen::ScreenPowerState::POWER_ON:
64 state = DisplayState::DISPLAY_ON;
65 break;
66 case Rosen::ScreenPowerState::POWER_STAND_BY:
67 state = DisplayState::DISPLAY_DIM;
68 break;
69 case Rosen::ScreenPowerState::POWER_SUSPEND:
70 state = DisplayState::DISPLAY_SUSPEND;
71 break;
72 case Rosen::ScreenPowerState::POWER_OFF:
73 state = DisplayState::DISPLAY_OFF;
74 break;
75 default:
76 break;
77 }
78 DISPLAY_HILOGI(FEAT_STATE, "state=%{public}u displayId=%{public}u", static_cast<uint32_t>(state), displayId_);
79 return state;
80 }
81
EnableSkipSetDisplayState(uint32_t reason)82 bool ScreenAction::EnableSkipSetDisplayState(uint32_t reason)
83 {
84 if (reason == static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS)) {
85 return true;
86 }
87 return false;
88 }
89
ParseDisplayState(DisplayState state)90 Rosen::DisplayState ScreenAction::ParseDisplayState(DisplayState state)
91 {
92 Rosen::DisplayState ret = Rosen::DisplayState::UNKNOWN;
93 switch (state) {
94 case DisplayState::DISPLAY_ON:
95 ret = Rosen::DisplayState::ON;
96 break;
97 case DisplayState::DISPLAY_OFF:
98 ret = Rosen::DisplayState::OFF;
99 break;
100 case DisplayState::DISPLAY_DOZE:
101 ret = Rosen::DisplayState::DOZE;
102 break;
103 case DisplayState::DISPLAY_DOZE_SUSPEND:
104 ret = Rosen::DisplayState::DOZE_SUSPEND;
105 break;
106 default:
107 ret = Rosen::DisplayState::UNKNOWN;
108 break;
109 }
110 return ret;
111 }
112
WriteHiSysEvent(DisplayState state,int32_t beginTimeMs)113 void ScreenAction::WriteHiSysEvent(DisplayState state, int32_t beginTimeMs)
114 {
115 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
116 constexpr int32_t DMS_WAIT_LOCKSCREENON_TIMEOUT = 300;
117 constexpr int32_t DMS_WAIT_LOCKSCREENOFF_TIMEOUT = 2000;
118 constexpr int32_t DMS_WAIT_LOCKSCREENON_TYPE = 0;
119 constexpr int32_t DMS_WAIT_LOCKSCREENOFF_TYPE = 1;
120 int32_t endTimeMs = GetTickCount();
121 if ((endTimeMs - beginTimeMs > DMS_WAIT_LOCKSCREENON_TIMEOUT) && state == DisplayState::DISPLAY_ON) {
122 DISPLAY_HILOGI(FEAT_STATE, "dms wait lockscreenon timeout=%{public}d", (endTimeMs - beginTimeMs));
123 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::DISPLAY, "DMS_WAIT_LOCKSCREEN_TIMEOUT",
124 HiviewDFX::HiSysEvent::EventType::BEHAVIOR, "TYPE", DMS_WAIT_LOCKSCREENON_TYPE,
125 "TIME", (endTimeMs - beginTimeMs));
126 } else if ((endTimeMs - beginTimeMs > DMS_WAIT_LOCKSCREENOFF_TIMEOUT) && state == DisplayState::DISPLAY_OFF) {
127 DISPLAY_HILOGI(FEAT_STATE, "dms wait lockscreenoff timeout=%{public}d", (endTimeMs - beginTimeMs));
128 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::DISPLAY, "DMS_WAIT_LOCKSCREEN_TIMEOUT",
129 HiviewDFX::HiSysEvent::EventType::BEHAVIOR, "TYPE", DMS_WAIT_LOCKSCREENOFF_TYPE,
130 "TIME", (endTimeMs - beginTimeMs));
131 }
132 #endif
133 }
134
SetDisplayState(DisplayState state,const std::function<void (DisplayState)> & callback)135 bool ScreenAction::SetDisplayState(DisplayState state, const std::function<void(DisplayState)>& callback)
136 {
137 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
138 int32_t beginTimeMs = GetTickCount();
139 #endif
140 DISPLAY_HILOGI(FEAT_STATE, "[UL_POWER] SetDisplayState displayId=%{public}u, state=%{public}u", displayId_,
141 static_cast<uint32_t>(state));
142 Rosen::DisplayState rds = ParseDisplayState(state);
143 std::string identity = IPCSkeleton::ResetCallingIdentity();
144 bool ret = Rosen::DisplayManagerLite::GetInstance().SetDisplayState(rds,
145 [callback](Rosen::DisplayState rosenState) {
146 DISPLAY_HILOGI(FEAT_STATE, "[UL_POWER] SetDisplayState Callback:%{public}d", static_cast<uint32_t>(rosenState));
147 DisplayState state;
148 switch (rosenState) {
149 case Rosen::DisplayState::ON:
150 state = DisplayState::DISPLAY_ON;
151 break;
152 case Rosen::DisplayState::OFF:
153 state = DisplayState::DISPLAY_OFF;
154 break;
155 case Rosen::DisplayState::ON_SUSPEND:
156 state = DisplayState::DISPLAY_SUSPEND;
157 break;
158 case Rosen::DisplayState::DOZE:
159 state = DisplayState::DISPLAY_DOZE;
160 break;
161 case Rosen::DisplayState::DOZE_SUSPEND:
162 state = DisplayState::DISPLAY_DOZE_SUSPEND;
163 break;
164 default:
165 return;
166 }
167 callback(state);
168 });
169 WriteHiSysEvent(state, beginTimeMs);
170 IPCSkeleton::SetCallingIdentity(identity);
171 // Notify screen state change event to battery statistics
172 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
173 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::DISPLAY, "SCREEN_STATE",
174 HiviewDFX::HiSysEvent::EventType::STATISTIC, "STATE", static_cast<int32_t>(state));
175 #endif
176 DISPLAY_HILOGI(FEAT_STATE, "[UL_POWER] SetDisplayState: displayId=%{public}u, state=%{public}u, ret=%{public}d",
177 displayId_, static_cast<uint32_t>(state), ret);
178 return ret;
179 }
180
ParseSpecialReason(uint32_t reason)181 Rosen::PowerStateChangeReason ScreenAction::ParseSpecialReason(uint32_t reason)
182 {
183 auto changeReason = Rosen::PowerStateChangeReason::POWER_BUTTON;
184 switch (reason) {
185 case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT):
186 changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT;
187 break;
188 case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON):
189 changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON;
190 break;
191 case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS):
192 changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS;
193 break;
194 case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF):
195 changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF;
196 break;
197 case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_SWITCH):
198 changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_SWITCH;
199 break;
200 case static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_POWER_KEY):
201 changeReason = Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
202 break;
203 default:
204 break;
205 }
206 return changeReason;
207 }
208
SetDisplayPower(DisplayState state,uint32_t reason)209 bool ScreenAction::SetDisplayPower(DisplayState state, uint32_t reason)
210 {
211 DISPLAY_HILOGI(FEAT_STATE, "[UL_POWER] SetDisplayPower displayId=%{public}u, state=%{public}u, reason=%{public}u",
212 displayId_, static_cast<uint32_t>(state), reason);
213 Rosen::ScreenPowerState status = Rosen::ScreenPowerState::INVALID_STATE;
214 switch (state) {
215 case DisplayState::DISPLAY_ON:
216 status = Rosen::ScreenPowerState::POWER_ON;
217 break;
218 case DisplayState::DISPLAY_DIM:
219 status = Rosen::ScreenPowerState::POWER_STAND_BY;
220 break;
221 case DisplayState::DISPLAY_SUSPEND:
222 status = Rosen::ScreenPowerState::POWER_SUSPEND;
223 break;
224 case DisplayState::DISPLAY_OFF:
225 status = Rosen::ScreenPowerState::POWER_OFF;
226 break;
227 case DisplayState::DISPLAY_DOZE:
228 status = Rosen::ScreenPowerState::POWER_DOZE;
229 break;
230 case DisplayState::DISPLAY_DOZE_SUSPEND:
231 status = Rosen::ScreenPowerState::POWER_DOZE_SUSPEND;
232 break;
233 default:
234 break;
235 }
236
237 bool ret = false;
238 auto changeReason = ParseSpecialReason(reason);
239 if (coordinated_ && reason == static_cast<uint32_t>(PowerMgr::StateChangeReason::STATE_CHANGE_REASON_TIMEOUT)) {
240 ret = Rosen::ScreenManagerLite::GetInstance().SetSpecifiedScreenPower(
241 displayId_, status, Rosen::PowerStateChangeReason::STATE_CHANGE_REASON_COLLABORATION);
242 } else {
243 ret = Rosen::ScreenManagerLite::GetInstance().SetScreenPowerForAll(status, changeReason);
244 }
245 DISPLAY_HILOGI(FEAT_STATE,
246 "[UL_POWER] SetDisplayPower state=%{public}u, reason=%{public}u, ret=%{public}d, coordinated=%{public}d",
247 static_cast<uint32_t>(state), reason, ret, coordinated_);
248 return (state == DisplayState::DISPLAY_DIM || state == DisplayState::DISPLAY_SUSPEND) ? true : ret;
249 }
250
GetBrightness()251 uint32_t ScreenAction::GetBrightness()
252 {
253 std::lock_guard lock(mutexBrightness_);
254 std::string identity = IPCSkeleton::ResetCallingIdentity();
255 brightness_ = Rosen::DisplayManagerLite::GetInstance().GetScreenBrightness(displayId_);
256 IPCSkeleton::SetCallingIdentity(identity);
257 DISPLAY_HILOGD(FEAT_BRIGHTNESS, "displayId=%{public}u, brightness=%{public}u", displayId_, brightness_);
258 return brightness_;
259 }
260
SetBrightness(uint32_t value)261 bool ScreenAction::SetBrightness(uint32_t value)
262 {
263 DISPLAY_HILOGI(FEAT_BRIGHTNESS, "SetBrightness displayId=%{public}u, brightness=%{public}u", displayId_, value);
264 std::string identity = IPCSkeleton::ResetCallingIdentity();
265 bool isSucc = Rosen::DisplayManagerLite::GetInstance().SetScreenBrightness(displayId_, value);
266 IPCSkeleton::SetCallingIdentity(identity);
267 std::lock_guard lock(mutexBrightness_);
268 brightness_ = isSucc ? value : brightness_;
269 return isSucc;
270 }
271
SetCoordinated(bool coordinated)272 void ScreenAction::SetCoordinated(bool coordinated)
273 {
274 coordinated_ = coordinated;
275 }
276 } // namespace DisplayPowerMgr
277 } // namespace OHOS
278