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 "battery_stats_listener.h"
17
18 #include <string>
19 #include <strstream>
20
21 #ifdef HAS_BATTERYSTATS_BLUETOOTH_PART
22 #include "bluetooth_def.h"
23 #endif
24
25 #ifdef HAS_BATTERYSTATS_CALL_MANAGER_PART
26 #include "call_manager_inner_type.h"
27 #endif
28
29 #ifdef HAS_BATTERYSTATS_DISPLAY_MANAGER_PART
30 #include "display_power_info.h"
31 #endif
32
33 #ifdef HAS_BATTERYSTATS_WIFI_PART
34 #include "wifi_msg.h"
35 #endif
36
37 #include "battery_stats_service.h"
38 #include "stats_cjson_utils.h"
39 #include "stats_hisysevent.h"
40 #include "stats_log.h"
41 #include "stats_types.h"
42
43 namespace OHOS {
44 namespace PowerMgr {
45 namespace {
46 constexpr int32_t THERMAL_RATIO_BEGIN = 0;
47 constexpr int32_t THERMAL_RATIO_LENGTH = 4;
48 }
OnEvent(std::shared_ptr<HiviewDFX::HiSysEventRecord> sysEvent)49 void BatteryStatsListener::OnEvent(std::shared_ptr<HiviewDFX::HiSysEventRecord> sysEvent)
50 {
51 if (sysEvent == nullptr) {
52 return;
53 }
54 std::string eventName = sysEvent->GetEventName();
55 std::string eventDetail = sysEvent->AsJson();
56 STATS_HILOGD(COMP_SVC, "EventDetail: %{public}s", eventDetail.c_str());
57 if (!StatsHiSysEvent::CheckHiSysEvent(eventName)) {
58 return;
59 }
60
61 cJSON* root = cJSON_Parse(eventDetail.c_str());
62 if (root != nullptr) {
63 if (!cJSON_IsObject(root)) {
64 STATS_HILOGD(COMP_SVC, "json root is not an object");
65 cJSON_Delete(root);
66 return;
67 }
68 ProcessHiSysEvent(eventName, root);
69 cJSON_Delete(root);
70 } else {
71 STATS_HILOGW(COMP_SVC, "Parse hisysevent data failed");
72 }
73 }
74
ProcessHiSysEvent(const std::string & eventName,const cJSON * root)75 void BatteryStatsListener::ProcessHiSysEvent(const std::string& eventName, const cJSON* root)
76 {
77 auto statsService = BatteryStatsService::GetInstance();
78 auto detector = statsService->GetBatteryStatsDetector();
79 StatsUtils::StatsData data;
80 data.eventDebugInfo.clear();
81 if (eventName == StatsHiSysEvent::POWER_RUNNINGLOCK) {
82 ProcessWakelockEvent(data, root);
83 } else if (eventName == StatsHiSysEvent::SCREEN_STATE || eventName == StatsHiSysEvent::BRIGHTNESS_NIT ||
84 eventName == StatsHiSysEvent::BACKLIGHT_DISCOUNT || eventName == StatsHiSysEvent::AMBIENT_LIGHT) {
85 ProcessDisplayEvent(data, root, eventName);
86 } else if (eventName == StatsHiSysEvent::BATTERY_CHANGED) {
87 ProcessBatteryEvent(data, root);
88 } else if (eventName == StatsHiSysEvent::POWER_TEMPERATURE ||
89 eventName == StatsHiSysEvent::THERMAL_LEVEL_CHANGED ||
90 eventName == StatsHiSysEvent::THERMAL_ACTION_TRIGGERED) {
91 ProcessThermalEvent(data, root);
92 } else if (eventName == StatsHiSysEvent::POWER_WORKSCHEDULER || eventName == StatsHiSysEvent::WORK_ADD ||
93 eventName == StatsHiSysEvent::WORK_REMOVE || eventName == StatsHiSysEvent::WORK_START ||
94 eventName == StatsHiSysEvent::WORK_STOP) {
95 ProcessWorkschedulerEvent(data, root);
96 } else if (eventName == StatsHiSysEvent::CALL_STATE || eventName == StatsHiSysEvent::DATA_CONNECTION_STATE) {
97 ProcessPhoneEvent(data, root, eventName);
98 } else {
99 ProcessHiSysEventInternal(data, eventName, root);
100 }
101 detector->HandleStatsChangedEvent(data);
102 }
103
ProcessHiSysEventInternal(StatsUtils::StatsData & data,const std::string & eventName,const cJSON * root)104 void BatteryStatsListener::ProcessHiSysEventInternal(StatsUtils::StatsData& data,
105 const std::string& eventName, const cJSON* root)
106 {
107 if (eventName == StatsHiSysEvent::TORCH_STATE) {
108 ProcessFlashlightEvent(data, root);
109 } else if (eventName == StatsHiSysEvent::CAMERA_CONNECT || eventName == StatsHiSysEvent::CAMERA_DISCONNECT ||
110 eventName == StatsHiSysEvent::FLASHLIGHT_ON || eventName == StatsHiSysEvent::FLASHLIGHT_OFF) {
111 ProcessCameraEvent(data, root, eventName);
112 } else if (eventName == StatsHiSysEvent::STREAM_CHANGE) {
113 ProcessAudioEvent(data, root);
114 } else if (eventName == StatsHiSysEvent::POWER_SENSOR_GRAVITY ||
115 eventName == StatsHiSysEvent::POWER_SENSOR_PROXIMITY) {
116 ProcessSensorEvent(data, root, eventName);
117 } else if (eventName == StatsHiSysEvent::GNSS_STATE) {
118 ProcessGnssEvent(data, root);
119 } else if (eventName == StatsHiSysEvent::BR_SWITCH_STATE || eventName == StatsHiSysEvent::DISCOVERY_STATE ||
120 eventName == StatsHiSysEvent::BLE_SWITCH_STATE || eventName == StatsHiSysEvent::BLE_SCAN_START ||
121 eventName == StatsHiSysEvent::BLE_SCAN_STOP) {
122 ProcessBluetoothEvent(data, root, eventName);
123 } else if (eventName == StatsHiSysEvent::WIFI_CONNECTION || eventName == StatsHiSysEvent::WIFI_SCAN) {
124 ProcessWifiEvent(data, root, eventName);
125 } else if (eventName == StatsHiSysEvent::START_REMOTE_ABILITY) {
126 ProcessDistributedSchedulerEvent(data, root);
127 } else if (eventName == StatsHiSysEvent::MISC_TIME_STATISTIC_REPORT) {
128 ProcessAlarmEvent(data, root);
129 }
130 }
131
ProcessCameraEvent(StatsUtils::StatsData & data,const cJSON * root,const std::string & eventName)132 void BatteryStatsListener::ProcessCameraEvent(StatsUtils::StatsData& data, const cJSON* root,
133 const std::string& eventName)
134 {
135 if (eventName == StatsHiSysEvent::CAMERA_CONNECT || eventName == StatsHiSysEvent::CAMERA_DISCONNECT) {
136 data.type = StatsUtils::STATS_TYPE_CAMERA_ON;
137 cJSON* uidItem = cJSON_GetObjectItemCaseSensitive(root, "UID");
138 if (StatsJsonUtils::IsValidJsonNumber(uidItem)) {
139 data.uid = static_cast<int32_t>(uidItem->valueint);
140 }
141
142 cJSON* pidItem = cJSON_GetObjectItemCaseSensitive(root, "PID");
143 if (StatsJsonUtils::IsValidJsonNumber(pidItem)) {
144 data.pid = static_cast<int32_t>(pidItem->valueint);
145 }
146
147 cJSON* idItem = cJSON_GetObjectItemCaseSensitive(root, "ID");
148 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(idItem)) {
149 data.deviceId = idItem->valuestring;
150 }
151
152 if (eventName == StatsHiSysEvent::CAMERA_CONNECT) {
153 data.state = StatsUtils::STATS_STATE_ACTIVATED;
154 } else {
155 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
156 }
157 } else if (eventName == StatsHiSysEvent::FLASHLIGHT_ON || eventName == StatsHiSysEvent::FLASHLIGHT_OFF) {
158 data.type = StatsUtils::STATS_TYPE_CAMERA_FLASHLIGHT_ON;
159 if (eventName == StatsHiSysEvent::FLASHLIGHT_ON) {
160 data.state = StatsUtils::STATS_STATE_ACTIVATED;
161 } else {
162 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
163 }
164 }
165 }
166
ProcessAudioEvent(StatsUtils::StatsData & data,const cJSON * root)167 void BatteryStatsListener::ProcessAudioEvent(StatsUtils::StatsData& data, const cJSON* root)
168 {
169 data.type = StatsUtils::STATS_TYPE_AUDIO_ON;
170 cJSON* uidItem = cJSON_GetObjectItemCaseSensitive(root, "UID");
171 if (StatsJsonUtils::IsValidJsonNumber(uidItem)) {
172 data.uid = static_cast<int32_t>(uidItem->valueint);
173 }
174
175 cJSON* pidItem = cJSON_GetObjectItemCaseSensitive(root, "PID");
176 if (StatsJsonUtils::IsValidJsonNumber(pidItem)) {
177 data.pid = static_cast<int32_t>(pidItem->valueint);
178 }
179
180 cJSON* stateItem = cJSON_GetObjectItemCaseSensitive(root, "STATE");
181 if (StatsJsonUtils::IsValidJsonNumber(stateItem)) {
182 AudioState state = static_cast<AudioState>(stateItem->valueint);
183 switch (state) {
184 case AudioState::AUDIO_STATE_RUNNING:
185 data.state = StatsUtils::STATS_STATE_ACTIVATED;
186 break;
187 case AudioState::AUDIO_STATE_STOPPED:
188 case AudioState::AUDIO_STATE_RELEASED:
189 case AudioState::AUDIO_STATE_PAUSED:
190 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
191 break;
192 default:
193 data.state = StatsUtils::STATS_STATE_INVALID;
194 break;
195 }
196 }
197 }
198
ProcessSensorEvent(StatsUtils::StatsData & data,const cJSON * root,const std::string & eventName)199 void BatteryStatsListener::ProcessSensorEvent(StatsUtils::StatsData& data, const cJSON* root,
200 const std::string& eventName)
201 {
202 if (eventName == StatsHiSysEvent::POWER_SENSOR_GRAVITY) {
203 data.type = StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON;
204 } else if (eventName == StatsHiSysEvent::POWER_SENSOR_PROXIMITY) {
205 data.type = StatsUtils::STATS_TYPE_SENSOR_PROXIMITY_ON;
206 }
207
208 cJSON* uidItem = cJSON_GetObjectItemCaseSensitive(root, "UID");
209 if (StatsJsonUtils::IsValidJsonNumber(uidItem)) {
210 data.uid = static_cast<int32_t>(uidItem->valueint);
211 }
212
213 cJSON* pidItem = cJSON_GetObjectItemCaseSensitive(root, "PID");
214 if (StatsJsonUtils::IsValidJsonNumber(pidItem)) {
215 data.pid = static_cast<int32_t>(pidItem->valueint);
216 }
217
218 cJSON* stateItem = cJSON_GetObjectItemCaseSensitive(root, "STATE");
219 if (StatsJsonUtils::IsValidJsonNumber(stateItem)) {
220 if (stateItem->valueint == 1) {
221 data.state = StatsUtils::STATS_STATE_ACTIVATED;
222 } else if (stateItem->valueint == 0) {
223 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
224 }
225 }
226 }
227
ProcessGnssEvent(StatsUtils::StatsData & data,const cJSON * root)228 void BatteryStatsListener::ProcessGnssEvent(StatsUtils::StatsData& data, const cJSON* root)
229 {
230 data.type = StatsUtils::STATS_TYPE_GNSS_ON;
231 cJSON* uidItem = cJSON_GetObjectItemCaseSensitive(root, "UID");
232 if (StatsJsonUtils::IsValidJsonNumber(uidItem)) {
233 data.uid = static_cast<int32_t>(uidItem->valueint);
234 }
235
236 cJSON* pidItem = cJSON_GetObjectItemCaseSensitive(root, "PID");
237 if (StatsJsonUtils::IsValidJsonNumber(pidItem)) {
238 data.pid = static_cast<int32_t>(pidItem->valueint);
239 }
240
241 cJSON* stateItem = cJSON_GetObjectItemCaseSensitive(root, "STATE");
242 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(stateItem)) {
243 const char* stateStr = stateItem->valuestring;
244 if (strcmp(stateStr, "start") == 0) {
245 data.state = StatsUtils::STATS_STATE_ACTIVATED;
246 } else if (strcmp(stateStr, "stop") == 0) {
247 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
248 }
249 }
250 }
251
ProcessBluetoothBrEvent(StatsUtils::StatsData & data,const cJSON * root,const std::string & eventName)252 void BatteryStatsListener::ProcessBluetoothBrEvent(StatsUtils::StatsData& data, const cJSON* root,
253 const std::string& eventName)
254 {
255 cJSON* stateItem = cJSON_GetObjectItemCaseSensitive(root, "STATE");
256 if (eventName == StatsHiSysEvent::BR_SWITCH_STATE) {
257 data.type = StatsUtils::STATS_TYPE_BLUETOOTH_BR_ON;
258 if (StatsJsonUtils::IsValidJsonNumber(stateItem)) {
259 #ifdef HAS_BATTERYSTATS_BLUETOOTH_PART
260 if (stateItem->valueint == Bluetooth::BTStateID::STATE_TURN_ON) {
261 data.state = StatsUtils::STATS_STATE_ACTIVATED;
262 } else if (stateItem->valueint == Bluetooth::BTStateID::STATE_TURN_OFF) {
263 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
264 }
265 #endif
266 }
267 } else if (eventName == StatsHiSysEvent::DISCOVERY_STATE) {
268 data.type = StatsUtils::STATS_TYPE_BLUETOOTH_BR_SCAN;
269 if (StatsJsonUtils::IsValidJsonNumber(stateItem)) {
270 #ifdef HAS_BATTERYSTATS_BLUETOOTH_PART
271 if (stateItem->valueint == Bluetooth::DISCOVERY_STARTED) {
272 data.state = StatsUtils::STATS_STATE_ACTIVATED;
273 } else if (stateItem->valueint == Bluetooth::DISCOVERY_STOPED) {
274 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
275 }
276 #endif
277 }
278 cJSON* uidItem = cJSON_GetObjectItemCaseSensitive(root, "UID");
279 if (StatsJsonUtils::IsValidJsonNumber(uidItem)) {
280 data.uid = static_cast<int32_t>(uidItem->valueint);
281 }
282
283 cJSON* pidItem = cJSON_GetObjectItemCaseSensitive(root, "PID");
284 if (StatsJsonUtils::IsValidJsonNumber(pidItem)) {
285 data.pid = static_cast<int32_t>(pidItem->valueint);
286 }
287 }
288 }
289
ProcessBluetoothBleEvent(StatsUtils::StatsData & data,const cJSON * root,const std::string & eventName)290 void BatteryStatsListener::ProcessBluetoothBleEvent(StatsUtils::StatsData& data, const cJSON* root,
291 const std::string& eventName)
292 {
293 if (eventName == StatsHiSysEvent::BLE_SWITCH_STATE) {
294 data.type = StatsUtils::STATS_TYPE_BLUETOOTH_BLE_ON;
295 cJSON* stateItem = cJSON_GetObjectItemCaseSensitive(root, "STATE");
296 if (StatsJsonUtils::IsValidJsonNumber(stateItem)) {
297 #ifdef HAS_BATTERYSTATS_BLUETOOTH_PART
298 if (stateItem->valueint == Bluetooth::BTStateID::STATE_TURN_ON) {
299 data.state = StatsUtils::STATS_STATE_ACTIVATED;
300 } else if (stateItem->valueint == Bluetooth::BTStateID::STATE_TURN_OFF) {
301 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
302 }
303 #endif
304 }
305 } else if (eventName == StatsHiSysEvent::BLE_SCAN_START || eventName == StatsHiSysEvent::BLE_SCAN_STOP) {
306 data.type = StatsUtils::STATS_TYPE_BLUETOOTH_BLE_SCAN;
307 if (eventName == StatsHiSysEvent::BLE_SCAN_START) {
308 data.state = StatsUtils::STATS_STATE_ACTIVATED;
309 } else if (eventName == StatsHiSysEvent::BLE_SCAN_STOP) {
310 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
311 }
312 cJSON* uidItem = cJSON_GetObjectItemCaseSensitive(root, "UID");
313 if (StatsJsonUtils::IsValidJsonNumber(uidItem)) {
314 data.uid = static_cast<int32_t>(uidItem->valueint);
315 }
316
317 cJSON* pidItem = cJSON_GetObjectItemCaseSensitive(root, "PID");
318 if (StatsJsonUtils::IsValidJsonNumber(pidItem)) {
319 data.pid = static_cast<int32_t>(pidItem->valueint);
320 }
321 }
322 }
323
ProcessBluetoothEvent(StatsUtils::StatsData & data,const cJSON * root,const std::string & eventName)324 void BatteryStatsListener::ProcessBluetoothEvent(StatsUtils::StatsData& data, const cJSON* root,
325 const std::string& eventName)
326 {
327 if (eventName == StatsHiSysEvent::BR_SWITCH_STATE || eventName == StatsHiSysEvent::DISCOVERY_STATE) {
328 ProcessBluetoothBrEvent(data, root, eventName);
329 } else if (eventName == StatsHiSysEvent::BLE_SWITCH_STATE ||eventName == StatsHiSysEvent::BLE_SCAN_START ||
330 eventName == StatsHiSysEvent::BLE_SCAN_STOP) {
331 ProcessBluetoothBleEvent(data, root, eventName);
332 }
333 }
334
ProcessWifiEvent(StatsUtils::StatsData & data,const cJSON * root,const std::string & eventName)335 void BatteryStatsListener::ProcessWifiEvent(StatsUtils::StatsData& data, const cJSON* root,
336 const std::string& eventName)
337 {
338 if (eventName == StatsHiSysEvent::WIFI_CONNECTION) {
339 data.type = StatsUtils::STATS_TYPE_WIFI_ON;
340 cJSON* typeItem = cJSON_GetObjectItemCaseSensitive(root, "TYPE");
341 if (StatsJsonUtils::IsValidJsonNumber(typeItem)) {
342 #ifdef HAS_BATTERYSTATS_WIFI_PART
343 int connectionTypeInt = typeItem->valueint;
344 switch (static_cast<Wifi::ConnState>(connectionTypeInt)) {
345 case Wifi::ConnState::CONNECTED:
346 data.state = StatsUtils::STATS_STATE_ACTIVATED;
347 break;
348 case Wifi::ConnState::DISCONNECTED:
349 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
350 break;
351 default:
352 break;
353 }
354 #endif
355 }
356 } else if (eventName == StatsHiSysEvent::WIFI_SCAN) {
357 data.type = StatsUtils::STATS_TYPE_WIFI_SCAN;
358 data.traffic = 1;
359 }
360 }
361
ProcessPhoneDebugInfo(StatsUtils::StatsData & data,const cJSON * root)362 void BatteryStatsListener::ProcessPhoneDebugInfo(StatsUtils::StatsData& data, const cJSON* root)
363 {
364 cJSON* item = nullptr;
365
366 item = cJSON_GetObjectItemCaseSensitive(root, "name_");
367 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(item)) {
368 data.eventDebugInfo.append("Event name = ").append(item->valuestring);
369 }
370
371 item = cJSON_GetObjectItemCaseSensitive(root, "STATE");
372 if (StatsJsonUtils::IsValidJsonNumber(item)) {
373 data.eventDebugInfo.append(" State = ").append(std::to_string(item->valueint));
374 }
375
376 item = cJSON_GetObjectItemCaseSensitive(root, "SLOT_ID");
377 if (StatsJsonUtils::IsValidJsonNumber(item)) {
378 data.eventDebugInfo.append(" Slot ID = ").append(std::to_string(item->valueint));
379 }
380
381 item = cJSON_GetObjectItemCaseSensitive(root, "INDEX_ID");
382 if (StatsJsonUtils::IsValidJsonNumber(item)) {
383 data.eventDebugInfo.append(" Index ID = ").append(std::to_string(item->valueint));
384 }
385 }
386
ProcessPhoneEvent(StatsUtils::StatsData & data,const cJSON * root,const std::string & eventName)387 void BatteryStatsListener::ProcessPhoneEvent(StatsUtils::StatsData& data, const cJSON* root,
388 const std::string& eventName)
389 {
390 cJSON* stateItem = cJSON_GetObjectItemCaseSensitive(root, "STATE");
391 if (eventName == StatsHiSysEvent::CALL_STATE) {
392 data.type = StatsUtils::STATS_TYPE_PHONE_ACTIVE;
393 if (StatsJsonUtils::IsValidJsonNumber(stateItem)) {
394 #ifdef HAS_BATTERYSTATS_CALL_MANAGER_PART
395 int callStateInt = stateItem->valueint;
396 switch (static_cast<Telephony::TelCallState>(callStateInt)) {
397 case Telephony::TelCallState::CALL_STATUS_ACTIVE:
398 data.state = StatsUtils::STATS_STATE_ACTIVATED;
399 break;
400 case Telephony::TelCallState::CALL_STATUS_DISCONNECTED:
401 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
402 break;
403 default:
404 break;
405 }
406 #endif
407 }
408 } else if (eventName == StatsHiSysEvent::DATA_CONNECTION_STATE) {
409 data.type = StatsUtils::STATS_TYPE_PHONE_DATA;
410 if (StatsJsonUtils::IsValidJsonNumber(stateItem)) {
411 if (stateItem->valueint == 1) {
412 data.state = StatsUtils::STATS_STATE_ACTIVATED;
413 } else if (stateItem->valueint == 0) {
414 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
415 }
416 }
417 }
418
419 /**
420 * The average power consumption of phone call and phone data is divided by level
421 * However, the Telephony event has no input level information, so use level 0
422 */
423 data.level = 0;
424 ProcessPhoneDebugInfo(data, root);
425 }
426
ProcessFlashlightEvent(StatsUtils::StatsData & data,const cJSON * root)427 void BatteryStatsListener::ProcessFlashlightEvent(StatsUtils::StatsData& data, const cJSON* root)
428 {
429 data.type = StatsUtils::STATS_TYPE_FLASHLIGHT_ON;
430 cJSON* uidItem = cJSON_GetObjectItemCaseSensitive(root, "UID");
431 if (StatsJsonUtils::IsValidJsonNumber(uidItem)) {
432 data.uid = static_cast<int32_t>(uidItem->valueint);
433 }
434
435 cJSON* pidItem = cJSON_GetObjectItemCaseSensitive(root, "PID");
436 if (StatsJsonUtils::IsValidJsonNumber(pidItem)) {
437 data.pid = static_cast<int32_t>(pidItem->valueint);
438 }
439
440 cJSON* stateItem = cJSON_GetObjectItemCaseSensitive(root, "STATE");
441 if (StatsJsonUtils::IsValidJsonNumber(stateItem)) {
442 if (stateItem->valueint == 1) {
443 data.state = StatsUtils::STATS_STATE_ACTIVATED;
444 } else if (stateItem->valueint == 0) {
445 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
446 }
447 }
448 }
449
ProcessWakelockEvent(StatsUtils::StatsData & data,const cJSON * root)450 void BatteryStatsListener::ProcessWakelockEvent(StatsUtils::StatsData& data, const cJSON* root)
451 {
452 data.type = StatsUtils::STATS_TYPE_WAKELOCK_HOLD;
453 cJSON* uidItem = cJSON_GetObjectItemCaseSensitive(root, "UID");
454 if (StatsJsonUtils::IsValidJsonNumber(uidItem)) {
455 data.uid = static_cast<int32_t>(uidItem->valueint);
456 }
457
458 cJSON* pidItem = cJSON_GetObjectItemCaseSensitive(root, "PID");
459 if (StatsJsonUtils::IsValidJsonNumber(pidItem)) {
460 data.pid = static_cast<int32_t>(pidItem->valueint);
461 }
462 cJSON* stateItem = cJSON_GetObjectItemCaseSensitive(root, "STATE");
463 if (StatsJsonUtils::IsValidJsonNumber(stateItem)) {
464 int lockStateInt = stateItem->valueint;
465 std::string stateLabel = "";
466 switch (static_cast<RunningLockState>(lockStateInt)) {
467 case RunningLockState::RUNNINGLOCK_STATE_DISABLE: {
468 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
469 stateLabel = "Disable";
470 break;
471 }
472 case RunningLockState::RUNNINGLOCK_STATE_ENABLE: {
473 data.state = StatsUtils::STATS_STATE_ACTIVATED;
474 stateLabel = "Enable";
475 break;
476 }
477 case RunningLockState::RUNNINGLOCK_STATE_PROXIED:
478 case RunningLockState::RUNNINGLOCK_STATE_UNPROXIED_RESTORE: {
479 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
480 stateLabel = "Proxied";
481 break;
482 }
483 default:
484 break;
485 }
486 data.eventDebugInfo.append(" STATE = ").append(stateLabel);
487 }
488
489 ProcessWakelockEventInternal(data, root);
490 }
491
ProcessWakelockEventInternal(StatsUtils::StatsData & data,const cJSON * root)492 void BatteryStatsListener::ProcessWakelockEventInternal(StatsUtils::StatsData& data, const cJSON* root)
493 {
494 cJSON* typeItem = cJSON_GetObjectItemCaseSensitive(root, "TYPE");
495 if (StatsJsonUtils::IsValidJsonNumber(typeItem)) {
496 data.eventDataType = static_cast<int32_t>(typeItem->valueint);
497 }
498
499 cJSON* nameItem = cJSON_GetObjectItemCaseSensitive(root, "NAME");
500 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(nameItem)) {
501 data.eventDataName = nameItem->valuestring;
502 }
503
504 cJSON* logLevelItem = cJSON_GetObjectItemCaseSensitive(root, "LOG_LEVEL");
505 if (StatsJsonUtils::IsValidJsonNumber(logLevelItem)) {
506 data.eventDebugInfo.append(" LOG_LEVEL = ").append(std::to_string(logLevelItem->valueint));
507 }
508
509 cJSON* tagItem = cJSON_GetObjectItemCaseSensitive(root, "TAG");
510 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(tagItem)) {
511 data.eventDebugInfo.append(" TAG = ").append(tagItem->valuestring);
512 }
513
514 cJSON* messageItem = cJSON_GetObjectItemCaseSensitive(root, "MESSAGE");
515 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(messageItem)) {
516 data.eventDebugInfo.append(" MESSAGE = ").append(messageItem->valuestring);
517 }
518 }
519
ProcessDisplayDebugInfo(StatsUtils::StatsData & data,const cJSON * root)520 void BatteryStatsListener::ProcessDisplayDebugInfo(StatsUtils::StatsData& data, const cJSON* root)
521 {
522 cJSON* nameItem = cJSON_GetObjectItemCaseSensitive(root, "name_");
523 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(nameItem)) {
524 data.eventDebugInfo.append("Event name = ").append(nameItem->valuestring);
525 }
526
527 cJSON* stateItem = cJSON_GetObjectItemCaseSensitive(root, "STATE");
528 if (StatsJsonUtils::IsValidJsonNumber(stateItem)) {
529 data.eventDebugInfo.append(" Screen state = ").append(std::to_string(stateItem->valueint));
530 }
531
532 cJSON* brightnessItem = cJSON_GetObjectItemCaseSensitive(root, "BRIGHTNESS");
533 if (StatsJsonUtils::IsValidJsonNumber(brightnessItem)) {
534 data.eventDebugInfo.append(" Screen brightness = ").append(std::to_string(brightnessItem->valueint));
535 }
536
537 cJSON* reasonItem = cJSON_GetObjectItemCaseSensitive(root, "REASON");
538 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(reasonItem)) {
539 data.eventDebugInfo.append(" Brightness reason = ").append(reasonItem->valuestring);
540 }
541 ProcessDisplayDebugInfoInternal(data, root);
542 }
543
ProcessDisplayDebugInfoInternal(StatsUtils::StatsData & data,const cJSON * root)544 void BatteryStatsListener::ProcessDisplayDebugInfoInternal(StatsUtils::StatsData& data, const cJSON* root)
545 {
546 cJSON* nitItem = cJSON_GetObjectItemCaseSensitive(root, "NIT");
547 if (StatsJsonUtils::IsValidJsonNumber(nitItem)) {
548 data.eventDebugInfo.append(" Brightness nit = ").append(std::to_string(nitItem->valueint));
549 }
550
551 cJSON* ratioItem = cJSON_GetObjectItemCaseSensitive(root, "RATIO");
552 if (StatsJsonUtils::IsValidJsonNumber(ratioItem)) {
553 data.eventDebugInfo.append(" Ratio = ").append(std::to_string(ratioItem->valueint));
554 }
555
556 cJSON* typeItem = cJSON_GetObjectItemCaseSensitive(root, "TYPE");
557 if (StatsJsonUtils::IsValidJsonNumber(typeItem)) {
558 data.eventDebugInfo.append(" Ambient type = ").append(std::to_string(typeItem->valueint));
559 }
560
561 cJSON* levelItem = cJSON_GetObjectItemCaseSensitive(root, "LEVEL");
562 if (StatsJsonUtils::IsValidJsonNumber(levelItem)) {
563 data.eventDebugInfo.append(" Ambient brightness = ").append(std::to_string(levelItem->valueint));
564 }
565 }
566
ProcessDisplayEvent(StatsUtils::StatsData & data,const cJSON * root,const std::string & eventName)567 void BatteryStatsListener::ProcessDisplayEvent(StatsUtils::StatsData& data, const cJSON* root,
568 const std::string& eventName)
569 {
570 data.type = StatsUtils::STATS_TYPE_DISPLAY;
571 if (eventName == StatsHiSysEvent::SCREEN_STATE) {
572 data.type = StatsUtils::STATS_TYPE_SCREEN_ON;
573 #ifdef HAS_BATTERYSTATS_DISPLAY_MANAGER_PART
574 cJSON* stateItem = cJSON_GetObjectItemCaseSensitive(root, "STATE");
575 if (StatsJsonUtils::IsValidJsonNumber(stateItem)) {
576 int displayStateInt = stateItem->valueint;
577 switch (static_cast<DisplayPowerMgr::DisplayState>(displayStateInt)) {
578 case DisplayPowerMgr::DisplayState::DISPLAY_OFF:
579 data.state = StatsUtils::STATS_STATE_DEACTIVATED;
580 break;
581 case DisplayPowerMgr::DisplayState::DISPLAY_ON:
582 data.state = StatsUtils::STATS_STATE_ACTIVATED;
583 break;
584 default:
585 break;
586 }
587 }
588 #endif
589 } else if (eventName == StatsHiSysEvent::BRIGHTNESS_NIT) {
590 data.type = StatsUtils::STATS_TYPE_SCREEN_BRIGHTNESS;
591 cJSON* brightnessItem = cJSON_GetObjectItemCaseSensitive(root, "BRIGHTNESS");
592 if (StatsJsonUtils::IsValidJsonNumber(brightnessItem)) {
593 data.level = static_cast<int16_t>(brightnessItem->valueint);
594 }
595 }
596 ProcessDisplayDebugInfo(data, root);
597 }
598
ProcessBatteryEvent(StatsUtils::StatsData & data,const cJSON * root)599 void BatteryStatsListener::ProcessBatteryEvent(StatsUtils::StatsData& data, const cJSON* root)
600 {
601 data.type = StatsUtils::STATS_TYPE_BATTERY;
602
603 cJSON* levelItem = cJSON_GetObjectItemCaseSensitive(root, "LEVEL");
604 if (StatsJsonUtils::IsValidJsonNumber(levelItem)) {
605 data.level = static_cast<int16_t>(levelItem->valueint);
606 }
607
608 cJSON* chargerItem = cJSON_GetObjectItemCaseSensitive(root, "CHARGER");
609 if (StatsJsonUtils::IsValidJsonNumber(chargerItem)) {
610 data.eventDataExtra = static_cast<int32_t>(chargerItem->valueint);
611 }
612
613 cJSON* voltageItem = cJSON_GetObjectItemCaseSensitive(root, "VOLTAGE");
614 if (StatsJsonUtils::IsValidJsonNumber(voltageItem)) {
615 data.eventDebugInfo.append(" Voltage = ").append(std::to_string(voltageItem->valueint));
616 }
617
618 cJSON* healthItem = cJSON_GetObjectItemCaseSensitive(root, "HEALTH");
619 if (StatsJsonUtils::IsValidJsonNumber(healthItem)) {
620 data.eventDebugInfo.append(" Health = ").append(std::to_string(healthItem->valueint));
621 }
622
623 cJSON* temperatureItem = cJSON_GetObjectItemCaseSensitive(root, "TEMPERATURE");
624 if (StatsJsonUtils::IsValidJsonNumber(temperatureItem)) {
625 data.eventDebugInfo.append(" Temperature = ").append(std::to_string(temperatureItem->valueint));
626 }
627 }
628
ProcessThermalEvent(StatsUtils::StatsData & data,const cJSON * root)629 void BatteryStatsListener::ProcessThermalEvent(StatsUtils::StatsData& data, const cJSON* root)
630 {
631 data.type = StatsUtils::STATS_TYPE_THERMAL;
632
633 cJSON* nameItem = cJSON_GetObjectItemCaseSensitive(root, "name_");
634 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(nameItem)) {
635 data.eventDebugInfo.append("Event name = ").append(nameItem->valuestring);
636 }
637
638 cJSON* bundleNameItem = cJSON_GetObjectItemCaseSensitive(root, "NAME");
639 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(bundleNameItem)) {
640 data.eventDebugInfo.append(" Name = ").append(bundleNameItem->valuestring);
641 }
642
643 cJSON* temperatureItem = cJSON_GetObjectItemCaseSensitive(root, "TEMPERATURE");
644 if (StatsJsonUtils::IsValidJsonNumber(temperatureItem)) {
645 data.eventDebugInfo.append(" Temperature = ").append(std::to_string(temperatureItem->valueint));
646 }
647
648 cJSON* levelItem = cJSON_GetObjectItemCaseSensitive(root, "LEVEL");
649 if (StatsJsonUtils::IsValidJsonNumber(levelItem)) {
650 data.eventDebugInfo.append(" Temperature level = ").append(std::to_string(levelItem->valueint));
651 }
652
653 ProcessThermalEventInternal(data, root);
654 }
655
ProcessThermalEventInternal(StatsUtils::StatsData & data,const cJSON * root)656 void BatteryStatsListener::ProcessThermalEventInternal(StatsUtils::StatsData& data, const cJSON* root)
657 {
658 cJSON* actionItem = cJSON_GetObjectItemCaseSensitive(root, "ACTION");
659 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(actionItem)) {
660 data.eventDebugInfo.append(" Action name = ").append(actionItem->valuestring);
661 }
662
663 cJSON* valueItem = cJSON_GetObjectItemCaseSensitive(root, "VALUE");
664 if (StatsJsonUtils::IsValidJsonNumber(valueItem)) {
665 data.eventDebugInfo.append(" Value = ").append(std::to_string(valueItem->valueint));
666 }
667
668 cJSON* ratioItem = cJSON_GetObjectItemCaseSensitive(root, "RATIO");
669 if (StatsJsonUtils::IsValidJsonNumber(ratioItem)) {
670 std::string ratio = std::to_string(static_cast<float>(ratioItem->valuedouble)).substr(THERMAL_RATIO_BEGIN,
671 THERMAL_RATIO_LENGTH);
672 data.eventDebugInfo.append(" Ratio = ").append(ratio);
673 }
674 }
675
ProcessPowerWorkschedulerEvent(StatsUtils::StatsData & data,const cJSON * root)676 void BatteryStatsListener::ProcessPowerWorkschedulerEvent(StatsUtils::StatsData& data, const cJSON* root)
677 {
678 data.type = StatsUtils::STATS_TYPE_WORKSCHEDULER;
679 cJSON* uidItem = cJSON_GetObjectItemCaseSensitive(root, "UID");
680 if (StatsJsonUtils::IsValidJsonNumber(uidItem)) {
681 data.uid = static_cast<int32_t>(uidItem->valueint);
682 }
683
684 cJSON* pidItem = cJSON_GetObjectItemCaseSensitive(root, "PID");
685 if (StatsJsonUtils::IsValidJsonNumber(pidItem)) {
686 data.pid = static_cast<int32_t>(pidItem->valueint);
687 }
688
689 cJSON* stateItem = cJSON_GetObjectItemCaseSensitive(root, "STATE");
690 if (StatsJsonUtils::IsValidJsonNumber(stateItem)) {
691 data.state = static_cast<StatsUtils::StatsState>(stateItem->valueint);
692 }
693
694 cJSON* typeItem = cJSON_GetObjectItemCaseSensitive(root, "TYPE");
695 if (StatsJsonUtils::IsValidJsonNumber(typeItem)) {
696 data.eventDataType = static_cast<int32_t>(typeItem->valueint);
697 }
698
699 cJSON* intervalItem = cJSON_GetObjectItemCaseSensitive(root, "INTERVAL");
700 if (StatsJsonUtils::IsValidJsonNumber(intervalItem)) {
701 data.eventDataExtra = static_cast<int32_t>(intervalItem->valueint);
702 }
703 }
704
ProcessOthersWorkschedulerEvent(StatsUtils::StatsData & data,const cJSON * root)705 void BatteryStatsListener::ProcessOthersWorkschedulerEvent(StatsUtils::StatsData& data, const cJSON* root)
706 {
707 data.type = StatsUtils::STATS_TYPE_WORKSCHEDULER;
708 cJSON* nameItem = cJSON_GetObjectItemCaseSensitive(root, "name_");
709 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(nameItem)) {
710 data.eventDebugInfo.append(nameItem->valuestring).append(":");
711 }
712
713 cJSON* uidItem = cJSON_GetObjectItemCaseSensitive(root, "UID");
714 if (StatsJsonUtils::IsValidJsonNumber(uidItem)) {
715 data.uid = static_cast<int32_t>(uidItem->valueint);
716 }
717
718 cJSON* pidItem = cJSON_GetObjectItemCaseSensitive(root, "PID");
719 if (StatsJsonUtils::IsValidJsonNumber(pidItem)) {
720 data.pid = static_cast<int32_t>(pidItem->valueint);
721 }
722
723 cJSON* bundleNameItem = cJSON_GetObjectItemCaseSensitive(root, "NAME");
724 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(bundleNameItem)) {
725 data.eventDebugInfo.append(" Bundle name = ").append(bundleNameItem->valuestring);
726 }
727 ProcessOthersWorkschedulerEventInternal(data, root);
728 }
729
ProcessOthersWorkschedulerEventInternal(StatsUtils::StatsData & data,const cJSON * root)730 void BatteryStatsListener::ProcessOthersWorkschedulerEventInternal(StatsUtils::StatsData& data, const cJSON* root)
731 {
732 cJSON* workIdItem = cJSON_GetObjectItemCaseSensitive(root, "WORKID");
733 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(workIdItem)) {
734 data.eventDebugInfo.append(" Work ID = ").append(workIdItem->valuestring);
735 }
736
737 cJSON* triggerItem = cJSON_GetObjectItemCaseSensitive(root, "TRIGGER");
738 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(triggerItem)) {
739 data.eventDebugInfo.append(" Trigger conditions = ").append(triggerItem->valuestring);
740 }
741
742 cJSON* typeItem = cJSON_GetObjectItemCaseSensitive(root, "TYPE");
743 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(typeItem)) {
744 data.eventDebugInfo.append(" Work type = ").append(typeItem->valuestring);
745 }
746
747 cJSON* intervalItem = cJSON_GetObjectItemCaseSensitive(root, "INTERVAL");
748 if (StatsJsonUtils::IsValidJsonNumber(intervalItem)) {
749 data.eventDebugInfo.append(" Interval = ").append(std::to_string(intervalItem->valueint));
750 }
751 }
752
ProcessWorkschedulerEvent(StatsUtils::StatsData & data,const cJSON * root)753 void BatteryStatsListener::ProcessWorkschedulerEvent(StatsUtils::StatsData& data, const cJSON* root)
754 {
755 cJSON* nameItem = cJSON_GetObjectItemCaseSensitive(root, "name_");
756 if (!StatsJsonUtils::IsValidJsonStringAndNoEmpty(nameItem)) {
757 return;
758 }
759 std::string eventName(nameItem->valuestring);
760 if (eventName == StatsHiSysEvent::POWER_WORKSCHEDULER) {
761 ProcessPowerWorkschedulerEvent(data, root);
762 } else {
763 ProcessOthersWorkschedulerEvent(data, root);
764 }
765 }
766
ProcessDistributedSchedulerEvent(StatsUtils::StatsData & data,const cJSON * root)767 void BatteryStatsListener::ProcessDistributedSchedulerEvent(StatsUtils::StatsData& data, const cJSON* root)
768 {
769 data.type = StatsUtils::STATS_TYPE_DISTRIBUTEDSCHEDULER;
770 cJSON* nameItem = cJSON_GetObjectItemCaseSensitive(root, "name_");
771 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(nameItem)) {
772 data.eventDebugInfo.append("Event name = ").append(nameItem->valuestring);
773 }
774
775 cJSON* callingTypeItem = cJSON_GetObjectItemCaseSensitive(root, "CALLING_TYPE");
776 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(callingTypeItem)) {
777 data.eventDebugInfo.append(" Calling Type = ").append(callingTypeItem->valuestring);
778 }
779
780 cJSON* callingUidItem = cJSON_GetObjectItemCaseSensitive(root, "CALLING_UID");
781 if (StatsJsonUtils::IsValidJsonNumber(callingUidItem)) {
782 data.eventDebugInfo.append(" Calling Uid = ").append(std::to_string(callingUidItem->valueint));
783 }
784
785 cJSON* callingPidItem = cJSON_GetObjectItemCaseSensitive(root, "CALLING_PID");
786 if (StatsJsonUtils::IsValidJsonNumber(callingPidItem)) {
787 data.eventDebugInfo.append(" Calling Pid = ").append(std::to_string(callingPidItem->valueint));
788 }
789
790 ProcessDistributedSchedulerEventInternal(data, root);
791 }
792
ProcessDistributedSchedulerEventInternal(StatsUtils::StatsData & data,const cJSON * root)793 void BatteryStatsListener::ProcessDistributedSchedulerEventInternal(StatsUtils::StatsData& data, const cJSON* root)
794 {
795 cJSON* targetBundleItem = cJSON_GetObjectItemCaseSensitive(root, "TARGET_BUNDLE");
796 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(targetBundleItem)) {
797 data.eventDebugInfo.append(" Target Bundle Name = ").append(targetBundleItem->valuestring);
798 }
799
800 cJSON* targetAbilityItem = cJSON_GetObjectItemCaseSensitive(root, "TARGET_ABILITY");
801 if (StatsJsonUtils::IsValidJsonStringAndNoEmpty(targetAbilityItem)) {
802 data.eventDebugInfo.append(" Target Ability Name = ").append(targetAbilityItem->valuestring);
803 }
804
805 cJSON* callingAppUidItem = cJSON_GetObjectItemCaseSensitive(root, "CALLING_APP_UID");
806 if (StatsJsonUtils::IsValidJsonNumber(callingAppUidItem)) {
807 data.eventDebugInfo.append(" Calling App Uid = ").append(std::to_string(callingAppUidItem->valueint));
808 }
809
810 cJSON* resultItem = cJSON_GetObjectItemCaseSensitive(root, "RESULT");
811 if (StatsJsonUtils::IsValidJsonNumber(resultItem)) {
812 data.eventDebugInfo.append(" RESULT = ").append(std::to_string(resultItem->valueint));
813 }
814 }
815
ProcessAlarmEvent(StatsUtils::StatsData & data,const cJSON * root)816 void BatteryStatsListener::ProcessAlarmEvent(StatsUtils::StatsData& data, const cJSON* root)
817 {
818 data.type = StatsUtils::STATS_TYPE_ALARM;
819 data.traffic = 1;
820
821 cJSON* uidItem = cJSON_GetObjectItemCaseSensitive(root, "CALLER_UID");
822 if (StatsJsonUtils::IsValidJsonNumber(uidItem)) {
823 data.uid = static_cast<int32_t>(uidItem->valueint);
824 }
825
826 cJSON* pidItem = cJSON_GetObjectItemCaseSensitive(root, "CALLER_PID");
827 if (StatsJsonUtils::IsValidJsonNumber(pidItem)) {
828 data.pid = static_cast<int32_t>(pidItem->valueint);
829 }
830 }
831
OnServiceDied()832 void BatteryStatsListener::OnServiceDied()
833 {
834 STATS_HILOGE(COMP_SVC, "Service disconnected");
835 }
836 } // namespace PowerMgr
837 } // namespace OHOS
838