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