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_EXIT_SYSTEM_STR:
99             return std::string("EXIT_SYSTEM_STR");
100         case StateChangeReason::STATE_CHANGE_REASON_UNKNOWN:
101             return std::string("UNKNOWN");
102         default:
103             break;
104     }
105     return std::string("UNKNOWN");
106 }
107 
GetPowerStateString(PowerState state)108 const std::string PowerUtils::GetPowerStateString(PowerState state)
109 {
110     switch (state) {
111         case PowerState::AWAKE:
112             return std::string("AWAKE");
113         case PowerState::FREEZE:
114             return std::string("FREEZE");
115         case PowerState::INACTIVE:
116             return std::string("INACTIVE");
117         case PowerState::STAND_BY:
118             return std::string("STAND_BY");
119         case PowerState::DOZE:
120             return std::string("DOZE");
121         case PowerState::SLEEP:
122             return std::string("SLEEP");
123         case PowerState::HIBERNATE:
124             return std::string("HIBERNATE");
125         case PowerState::SHUTDOWN:
126             return std::string("SHUTDOWN");
127         case PowerState::DIM:
128             return std::string("DIM");
129         case PowerState::UNKNOWN:
130             return std::string("UNKNOWN");
131         default:
132             break;
133     }
134     return std::string("UNKNOWN");
135 }
136 
GetDisplayStateString(DisplayState state)137 const std::string PowerUtils::GetDisplayStateString(DisplayState state)
138 {
139     switch (state) {
140         case DisplayState::DISPLAY_OFF:
141             return std::string("DISPLAY_OFF");
142         case DisplayState::DISPLAY_DIM:
143             return std::string("DISPLAY_DIM");
144         case DisplayState::DISPLAY_ON:
145             return std::string("DISPLAY_ON");
146         case DisplayState::DISPLAY_SUSPEND:
147             return std::string("DISPLAY_SUSPEND");
148         case DisplayState::DISPLAY_UNKNOWN:
149             return std::string("DISPLAY_UNKNOWN");
150         default:
151             break;
152     }
153     return std::string("DISPLAY_UNKNOWN");
154 }
155 
GetRunningLockTypeString(RunningLockType type)156 const std::string PowerUtils::GetRunningLockTypeString(RunningLockType type)
157 {
158     switch (type) {
159         case RunningLockType::RUNNINGLOCK_SCREEN:
160             return "SCREEN";
161         case RunningLockType::RUNNINGLOCK_BACKGROUND:
162             return "BACKGROUND";
163         case RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL:
164             return "PROXIMITY_SCREEN_CONTROL";
165         case RunningLockType::RUNNINGLOCK_COORDINATION:
166             return "RUNNINGLOCK_COORDINATION";
167         case RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE:
168             return "BACKGROUND_PHONE";
169         case RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION:
170             return "BACKGROUND_NOTIFICATION";
171         case RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO:
172             return "BACKGROUND_AUDIO";
173         case RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT:
174             return "BACKGROUND_SPORT";
175         case RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION:
176             return "BACKGROUND_NAVIGATION";
177         case RunningLockType::RUNNINGLOCK_BACKGROUND_TASK:
178             return "BACKGROUND_TASK";
179         case RunningLockType::RUNNINGLOCK_BUTT:
180             return "BUTT";
181         default:
182             break;
183     }
184     return "UNKNOWN";
185 }
186 
JsonToSimpleStr(const std::string& json)187 const std::string PowerUtils::JsonToSimpleStr(const std::string& json)
188 {
189     std::string str;
190     for (auto ch : json) {
191         if (ch != ' ' && ch != '\n') {
192             str += ch;
193         }
194     }
195     return str;
196 }
197 
IsForegroundApplication(const std::string& appName)198 bool PowerUtils::IsForegroundApplication(const std::string& appName)
199 {
200     void* handler = dlopen("libpower_ability.z.so", RTLD_NOW);
201     if (handler == nullptr) {
202         POWER_HILOGE(FEATURE_UTIL, "dlopen libpower_ability.z.so failed, reason : %{public}s", dlerror());
203         return false;
204     }
205 
206     auto powerIsForegroundApplicationFunc =
207         reinterpret_cast<bool (*)(const std::string&)>(dlsym(handler, "PowerIsForegroundApplication"));
208     if (powerIsForegroundApplicationFunc == nullptr) {
209         POWER_HILOGE(FEATURE_UTIL, "find PowerIsForegroundApplication function failed, reason : %{public}s", dlerror());
210 #ifndef FUZZ_TEST
211         dlclose(handler);
212 #endif
213         handler = nullptr;
214         return false;
215     }
216     bool isForeground = powerIsForegroundApplicationFunc(appName);
217 #ifndef FUZZ_TEST
218     dlclose(handler);
219 #endif
220     handler = nullptr;
221     return isForeground;
222 }
223 } // namespace PowerMgr
224 } // namespace OHOS
225