1 /*
2 * Copyright (c) 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 <dlfcn.h>
17 #include <string>
18 #include "power_log.h"
19 #include "power_utils.h"
20
21 namespace OHOS {
22 namespace PowerMgr {
GetReasonTypeString(StateChangeReason type)23 const std::string PowerUtils::GetReasonTypeString(StateChangeReason type)
24 {
25 switch (type) {
26 case StateChangeReason::STATE_CHANGE_REASON_INIT:
27 return std::string("INIT");
28 case StateChangeReason::STATE_CHANGE_REASON_TIMEOUT:
29 return std::string("TIMEOUT");
30 case StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK:
31 return std::string("RUNNING_LOCK");
32 case StateChangeReason::STATE_CHANGE_REASON_BATTERY:
33 return std::string("BATTERY");
34 case StateChangeReason::STATE_CHANGE_REASON_THERMAL:
35 return std::string("THERMAL");
36 case StateChangeReason::STATE_CHANGE_REASON_WORK:
37 return std::string("WORK");
38 case StateChangeReason::STATE_CHANGE_REASON_SYSTEM:
39 return std::string("SYSTEM");
40 case StateChangeReason::STATE_CHANGE_REASON_APPLICATION:
41 return std::string("APPLICATION");
42 case StateChangeReason::STATE_CHANGE_REASON_SETTINGS:
43 return std::string("SETTINGS");
44 case StateChangeReason::STATE_CHANGE_REASON_HARD_KEY:
45 return std::string("HARD_KEY");
46 case StateChangeReason::STATE_CHANGE_REASON_TOUCH:
47 return std::string("TOUCH");
48 case StateChangeReason::STATE_CHANGE_REASON_CABLE:
49 return std::string("CABLE");
50 case StateChangeReason::STATE_CHANGE_REASON_SENSOR:
51 return std::string("SENSOR");
52 case StateChangeReason::STATE_CHANGE_REASON_LID:
53 return std::string("LID");
54 case StateChangeReason::STATE_CHANGE_REASON_CAMERA:
55 return std::string("CAMERA");
56 case StateChangeReason::STATE_CHANGE_REASON_ACCESSIBILITY:
57 return std::string("ACCESS");
58 case StateChangeReason::STATE_CHANGE_REASON_RESET:
59 return std::string("RESET");
60 case StateChangeReason::STATE_CHANGE_REASON_POWER_KEY:
61 return std::string("POWER_KEY");
62 case StateChangeReason::STATE_CHANGE_REASON_KEYBOARD:
63 return std::string("KEYBOARD");
64 case StateChangeReason::STATE_CHANGE_REASON_MOUSE:
65 return std::string("MOUSE");
66 case StateChangeReason::STATE_CHANGE_REASON_DOUBLE_CLICK:
67 return std::string("DOUBLE_CLICK");
68 case StateChangeReason::STATE_CHANGE_REASON_PEN:
69 return std::string("PEN");
70 case StateChangeReason::STATE_CHANGE_REASON_SWITCH:
71 return std::string("SWITCH");
72 case StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT:
73 return std::string("PRE_BRIGHT");
74 case StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS:
75 return std::string("PRE_BRIGHT_ATUH_SUCCESS");
76 case StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON:
77 return std::string("PRE_BRIGHT_ATUH_FAIL_SCREEN_ON");
78 case StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF:
79 return std::string("PRE_BRIGHT_ATUH_FAIL_SCREEN_OFF");
80 case StateChangeReason::STATE_CHANGE_REASON_AOD_SLIDING:
81 return std::string("AOD_SLIDING");
82 case StateChangeReason::STATE_CHANGE_REASON_REMOTE:
83 return std::string("REMOTE");
84 case StateChangeReason::STATE_CHANGE_REASON_REFRESH:
85 return std::string("REFRESH");
86 case StateChangeReason::STATE_CHANGE_REASON_COORDINATION:
87 return std::string("COORDINATION_OVERRIDE");
88 case StateChangeReason::STATE_CHANGE_REASON_PROXIMITY:
89 return std::string("PROXIMITY");
90 case StateChangeReason::STATE_CHANGE_REASON_INCOMING_CALL:
91 return std::string("INCOMING_CALL");
92 case StateChangeReason::STATE_CHANGE_REASON_SHELL:
93 return std::string("SHELL");
94 case StateChangeReason::STATE_CHANGE_REASON_TIMEOUT_NO_SCREEN_LOCK:
95 return std::string("TIMEOUT_NO_SCREEN_LOCK");
96 case StateChangeReason::STATE_CHANGE_REASON_PICKUP:
97 return std::string("PICKUP");
98 case StateChangeReason::STATE_CHANGE_REASON_SCREEN_CONNECT:
99 return std::string("SCREEN_CONNECT");
100 case StateChangeReason::STATE_CHANGE_REASON_EXIT_SYSTEM_STR:
101 return std::string("EXIT_SYSTEM_STR");
102 case StateChangeReason::STATE_CHANGE_REASON_TP_TOUCH:
103 return std::string("TP_TOUCH");
104 case StateChangeReason::STATE_CHANGE_REASON_TP_COVER:
105 return std::string("TP_COVER");
106 case StateChangeReason::STATE_CHANGE_REASON_EX_SCREEN_INIT:
107 return std::string("EX_SCREEN_INIT");
108 case StateChangeReason::STATE_CHANGE_REASON_ABNORMAL_SCREEN_CONNECT:
109 return std::string("ABNORMAL_SCREEN_CONNECT");
110 case StateChangeReason::STATE_CHANGE_REASON_ROLLBACK_HIBERNATE:
111 return std::string("ROLLBACK_HIBERNATE");
112 case StateChangeReason::STATE_CHANGE_REASON_PLUG_CHANGE:
113 return std::string("PLUG_CHANGE");
114 case StateChangeReason::STATE_CHANGE_REASON_UNKNOWN:
115 return std::string("UNKNOWN");
116 default:
117 break;
118 }
119 return std::string("UNKNOWN");
120 }
121
GetPowerStateString(PowerState state)122 const std::string PowerUtils::GetPowerStateString(PowerState state)
123 {
124 switch (state) {
125 case PowerState::AWAKE:
126 return std::string("AWAKE");
127 case PowerState::FREEZE:
128 return std::string("FREEZE");
129 case PowerState::INACTIVE:
130 return std::string("INACTIVE");
131 case PowerState::STAND_BY:
132 return std::string("STAND_BY");
133 case PowerState::DOZE:
134 return std::string("DOZE");
135 case PowerState::SLEEP:
136 return std::string("SLEEP");
137 case PowerState::HIBERNATE:
138 return std::string("HIBERNATE");
139 case PowerState::SHUTDOWN:
140 return std::string("SHUTDOWN");
141 case PowerState::DIM:
142 return std::string("DIM");
143 case PowerState::UNKNOWN:
144 return std::string("UNKNOWN");
145 default:
146 break;
147 }
148 return std::string("UNKNOWN");
149 }
150
GetDisplayStateString(DisplayState state)151 const std::string PowerUtils::GetDisplayStateString(DisplayState state)
152 {
153 switch (state) {
154 case DisplayState::DISPLAY_OFF:
155 return std::string("DISPLAY_OFF");
156 case DisplayState::DISPLAY_DIM:
157 return std::string("DISPLAY_DIM");
158 case DisplayState::DISPLAY_ON:
159 return std::string("DISPLAY_ON");
160 case DisplayState::DISPLAY_SUSPEND:
161 return std::string("DISPLAY_SUSPEND");
162 case DisplayState::DISPLAY_UNKNOWN:
163 return std::string("DISPLAY_UNKNOWN");
164 default:
165 break;
166 }
167 return std::string("DISPLAY_UNKNOWN");
168 }
169
GetRunningLockTypeString(RunningLockType type)170 const std::string PowerUtils::GetRunningLockTypeString(RunningLockType type)
171 {
172 switch (type) {
173 case RunningLockType::RUNNINGLOCK_SCREEN:
174 return "SCREEN";
175 case RunningLockType::RUNNINGLOCK_BACKGROUND:
176 return "BACKGROUND";
177 case RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL:
178 return "PROXIMITY_SCREEN_CONTROL";
179 case RunningLockType::RUNNINGLOCK_COORDINATION:
180 return "RUNNINGLOCK_COORDINATION";
181 case RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE:
182 return "BACKGROUND_PHONE";
183 case RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION:
184 return "BACKGROUND_NOTIFICATION";
185 case RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO:
186 return "BACKGROUND_AUDIO";
187 case RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT:
188 return "BACKGROUND_SPORT";
189 case RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION:
190 return "BACKGROUND_NAVIGATION";
191 case RunningLockType::RUNNINGLOCK_BACKGROUND_TASK:
192 return "BACKGROUND_TASK";
193 case RunningLockType::RUNNINGLOCK_BUTT:
194 return "BUTT";
195 default:
196 break;
197 }
198 return "UNKNOWN";
199 }
200
GetDmsReasonByPowerReason(StateChangeReason reason)201 Rosen::PowerStateChangeReason PowerUtils::GetDmsReasonByPowerReason(StateChangeReason reason)
202 {
203 using namespace Rosen;
204 PowerStateChangeReason dmsReason = static_cast<PowerStateChangeReason>(reason);
205 switch (reason) {
206 case StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT:
207 dmsReason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT;
208 break;
209 case StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS:
210 dmsReason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS;
211 break;
212 case StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON:
213 dmsReason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON;
214 break;
215 case StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF:
216 dmsReason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF;
217 break;
218 case StateChangeReason::STATE_CHANGE_REASON_POWER_KEY:
219 dmsReason = PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
220 break;
221 case StateChangeReason::STATE_CHANGE_REASON_TIMEOUT_NO_SCREEN_LOCK:
222 dmsReason = PowerStateChangeReason::STATE_CHANGE_REASON_COLLABORATION;
223 break;
224 case StateChangeReason::STATE_CHANGE_REASON_SWITCH:
225 dmsReason = PowerStateChangeReason::STATE_CHANGE_REASON_SWITCH;
226 break;
227 case StateChangeReason::STATE_CHANGE_REASON_SCREEN_CONNECT:
228 dmsReason = PowerStateChangeReason::STATE_CHANGE_REASON_SCREEN_CONNECT;
229 break;
230 case StateChangeReason::STATE_CHANGE_REASON_EX_SCREEN_INIT:
231 dmsReason = PowerStateChangeReason::STATE_CHANGE_REASON_EX_SCREEN_INIT;
232 break;
233 case StateChangeReason::STATE_CHANGE_REASON_HIBERNATE:
234 dmsReason = PowerStateChangeReason::STATE_CHANGE_REASON_HIBERNATE;
235 break;
236 case StateChangeReason::STATE_CHANGE_REASON_ABNORMAL_SCREEN_CONNECT:
237 dmsReason = PowerStateChangeReason::STATE_CHANGE_REASON_ABNORMAL_SCREEN_CONNECT;
238 break;
239 case StateChangeReason::STATE_CHANGE_REASON_ROLLBACK_HIBERNATE:
240 dmsReason = PowerStateChangeReason::STATE_CHANGE_REASON_ROLLBACK_HIBERNATE;
241 break;
242 default:
243 break;
244 }
245 POWER_HILOGI(FEATURE_POWER_STATE, "The reason to DMS is = %{public}d", static_cast<uint32_t>(dmsReason));
246 return dmsReason;
247 }
248
GetReasonByUserActivity(UserActivityType type)249 StateChangeReason PowerUtils::GetReasonByUserActivity(UserActivityType type)
250 {
251 StateChangeReason ret = StateChangeReason::STATE_CHANGE_REASON_UNKNOWN;
252 switch (type) {
253 case UserActivityType::USER_ACTIVITY_TYPE_BUTTON:
254 ret = StateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
255 break;
256 case UserActivityType::USER_ACTIVITY_TYPE_TOUCH:
257 ret = StateChangeReason::STATE_CHANGE_REASON_TOUCH;
258 break;
259 case UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY:
260 ret = StateChangeReason::STATE_CHANGE_REASON_ACCESSIBILITY;
261 break;
262 case UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE:
263 ret = StateChangeReason::STATE_CHANGE_REASON_APPLICATION;
264 break;
265 case UserActivityType::USER_ACTIVITY_TYPE_SWITCH:
266 ret = StateChangeReason::STATE_CHANGE_REASON_SWITCH;
267 break;
268 case UserActivityType::USER_ACTIVITY_TYPE_CABLE:
269 ret = StateChangeReason::STATE_CHANGE_REASON_CABLE;
270 break;
271 case UserActivityType::USER_ACTIVITY_TYPE_ATTENTION: // fall through
272 case UserActivityType::USER_ACTIVITY_TYPE_OTHER: // fall through
273 default:
274 break;
275 }
276 return ret;
277 }
278
ParseWakeupDeviceType(const std::string & details)279 WakeupDeviceType PowerUtils::ParseWakeupDeviceType(const std::string& details)
280 {
281 WakeupDeviceType parsedType = WakeupDeviceType::WAKEUP_DEVICE_APPLICATION;
282
283 if (strcmp(details.c_str(), "pre_bright") == 0) {
284 parsedType = WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT;
285 } else if (strcmp(details.c_str(), "pre_bright_auth_success") == 0) {
286 parsedType = WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_SUCCESS;
287 } else if (strcmp(details.c_str(), "pre_bright_auth_fail_screen_on") == 0) {
288 parsedType = WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON;
289 } else if (strcmp(details.c_str(), "pre_bright_auth_fail_screen_off") == 0) {
290 parsedType = WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF;
291 } else if (strcmp(details.c_str(), "incoming call") == 0) {
292 parsedType = WakeupDeviceType::WAKEUP_DEVICE_INCOMING_CALL;
293 } else if (strcmp(details.c_str(), "fake_str_check_unlock") == 0) {
294 parsedType = WakeupDeviceType::WAKEUP_DEVICE_EXIT_SYSTEM_STR;
295 } else if (strcmp(details.c_str(), "shell") == 0) {
296 parsedType = WakeupDeviceType::WAKEUP_DEVICE_SHELL;
297 }
298
299 if (parsedType != WakeupDeviceType::WAKEUP_DEVICE_APPLICATION) {
300 POWER_HILOGI(FEATURE_WAKEUP, "Parsed wakeup type is %{public}d", static_cast<uint32_t>(parsedType));
301 }
302 return parsedType;
303 }
304
JsonToSimpleStr(const std::string & json)305 const std::string PowerUtils::JsonToSimpleStr(const std::string& json)
306 {
307 std::string str;
308 for (auto ch : json) {
309 if (ch != ' ' && ch != '\n') {
310 str += ch;
311 }
312 }
313 return str;
314 }
315
IsForegroundApplication(const std::string & appName)316 bool PowerUtils::IsForegroundApplication(const std::string& appName)
317 {
318 void* handler = dlopen("libpower_ability.z.so", RTLD_NOW | RTLD_NODELETE);
319 if (handler == nullptr) {
320 POWER_HILOGE(FEATURE_UTIL, "dlopen libpower_ability.z.so failed, reason : %{public}s", dlerror());
321 return false;
322 }
323
324 auto powerIsForegroundApplicationFunc =
325 reinterpret_cast<bool (*)(const std::string&)>(dlsym(handler, "PowerIsForegroundApplication"));
326 if (powerIsForegroundApplicationFunc == nullptr) {
327 POWER_HILOGE(FEATURE_UTIL, "find PowerIsForegroundApplication function failed, reason : %{public}s", dlerror());
328 #ifndef FUZZ_TEST
329 dlclose(handler);
330 #endif
331 handler = nullptr;
332 return false;
333 }
334 bool isForeground = powerIsForegroundApplicationFunc(appName);
335 #ifndef FUZZ_TEST
336 dlclose(handler);
337 #endif
338 handler = nullptr;
339 return isForeground;
340 }
341 } // namespace PowerMgr
342 } // namespace OHOS
343