1 /*
2  * Copyright (c) 2021-2022 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 #include "battery_stats_core.h"
16 
17 #include <cinttypes>
18 #include <fstream>
19 #include <map>
20 #include <functional>
21 #include <list>
22 #include <utility>
23 #include <vector>
24 
25 #include "ios"
26 #include "json/reader.h"
27 #include "json/writer.h"
28 #include "ohos_account_kits.h"
29 
30 #include "battery_info.h"
31 #include "battery_srv_client.h"
32 #include "entities/audio_entity.h"
33 #include "entities/bluetooth_entity.h"
34 #include "entities/camera_entity.h"
35 #include "entities/cpu_entity.h"
36 #include "entities/flashlight_entity.h"
37 #include "entities/gnss_entity.h"
38 #include "entities/idle_entity.h"
39 #include "entities/phone_entity.h"
40 #include "entities/screen_entity.h"
41 #include "entities/sensor_entity.h"
42 #include "entities/uid_entity.h"
43 #include "entities/user_entity.h"
44 #include "entities/wifi_entity.h"
45 #include "entities/wakelock_entity.h"
46 #include "entities/alarm_entity.h"
47 #include "stats_helper.h"
48 
49 #include "xcollie/xcollie.h"
50 #include "xcollie/xcollie_define.h"
51 
52 namespace OHOS {
53 namespace PowerMgr {
54 namespace {
55 static const std::string BATTERY_STATS_JSON = "/data/service/el0/stats/battery_stats.json";
56 } // namespace
CreatePartEntity()57 void BatteryStatsCore::CreatePartEntity()
58 {
59     if (bluetoothEntity_ == nullptr) {
60         STATS_HILOGD(COMP_SVC, "Create bluetooth entity");
61         bluetoothEntity_ = std::make_shared<BluetoothEntity>();
62     }
63     if (idleEntity_ == nullptr) {
64         STATS_HILOGD(COMP_SVC, "Create idle entity");
65         idleEntity_ = std::make_shared<IdleEntity>();
66     }
67     if (phoneEntity_ == nullptr) {
68         STATS_HILOGD(COMP_SVC, "Create phone entity");
69         phoneEntity_ = std::make_shared<PhoneEntity>();
70     }
71     if (screenEntity_ == nullptr) {
72         STATS_HILOGD(COMP_SVC, "Create screen entity");
73         screenEntity_ = std::make_shared<ScreenEntity>();
74     }
75     if (wifiEntity_ == nullptr) {
76         STATS_HILOGD(COMP_SVC, "Create wifi entity");
77         wifiEntity_ = std::make_shared<WifiEntity>();
78     }
79 }
80 
CreateAppEntity()81 void BatteryStatsCore::CreateAppEntity()
82 {
83     if (audioEntity_ == nullptr) {
84         STATS_HILOGD(COMP_SVC, "Create audio entity");
85         audioEntity_ = std::make_shared<AudioEntity>();
86     }
87     if (cameraEntity_ == nullptr) {
88         STATS_HILOGD(COMP_SVC, "Create camera entity");
89         cameraEntity_ = std::make_shared<CameraEntity>();
90     }
91     if (flashlightEntity_ == nullptr) {
92         STATS_HILOGD(COMP_SVC, "Create flashlight entity");
93         flashlightEntity_ = std::make_shared<FlashlightEntity>();
94     }
95     if (gnssEntity_ == nullptr) {
96         STATS_HILOGD(COMP_SVC, "Create gnss entity");
97         gnssEntity_ = std::make_shared<GnssEntity>();
98     }
99     if (sensorEntity_ == nullptr) {
100         STATS_HILOGD(COMP_SVC, "Create sensor entity");
101         sensorEntity_ = std::make_shared<SensorEntity>();
102     }
103     if (uidEntity_ == nullptr) {
104         STATS_HILOGD(COMP_SVC, "Create uid entity");
105         uidEntity_ = std::make_shared<UidEntity>();
106     }
107     if (userEntity_ == nullptr) {
108         STATS_HILOGD(COMP_SVC, "Create user entity");
109         userEntity_ = std::make_shared<UserEntity>();
110     }
111     if (wakelockEntity_ == nullptr) {
112         STATS_HILOGD(COMP_SVC, "Create wakelock entity");
113         wakelockEntity_ = std::make_shared<WakelockEntity>();
114     }
115     if (cpuEntity_ == nullptr) {
116         STATS_HILOGD(COMP_SVC, "Create cpu entity");
117         cpuEntity_ = std::make_shared<CpuEntity>();
118     }
119     if (alarmEntity_ == nullptr) {
120         STATS_HILOGD(COMP_SVC, "Create alarm entity");
121         alarmEntity_ = std::make_shared<AlarmEntity>();
122     }
123 }
124 
Init()125 bool BatteryStatsCore::Init()
126 {
127     STATS_HILOGI(COMP_SVC, "Battery stats core init");
128     CreateAppEntity();
129     CreatePartEntity();
130     auto& batterySrvClient = BatterySrvClient::GetInstance();
131     BatteryPluggedType plugType = batterySrvClient.GetPluggedType();
132     if (plugType == BatteryPluggedType::PLUGGED_TYPE_NONE || plugType == BatteryPluggedType::PLUGGED_TYPE_BUTT) {
133         StatsHelper::SetOnBattery(true);
134     } else {
135         StatsHelper::SetOnBattery(false);
136     }
137 
138     if (!LoadBatteryStatsData()) {
139         STATS_HILOGW(COMP_SVC, "Load battery stats data failed");
140     }
141     return true;
142 }
143 
ComputePower()144 void BatteryStatsCore::ComputePower()
145 {
146     std::lock_guard lock(mutex_);
147     STATS_HILOGD(COMP_SVC, "Calculate battery stats");
148     const uint32_t DFX_DELAY_S = 60;
149     int id = HiviewDFX::XCollie::GetInstance().SetTimer("BatteryStatsCoreComputePower", DFX_DELAY_S, nullptr, nullptr,
150         HiviewDFX::XCOLLIE_FLAG_LOG);
151 
152     BatteryStatsEntity::ResetStatsEntity();
153     uidEntity_->Calculate();
154     bluetoothEntity_->Calculate();
155     idleEntity_->Calculate();
156     phoneEntity_->Calculate();
157     screenEntity_->Calculate();
158     wifiEntity_->Calculate();
159     userEntity_->Calculate();
160 
161     HiviewDFX::XCollie::GetInstance().CancelTimer(id);
162 }
163 
GetBatteryStats()164 BatteryStatsInfoList BatteryStatsCore::GetBatteryStats()
165 {
166     std::lock_guard lock(mutex_);
167     return BatteryStatsEntity::GetStatsInfoList();
168 }
169 
GetEntity(const BatteryStatsInfo::ConsumptionType & type)170 std::shared_ptr<BatteryStatsEntity> BatteryStatsCore::GetEntity(const BatteryStatsInfo::ConsumptionType& type)
171 {
172     STATS_HILOGD(COMP_SVC, "Get %{public}s entity", BatteryStatsInfo::ConvertConsumptionType(type).c_str());
173     switch (type) {
174         case BatteryStatsInfo::CONSUMPTION_TYPE_APP:
175             return uidEntity_;
176         case BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH:
177             return bluetoothEntity_;
178         case BatteryStatsInfo::CONSUMPTION_TYPE_IDLE:
179             return idleEntity_;
180         case BatteryStatsInfo::CONSUMPTION_TYPE_PHONE:
181             return phoneEntity_;
182         case BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN:
183             return screenEntity_;
184         case BatteryStatsInfo::CONSUMPTION_TYPE_USER:
185             return userEntity_;
186         case BatteryStatsInfo::CONSUMPTION_TYPE_WIFI:
187             return wifiEntity_;
188         case BatteryStatsInfo::CONSUMPTION_TYPE_CAMERA:
189             return cameraEntity_;
190         case BatteryStatsInfo::CONSUMPTION_TYPE_FLASHLIGHT:
191             return flashlightEntity_;
192         case BatteryStatsInfo::CONSUMPTION_TYPE_AUDIO:
193             return audioEntity_;
194         case BatteryStatsInfo::CONSUMPTION_TYPE_SENSOR:
195             return sensorEntity_;
196         case BatteryStatsInfo::CONSUMPTION_TYPE_GNSS:
197             return gnssEntity_;
198         case BatteryStatsInfo::CONSUMPTION_TYPE_CPU:
199             return cpuEntity_;
200         case BatteryStatsInfo::CONSUMPTION_TYPE_WAKELOCK:
201             return wakelockEntity_;
202         case BatteryStatsInfo::CONSUMPTION_TYPE_ALARM:
203             return alarmEntity_;
204         case BatteryStatsInfo::CONSUMPTION_TYPE_INVALID:
205         default:
206             return nullptr;
207     }
208 }
209 
UpdateStats(StatsUtils::StatsType statsType,int64_t time,int64_t data,int32_t uid)210 void BatteryStatsCore::UpdateStats(StatsUtils::StatsType statsType, int64_t time, int64_t data, int32_t uid)
211 {
212     STATS_HILOGD(COMP_SVC,
213         "Update for duration, statsType: %{public}s, uid: %{public}d, time: %{public}" PRId64 ", "  \
214         "data: %{public}" PRId64 "",
215         StatsUtils::ConvertStatsType(statsType).c_str(), uid, time, data);
216     if (uid > StatsUtils::INVALID_VALUE) {
217         uidEntity_->UpdateUidMap(uid);
218     }
219 
220     switch (statsType) {
221         case StatsUtils::STATS_TYPE_WIFI_SCAN:
222             UpdateCounter(wifiEntity_, statsType, data, uid);
223             break;
224         case StatsUtils::STATS_TYPE_ALARM:
225             UpdateCounter(alarmEntity_, statsType, data, uid);
226             break;
227         default:
228             break;
229     }
230 }
231 
UpdateConnectivityStats(StatsUtils::StatsType statsType,StatsUtils::StatsState state,int32_t uid)232 void BatteryStatsCore::UpdateConnectivityStats(StatsUtils::StatsType statsType, StatsUtils::StatsState state,
233     int32_t uid)
234 {
235     switch (statsType) {
236         case StatsUtils::STATS_TYPE_BLUETOOTH_BR_ON:
237         case StatsUtils::STATS_TYPE_BLUETOOTH_BLE_ON:
238             UpdateTimer(bluetoothEntity_, statsType, state);
239             break;
240         case StatsUtils::STATS_TYPE_WIFI_ON:
241             UpdateTimer(wifiEntity_, statsType, state);
242             break;
243         case StatsUtils::STATS_TYPE_BLUETOOTH_BR_SCAN:
244         case StatsUtils::STATS_TYPE_BLUETOOTH_BLE_SCAN:
245             UpdateTimer(bluetoothEntity_, statsType, state, uid);
246             break;
247         default:
248             break;
249     }
250 }
251 
UpdateCommonStats(StatsUtils::StatsType statsType,StatsUtils::StatsState state,int32_t uid)252 void BatteryStatsCore::UpdateCommonStats(StatsUtils::StatsType statsType, StatsUtils::StatsState state, int32_t uid)
253 {
254     switch (statsType) {
255         case StatsUtils::STATS_TYPE_FLASHLIGHT_ON:
256             UpdateTimer(flashlightEntity_, statsType, state, uid);
257             break;
258         case StatsUtils::STATS_TYPE_GNSS_ON:
259             UpdateTimer(gnssEntity_, statsType, state, uid);
260             break;
261         case StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON:
262             UpdateTimer(sensorEntity_, statsType, state, uid);
263             break;
264         case StatsUtils::STATS_TYPE_SENSOR_PROXIMITY_ON:
265             UpdateTimer(sensorEntity_, statsType, state, uid);
266             break;
267         case StatsUtils::STATS_TYPE_AUDIO_ON:
268             UpdateTimer(audioEntity_, statsType, state, uid);
269             break;
270         case StatsUtils::STATS_TYPE_WAKELOCK_HOLD:
271             UpdateTimer(wakelockEntity_, statsType, state, uid);
272             break;
273         default:
274             break;
275     }
276 }
277 
UpdateStats(StatsUtils::StatsType statsType,StatsUtils::StatsState state,int16_t level,int32_t uid,const std::string & deviceId)278 void BatteryStatsCore::UpdateStats(StatsUtils::StatsType statsType, StatsUtils::StatsState state, int16_t level,
279     int32_t uid, const std::string& deviceId)
280 {
281     STATS_HILOGD(COMP_SVC,
282         "Update for state, statsType: %{public}s, uid: %{public}d, state: %{public}d, level: %{public}d,"   \
283         "deviceId: %{private}s",
284         StatsUtils::ConvertStatsType(statsType).c_str(), uid, state, level, deviceId.c_str());
285     if (uid > StatsUtils::INVALID_VALUE) {
286         uidEntity_->UpdateUidMap(uid);
287     }
288 
289     switch (statsType) {
290         case StatsUtils::STATS_TYPE_SCREEN_ON:
291         case StatsUtils::STATS_TYPE_SCREEN_BRIGHTNESS:
292             UpdateScreenStats(statsType, state, level);
293             break;
294         case StatsUtils::STATS_TYPE_CAMERA_ON:
295         case StatsUtils::STATS_TYPE_CAMERA_FLASHLIGHT_ON:
296             UpdateCameraStats(statsType, state, uid, deviceId);
297             break;
298         case StatsUtils::STATS_TYPE_PHONE_ACTIVE:
299         case StatsUtils::STATS_TYPE_PHONE_DATA:
300             UpdatePhoneStats(statsType, state, level);
301             break;
302         case StatsUtils::STATS_TYPE_BLUETOOTH_BR_ON:
303         case StatsUtils::STATS_TYPE_BLUETOOTH_BLE_ON:
304         case StatsUtils::STATS_TYPE_WIFI_ON:
305         case StatsUtils::STATS_TYPE_BLUETOOTH_BR_SCAN:
306         case StatsUtils::STATS_TYPE_BLUETOOTH_BLE_SCAN:
307             UpdateConnectivityStats(statsType, state, uid);
308             break;
309         case StatsUtils::STATS_TYPE_FLASHLIGHT_ON:
310         case StatsUtils::STATS_TYPE_GNSS_ON:
311         case StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON:
312         case StatsUtils::STATS_TYPE_SENSOR_PROXIMITY_ON:
313         case StatsUtils::STATS_TYPE_AUDIO_ON:
314         case StatsUtils::STATS_TYPE_WAKELOCK_HOLD:
315             UpdateCommonStats(statsType, state, uid);
316             break;
317         default:
318             break;
319     }
320 }
321 
UpdateScreenStats(StatsUtils::StatsType statsType,StatsUtils::StatsState state,int16_t level)322 void BatteryStatsCore::UpdateScreenStats(StatsUtils::StatsType statsType, StatsUtils::StatsState state, int16_t level)
323 {
324     STATS_HILOGD(COMP_SVC,
325         "statsType: %{public}s, state: %{public}d, level: %{public}d, last brightness level: %{public}d",
326         StatsUtils::ConvertStatsType(statsType).c_str(), state, level, lastBrightnessLevel_);
327     if (statsType == StatsUtils::STATS_TYPE_SCREEN_ON) {
328         UpdateScreenTimer(state);
329     } else if (statsType == StatsUtils::STATS_TYPE_SCREEN_BRIGHTNESS) {
330         if (!isScreenOn_) {
331             STATS_HILOGD(COMP_SVC, "Screen is off, return");
332             return;
333         }
334         UpdateBrightnessTimer(state, level);
335     }
336 }
337 
UpdateCameraStats(StatsUtils::StatsType statsType,StatsUtils::StatsState state,int32_t uid,const std::string & deviceId)338 void BatteryStatsCore::UpdateCameraStats(StatsUtils::StatsType statsType, StatsUtils::StatsState state,
339     int32_t uid, const std::string& deviceId)
340 {
341     STATS_HILOGD(COMP_SVC, "Camera status: %{public}d, Last camera uid: %{public}d", isCameraOn_, lastCameraUid_);
342     if (statsType == StatsUtils::STATS_TYPE_CAMERA_ON) {
343         if (state == StatsUtils::STATS_STATE_ACTIVATED) {
344             if (isCameraOn_) {
345                 STATS_HILOGW(COMP_SVC, "Camera is already opened, return");
346                 return;
347             }
348             UpdateCameraTimer(state, uid, deviceId);
349         } else if (state == StatsUtils::STATS_STATE_DEACTIVATED) {
350             if (!isCameraOn_) {
351                 STATS_HILOGW(COMP_SVC, "Camera is off, return");
352                 return;
353             }
354             UpdateCameraTimer(state, lastCameraUid_, deviceId);
355         }
356     } else if (statsType == StatsUtils::STATS_TYPE_CAMERA_FLASHLIGHT_ON) {
357         if (!isCameraOn_) {
358             STATS_HILOGW(COMP_SVC, "Camera is off, return");
359             return;
360         }
361         UpdateTimer(flashlightEntity_, StatsUtils::STATS_TYPE_FLASHLIGHT_ON, state, lastCameraUid_);
362     }
363 }
364 
UpdatePhoneStats(StatsUtils::StatsType statsType,StatsUtils::StatsState state,int16_t level)365 void BatteryStatsCore::UpdatePhoneStats(StatsUtils::StatsType statsType, StatsUtils::StatsState state, int16_t level)
366 {
367     STATS_HILOGD(COMP_SVC, "statsType: %{public}s, state: %{public}d, level: %{public}d",
368         StatsUtils::ConvertStatsType(statsType).c_str(), state, level);
369     std::shared_ptr<StatsHelper::ActiveTimer> timer;
370     timer = phoneEntity_->GetOrCreateTimer(statsType, level);
371     if (timer == nullptr) {
372         STATS_HILOGW(COMP_SVC, "Timer is null, return");
373         return;
374     }
375 
376     switch (state) {
377         case StatsUtils::STATS_STATE_ACTIVATED:
378             timer->StartRunning();
379             break;
380         case StatsUtils::STATS_STATE_DEACTIVATED:
381             timer->StopRunning();
382             break;
383         default:
384             break;
385     }
386 }
387 
UpdateTimer(std::shared_ptr<BatteryStatsEntity> entity,StatsUtils::StatsType statsType,StatsUtils::StatsState state,int32_t uid)388 void BatteryStatsCore::UpdateTimer(std::shared_ptr<BatteryStatsEntity> entity, StatsUtils::StatsType statsType,
389     StatsUtils::StatsState state, int32_t uid)
390 {
391     STATS_HILOGD(COMP_SVC,
392         "entity: %{public}s, statsType: %{public}s, state: %{public}d, uid: %{public}d",
393         BatteryStatsInfo::ConvertConsumptionType(entity->GetConsumptionType()).c_str(),
394         StatsUtils::ConvertStatsType(statsType).c_str(),
395         state,
396         uid);
397     std::shared_ptr<StatsHelper::ActiveTimer> timer;
398     if (uid > StatsUtils::INVALID_VALUE) {
399         timer = entity->GetOrCreateTimer(uid, statsType);
400     } else {
401         timer = entity->GetOrCreateTimer(statsType);
402     }
403 
404     if (timer == nullptr) {
405         STATS_HILOGW(COMP_SVC, "Timer is null, return");
406         return;
407     }
408 
409     switch (state) {
410         case StatsUtils::STATS_STATE_ACTIVATED:
411             timer->StartRunning();
412             break;
413         case StatsUtils::STATS_STATE_DEACTIVATED:
414             timer->StopRunning();
415             break;
416         default:
417             break;
418     }
419 }
420 
UpdateTimer(std::shared_ptr<BatteryStatsEntity> entity,StatsUtils::StatsType statsType,int64_t time,int32_t uid)421 void BatteryStatsCore::UpdateTimer(std::shared_ptr<BatteryStatsEntity> entity, StatsUtils::StatsType statsType,
422     int64_t time, int32_t uid)
423 {
424     STATS_HILOGD(COMP_SVC,
425         "entity: %{public}s, statsType: %{public}s, time: %{public}" PRId64 ", uid: %{public}d",
426         BatteryStatsInfo::ConvertConsumptionType(entity->GetConsumptionType()).c_str(),
427         StatsUtils::ConvertStatsType(statsType).c_str(),
428         time,
429         uid);
430     std::shared_ptr<StatsHelper::ActiveTimer> timer;
431     if (uid > StatsUtils::INVALID_VALUE) {
432         timer = entity->GetOrCreateTimer(uid, statsType);
433     } else {
434         timer = entity->GetOrCreateTimer(statsType);
435     }
436 
437     if (timer == nullptr) {
438         STATS_HILOGW(COMP_SVC, "Timer is null, return");
439         return;
440     }
441     timer->AddRunningTimeMs(time);
442 }
443 
UpdateCameraTimer(StatsUtils::StatsState state,int32_t uid,const std::string & deviceId)444 void BatteryStatsCore::UpdateCameraTimer(StatsUtils::StatsState state, int32_t uid, const std::string& deviceId)
445 {
446     STATS_HILOGD(COMP_SVC, "Camera status: %{public}d, uid: %{public}d, deviceId: %{private}s",
447         state, uid, deviceId.c_str());
448     std::shared_ptr<StatsHelper::ActiveTimer> timer;
449     if (uid > StatsUtils::INVALID_VALUE && deviceId != "") {
450         timer = cameraEntity_->GetOrCreateTimer(deviceId, uid, StatsUtils::STATS_TYPE_CAMERA_ON);
451     } else {
452         timer = cameraEntity_->GetOrCreateTimer(StatsUtils::STATS_TYPE_CAMERA_ON);
453     }
454 
455     if (timer == nullptr) {
456         STATS_HILOGW(COMP_SVC, "Timer is null, return");
457         return;
458     }
459 
460     switch (state) {
461         case StatsUtils::STATS_STATE_ACTIVATED: {
462             if (timer->StartRunning()) {
463                 isCameraOn_ = true;
464                 lastCameraUid_ = uid;
465             }
466             break;
467         }
468         case StatsUtils::STATS_STATE_DEACTIVATED: {
469             if (timer->StopRunning()) {
470                 UpdateTimer(flashlightEntity_,
471                             StatsUtils::STATS_TYPE_FLASHLIGHT_ON,
472                             StatsUtils::STATS_STATE_DEACTIVATED,
473                             lastCameraUid_);
474                 isCameraOn_ = false;
475                 lastCameraUid_ = StatsUtils::INVALID_VALUE;
476             }
477             break;
478         }
479         default:
480             break;
481     }
482 }
483 
UpdateScreenTimer(StatsUtils::StatsState state)484 void BatteryStatsCore::UpdateScreenTimer(StatsUtils::StatsState state)
485 {
486     std::shared_ptr<StatsHelper::ActiveTimer> screenOnTimer = nullptr;
487     std::shared_ptr<StatsHelper::ActiveTimer> brightnessTimer = nullptr;
488     screenOnTimer = screenEntity_->GetOrCreateTimer(StatsUtils::STATS_TYPE_SCREEN_ON);
489     if (lastBrightnessLevel_ > StatsUtils::INVALID_VALUE) {
490         brightnessTimer = screenEntity_->GetOrCreateTimer(StatsUtils::STATS_TYPE_SCREEN_BRIGHTNESS,
491             lastBrightnessLevel_);
492     }
493     if (state == StatsUtils::STATS_STATE_ACTIVATED) {
494         if (screenOnTimer != nullptr) {
495             screenOnTimer->StartRunning();
496         }
497         if (brightnessTimer != nullptr) {
498             brightnessTimer->StartRunning();
499         }
500         isScreenOn_ = true;
501     } else if (state == StatsUtils::STATS_STATE_DEACTIVATED) {
502         if (screenOnTimer != nullptr) {
503             screenOnTimer->StopRunning();
504         }
505         if (brightnessTimer != nullptr) {
506             brightnessTimer->StopRunning();
507         }
508         isScreenOn_ = false;
509     }
510 }
511 
UpdateBrightnessTimer(StatsUtils::StatsState state,int16_t level)512 void BatteryStatsCore::UpdateBrightnessTimer(StatsUtils::StatsState state, int16_t level)
513 {
514     if (level <= StatsUtils::INVALID_VALUE || level > StatsUtils::SCREEN_BRIGHTNESS_BIN) {
515         STATS_HILOGW(COMP_SVC, "Screen brightness level is out of range");
516         return;
517     }
518 
519     if (lastBrightnessLevel_ <= StatsUtils::INVALID_VALUE ||
520         (level > StatsUtils::INVALID_VALUE && level == lastBrightnessLevel_)) {
521         auto brightnessTimer = screenEntity_->GetOrCreateTimer(StatsUtils::STATS_TYPE_SCREEN_BRIGHTNESS,
522             level);
523         if (brightnessTimer != nullptr) {
524             brightnessTimer->StartRunning();
525         }
526     } else if (level != lastBrightnessLevel_) {
527         auto oldBrightnessTimer = screenEntity_->GetOrCreateTimer(StatsUtils::STATS_TYPE_SCREEN_BRIGHTNESS,
528             lastBrightnessLevel_);
529         auto newBrightnessTimer = screenEntity_->GetOrCreateTimer(StatsUtils::STATS_TYPE_SCREEN_BRIGHTNESS, level);
530         if (oldBrightnessTimer != nullptr) {
531             STATS_HILOGI(COMP_SVC, "Stop screen brightness timer for last level: %{public}d",
532                 lastBrightnessLevel_);
533             oldBrightnessTimer->StopRunning();
534         }
535         if (newBrightnessTimer != nullptr) {
536             STATS_HILOGI(COMP_SVC, "Start screen brightness timer for latest level: %{public}d", level);
537             newBrightnessTimer->StartRunning();
538         }
539     }
540     lastBrightnessLevel_ = level;
541 }
542 
UpdateCounter(std::shared_ptr<BatteryStatsEntity> entity,StatsUtils::StatsType statsType,int64_t data,int32_t uid)543 void BatteryStatsCore::UpdateCounter(std::shared_ptr<BatteryStatsEntity> entity, StatsUtils::StatsType statsType,
544     int64_t data, int32_t uid)
545 {
546     STATS_HILOGD(COMP_SVC,
547         "entity: %{public}s, statsType: %{public}s, data: %{public}" PRId64 ", uid: %{public}d",
548         BatteryStatsInfo::ConvertConsumptionType(entity->GetConsumptionType()).c_str(),
549         StatsUtils::ConvertStatsType(statsType).c_str(),
550         data,
551         uid);
552     std::shared_ptr<StatsHelper::Counter> counter;
553     if (uid > StatsUtils::INVALID_VALUE) {
554         counter = entity->GetOrCreateCounter(statsType, uid);
555     } else {
556         counter = entity->GetOrCreateCounter(statsType);
557     }
558 
559     if (counter == nullptr) {
560         STATS_HILOGW(COMP_SVC, "Counter is null, return");
561         return;
562     }
563     counter->AddCount(data);
564 }
565 
GetTotalTimeMs(StatsUtils::StatsType statsType,int16_t level)566 int64_t BatteryStatsCore::GetTotalTimeMs(StatsUtils::StatsType statsType, int16_t level)
567 {
568     STATS_HILOGD(COMP_SVC, "Handle statsType: %{public}s, level: %{public}d",
569         StatsUtils::ConvertStatsType(statsType).c_str(), level);
570     int64_t time = StatsUtils::DEFAULT_VALUE;
571     switch (statsType) {
572         case StatsUtils::STATS_TYPE_SCREEN_BRIGHTNESS:
573             time = screenEntity_->GetActiveTimeMs(statsType, level);
574             break;
575         case StatsUtils::STATS_TYPE_SCREEN_ON:
576             time = screenEntity_->GetActiveTimeMs(statsType);
577             break;
578         case StatsUtils::STATS_TYPE_BLUETOOTH_BR_ON:
579         case StatsUtils::STATS_TYPE_BLUETOOTH_BLE_ON:
580             time = bluetoothEntity_->GetActiveTimeMs(statsType);
581             break;
582         case StatsUtils::STATS_TYPE_WIFI_ON:
583             time = wifiEntity_->GetActiveTimeMs(statsType);
584             break;
585         case StatsUtils::STATS_TYPE_PHONE_ACTIVE:
586         case StatsUtils::STATS_TYPE_PHONE_DATA:
587             time = phoneEntity_->GetActiveTimeMs(statsType, level);
588             break;
589         case StatsUtils::STATS_TYPE_PHONE_IDLE:
590         case StatsUtils::STATS_TYPE_CPU_SUSPEND:
591             time = idleEntity_->GetActiveTimeMs(statsType);
592             break;
593         default:
594             break;
595     }
596     STATS_HILOGD(COMP_SVC, "Get active time: %{public}sms for %{public}s", std::to_string(time).c_str(),
597         StatsUtils::ConvertStatsType(statsType).c_str());
598     return time;
599 }
600 
DumpInfo(std::string & result)601 void BatteryStatsCore::DumpInfo(std::string& result)
602 {
603     result.append("BATTERY STATS DUMP:\n");
604     result.append("\n");
605     if (bluetoothEntity_) {
606         bluetoothEntity_->DumpInfo(result);
607         result.append("\n");
608     }
609     if (idleEntity_) {
610         idleEntity_->DumpInfo(result);
611         result.append("\n");
612     }
613     if (phoneEntity_) {
614         phoneEntity_->DumpInfo(result);
615         result.append("\n");
616     }
617     if (screenEntity_) {
618         screenEntity_->DumpInfo(result);
619         result.append("\n");
620     }
621     if (wifiEntity_) {
622         wifiEntity_->DumpInfo(result);
623         result.append("\n");
624     }
625     if (uidEntity_) {
626         uidEntity_->DumpInfo(result);
627         result.append("\n");
628     }
629     GetDebugInfo(result);
630 }
631 
UpdateDebugInfo(const std::string & info)632 void BatteryStatsCore::UpdateDebugInfo(const std::string& info)
633 {
634     std::lock_guard lock(mutex_);
635     debugInfo_.append(info);
636 }
637 
GetDebugInfo(std::string & result)638 void BatteryStatsCore::GetDebugInfo(std::string& result)
639 {
640     std::lock_guard lock(mutex_);
641     if (debugInfo_.size() > 0) {
642         result.append("Misc stats info dump:\n");
643         result.append(debugInfo_);
644     }
645 }
646 
GetTotalTimeMs(int32_t uid,StatsUtils::StatsType statsType,int16_t level)647 int64_t BatteryStatsCore::GetTotalTimeMs(int32_t uid, StatsUtils::StatsType statsType, int16_t level)
648 {
649     STATS_HILOGD(COMP_SVC, "Handle statsType: %{public}s, uid: %{public}d, level: %{public}d",
650         StatsUtils::ConvertStatsType(statsType).c_str(), uid, level);
651     int64_t time = StatsUtils::DEFAULT_VALUE;
652     switch (statsType) {
653         case StatsUtils::STATS_TYPE_BLUETOOTH_BR_SCAN:
654         case StatsUtils::STATS_TYPE_BLUETOOTH_BLE_SCAN:
655             time = bluetoothEntity_->GetActiveTimeMs(uid, statsType);
656             break;
657         case StatsUtils::STATS_TYPE_CAMERA_ON:
658             time = cameraEntity_->GetActiveTimeMs(uid, statsType);
659             break;
660         case StatsUtils::STATS_TYPE_FLASHLIGHT_ON:
661             time = flashlightEntity_->GetActiveTimeMs(uid, statsType);
662             break;
663         case StatsUtils::STATS_TYPE_GNSS_ON:
664             time = gnssEntity_->GetActiveTimeMs(uid, statsType);
665             break;
666         case StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON:
667             time = sensorEntity_->GetActiveTimeMs(uid, statsType);
668             break;
669         case StatsUtils::STATS_TYPE_SENSOR_PROXIMITY_ON:
670             time = sensorEntity_->GetActiveTimeMs(uid, statsType);
671             break;
672         case StatsUtils::STATS_TYPE_AUDIO_ON:
673             time = audioEntity_->GetActiveTimeMs(uid, statsType);
674             break;
675         case StatsUtils::STATS_TYPE_WAKELOCK_HOLD:
676             time = wakelockEntity_->GetActiveTimeMs(uid, statsType);
677             break;
678         case StatsUtils::STATS_TYPE_CPU_CLUSTER:
679         case StatsUtils::STATS_TYPE_CPU_SPEED:
680         case StatsUtils::STATS_TYPE_CPU_ACTIVE:
681             time = cpuEntity_->GetCpuTimeMs(uid);
682             break;
683         default:
684             break;
685     }
686     STATS_HILOGD(COMP_SVC, "Get active time: %{public}sms for %{public}s of uid: %{public}d",
687         std::to_string(time).c_str(), StatsUtils::ConvertStatsType(statsType).c_str(), uid);
688     return time;
689 }
690 
GetTotalDataCount(StatsUtils::StatsType statsType,int32_t uid)691 int64_t BatteryStatsCore::GetTotalDataCount(StatsUtils::StatsType statsType, int32_t uid)
692 {
693     STATS_HILOGD(COMP_SVC, "no traffic data bytes of %{public}s for uid: %{public}d",
694         StatsUtils::ConvertStatsType(statsType).c_str(), uid);
695     return StatsUtils::DEFAULT_VALUE;
696 }
697 
GetTotalConsumptionCount(StatsUtils::StatsType statsType,int32_t uid)698 int64_t BatteryStatsCore::GetTotalConsumptionCount(StatsUtils::StatsType statsType, int32_t uid)
699 {
700     int64_t data = StatsUtils::DEFAULT_VALUE;
701     switch (statsType) {
702         case StatsUtils::STATS_TYPE_WIFI_SCAN:
703             data = wifiEntity_->GetConsumptionCount(statsType, uid);
704             break;
705         case StatsUtils::STATS_TYPE_ALARM:
706             data = alarmEntity_->GetConsumptionCount(statsType, uid);
707             break;
708         default:
709             break;
710     }
711     STATS_HILOGD(COMP_SVC, "Get consumption count: %{public}" PRId64 " of %{public}s for uid: %{public}d",
712         data, StatsUtils::ConvertStatsType(statsType).c_str(), uid);
713     return data;
714 }
715 
GetAppStatsMah(const int32_t & uid)716 double BatteryStatsCore::GetAppStatsMah(const int32_t& uid)
717 {
718     double appStatsMah = StatsUtils::DEFAULT_VALUE;
719     auto statsInfoList = GetBatteryStats();
720     for (auto iter = statsInfoList.begin(); iter != statsInfoList.end(); iter++) {
721         if ((*iter)->GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_APP) {
722             if ((*iter)->GetUid() == uid) {
723                 appStatsMah = (*iter)->GetPower();
724                 break;
725             }
726         }
727     }
728     STATS_HILOGD(COMP_SVC, "Get stats mah: %{public}lf for uid: %{public}d", appStatsMah, uid);
729     return appStatsMah;
730 }
731 
GetAppStatsPercent(const int32_t & uid)732 double BatteryStatsCore::GetAppStatsPercent(const int32_t& uid)
733 {
734     double appStatsPercent = StatsUtils::DEFAULT_VALUE;
735     auto statsInfoList = GetBatteryStats();
736     auto totalConsumption = BatteryStatsEntity::GetTotalPowerMah();
737     if (totalConsumption <= StatsUtils::DEFAULT_VALUE) {
738         STATS_HILOGW(COMP_SVC, "No consumption got, return 0");
739         return appStatsPercent;
740     }
741     for (auto iter = statsInfoList.begin(); iter != statsInfoList.end(); iter++) {
742         if ((*iter)->GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_APP) {
743             if ((*iter)->GetUid() == uid && totalConsumption != StatsUtils::DEFAULT_VALUE) {
744                 appStatsPercent = (*iter)->GetPower() / totalConsumption;
745                 break;
746             }
747         }
748     }
749     STATS_HILOGD(COMP_SVC, "Get stats percent: %{public}lf for uid: %{public}d", appStatsPercent, uid);
750     return appStatsPercent;
751 }
752 
GetPartStatsMah(const BatteryStatsInfo::ConsumptionType & type)753 double BatteryStatsCore::GetPartStatsMah(const BatteryStatsInfo::ConsumptionType& type)
754 {
755     double partStatsMah = StatsUtils::DEFAULT_VALUE;
756     auto statsInfoList = GetBatteryStats();
757     for (auto iter = statsInfoList.begin(); iter != statsInfoList.end(); iter++) {
758         if ((*iter)->GetConsumptionType() == type) {
759             partStatsMah = (*iter)->GetPower();
760             break;
761         }
762     }
763     STATS_HILOGD(COMP_SVC, "Get stats mah: %{public}lf for type: %{public}d", partStatsMah, type);
764     return partStatsMah;
765 }
766 
GetPartStatsPercent(const BatteryStatsInfo::ConsumptionType & type)767 double BatteryStatsCore::GetPartStatsPercent(const BatteryStatsInfo::ConsumptionType& type)
768 {
769     double partStatsPercent = StatsUtils::DEFAULT_VALUE;
770     auto statsInfoList = GetBatteryStats();
771     auto totalConsumption = BatteryStatsEntity::GetTotalPowerMah();
772     for (auto iter = statsInfoList.begin(); iter != statsInfoList.end(); iter++) {
773         if ((*iter)->GetConsumptionType() == type && totalConsumption != StatsUtils::DEFAULT_VALUE) {
774             partStatsPercent = (*iter)->GetPower() / totalConsumption;
775             break;
776         }
777     }
778     STATS_HILOGD(COMP_SVC, "Get stats percent: %{public}lf for type: %{public}d", partStatsPercent, type);
779     return partStatsPercent;
780 }
781 
SaveForHardware(Json::Value & root)782 void BatteryStatsCore::SaveForHardware(Json::Value& root)
783 {
784     STATS_HILOGD(COMP_SVC, "Save hardware battery stats");
785     // Save for Bluetooth
786     root["Hardware"]["bluetooth_br_on"] =
787         Json::Value(GetTotalTimeMs(StatsUtils::STATS_TYPE_BLUETOOTH_BR_ON));
788     root["Hardware"]["bluetooth_ble_on"] =
789         Json::Value(GetTotalTimeMs(StatsUtils::STATS_TYPE_BLUETOOTH_BLE_ON));
790 
791     // Save for Screen
792     root["Hardware"]["screen_on"] =
793         Json::Value(GetTotalTimeMs(StatsUtils::STATS_TYPE_SCREEN_ON));
794     for (uint16_t brightNess = 0; brightNess <= StatsUtils::SCREEN_BRIGHTNESS_BIN; brightNess++) {
795         root["Hardware"]["screen_brightness"][brightNess] =
796             Json::Value(GetTotalTimeMs(StatsUtils::STATS_TYPE_SCREEN_BRIGHTNESS, brightNess));
797     }
798 
799     // Save for Wifi
800     root["Hardware"]["wifi_on"] =
801         Json::Value(GetTotalTimeMs(StatsUtils::STATS_TYPE_WIFI_ON));
802     root["Hardware"]["wifi_scan"] =
803         Json::Value(GetTotalConsumptionCount(StatsUtils::STATS_TYPE_WIFI_SCAN));
804 
805     // Save for CPU idle
806     root["Hardware"]["cpu_idle"] =
807         Json::Value(GetTotalTimeMs(StatsUtils::STATS_TYPE_PHONE_IDLE));
808 
809     // Save for Phone
810     for (uint16_t signalOn = 0; signalOn < StatsUtils::RADIO_SIGNAL_BIN; signalOn++) {
811         root["Hardware"]["radio_on"][signalOn] =
812             Json::Value(GetTotalTimeMs(StatsUtils::STATS_TYPE_PHONE_ACTIVE, signalOn));
813     }
814     for (uint16_t signalData = 0; signalData < StatsUtils::RADIO_SIGNAL_BIN; signalData++) {
815         root["Hardware"]["radio_data"][signalData] =
816             Json::Value(GetTotalTimeMs(StatsUtils::STATS_TYPE_PHONE_DATA, signalData));
817     }
818 }
819 
SaveForSoftware(Json::Value & root)820 void BatteryStatsCore::SaveForSoftware(Json::Value& root)
821 {
822     for (auto it : uidEntity_->GetUids()) {
823         SaveForSoftwareCommon(root, it);
824         SaveForSoftwareConnectivity(root, it);
825     }
826 }
827 
SaveForSoftwareCommon(Json::Value & root,int32_t uid)828 void BatteryStatsCore::SaveForSoftwareCommon(Json::Value& root, int32_t uid)
829 {
830     STATS_HILOGD(COMP_SVC, "Save software common battery stats, uid: %{public}d", uid);
831     std::string strUid = std::to_string(uid);
832     // Save for camera related
833     root["Software"][strUid]["camera_on"] =
834         Json::Value(GetTotalTimeMs(uid, StatsUtils::STATS_TYPE_CAMERA_ON));
835 
836     // Save for flashlight related
837     root["Software"][strUid]["flashlight_on"] =
838         Json::Value(GetTotalTimeMs(uid, StatsUtils::STATS_TYPE_FLASHLIGHT_ON));
839 
840     // Save for gnss related
841     root["Software"][strUid]["gnss_on"] =
842         Json::Value(GetTotalTimeMs(uid, StatsUtils::STATS_TYPE_GNSS_ON));
843 
844     // Save for audio related
845     root["Software"][strUid]["audio_on"] =
846         Json::Value(GetTotalTimeMs(uid, StatsUtils::STATS_TYPE_AUDIO_ON));
847 
848     // Save for wakelock related
849     root["Software"][strUid]["cpu_awake"] =
850         Json::Value(GetTotalTimeMs(uid, StatsUtils::STATS_TYPE_WAKELOCK_HOLD));
851 
852     // Save for sensor related
853     root["Software"][strUid]["sensor_gravity"] =
854         Json::Value(GetTotalTimeMs(uid, StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON));
855     root["Software"][strUid]["sensor_proximity"] =
856         Json::Value(GetTotalTimeMs(uid, StatsUtils::STATS_TYPE_SENSOR_PROXIMITY_ON));
857 
858     // Save for alarm related
859     root["Software"][strUid]["alarm"] =
860         Json::Value(GetTotalConsumptionCount(StatsUtils::STATS_TYPE_ALARM, uid));
861 
862     // Save for cpu related
863     root["Software"][strUid]["cpu_time"] = Json::Value(cpuEntity_->GetCpuTimeMs(uid));
864 }
865 
SaveForSoftwareConnectivity(Json::Value & root,int32_t uid)866 void BatteryStatsCore::SaveForSoftwareConnectivity(Json::Value& root, int32_t uid)
867 {
868     STATS_HILOGD(COMP_SVC, "Save software connectivity battery stats, uid: %{public}d", uid);
869     std::string strUid = std::to_string(uid);
870     // Save for Bluetooth related
871     root["Software"][strUid]["bluetooth_br_scan"] =
872         Json::Value(GetTotalTimeMs(uid, StatsUtils::STATS_TYPE_BLUETOOTH_BR_SCAN));
873     root["Software"][strUid]["bluetooth_ble_scan"] =
874         Json::Value(GetTotalTimeMs(uid, StatsUtils::STATS_TYPE_BLUETOOTH_BLE_SCAN));
875 }
876 
SaveForPower(Json::Value & root)877 void BatteryStatsCore::SaveForPower(Json::Value& root)
878 {
879     STATS_HILOGD(COMP_SVC, "Save power battery stats");
880     auto statsInfoList = BatteryStatsEntity::GetStatsInfoList();
881     for (auto iter = statsInfoList.begin(); iter != statsInfoList.end(); iter++) {
882         if ((*iter)->GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_APP) {
883             std::string name = std::to_string((*iter)->GetUid());
884             root["Power"][name] = Json::Value((*iter)->GetPower());
885             STATS_HILOGD(COMP_SVC, "Saved power: %{public}lf for uid: %{public}s", (*iter)->GetPower(),
886                 name.c_str());
887         } else if ((*iter)->GetConsumptionType() != BatteryStatsInfo::CONSUMPTION_TYPE_USER) {
888             std::string name = std::to_string((*iter)->GetConsumptionType());
889             root["Power"][name] = Json::Value((*iter)->GetPower());
890             STATS_HILOGD(COMP_SVC, "Saved power: %{public}lf for type: %{public}s", (*iter)->GetPower(),
891                 name.c_str());
892         }
893     }
894 }
895 
SaveBatteryStatsData()896 bool BatteryStatsCore::SaveBatteryStatsData()
897 {
898     ComputePower();
899     Json::Value root;
900 
901     // Save for power
902     SaveForPower(root);
903 
904     // Save for hardware
905     SaveForHardware(root);
906 
907     // Save for software
908     SaveForSoftware(root);
909 
910     Json::StreamWriterBuilder swb;
911     std::ofstream ofs;
912     ofs.open(BATTERY_STATS_JSON);
913     if (!ofs.is_open()) {
914         STATS_HILOGE(COMP_SVC, "Opening json file failed");
915         return false;
916     }
917     swb.newStreamWriter()->write(root, &ofs);
918     ofs.close();
919     return true;
920 }
921 
UpdateStatsEntity(Json::Value & root)922 void BatteryStatsCore::UpdateStatsEntity(Json::Value &root)
923 {
924     BatteryStatsEntity::ResetStatsEntity();
925     Json::Value::Members member = root["Power"].getMemberNames();
926     std::map<int32_t, double> tmpUserPowerMap;
927     for (auto iter = member.begin(); iter != member.end(); iter++) {
928         if (!root["Power"][*iter].isDouble()) {
929             continue;
930         }
931         auto id = std::stoi(*iter);
932         int32_t usr = StatsUtils::INVALID_VALUE;
933         std::shared_ptr<BatteryStatsInfo> info = std::make_shared<BatteryStatsInfo>();
934         if (id > StatsUtils::INVALID_VALUE) {
935             info->SetUid(id);
936             info->SetConsumptioType(BatteryStatsInfo::CONSUMPTION_TYPE_APP);
937             info->SetPower(root["Power"][*iter].asDouble());
938             usr = AccountSA::OhosAccountKits::GetInstance().GetDeviceAccountIdByUID(id);
939             const auto& userPower = tmpUserPowerMap.find(usr);
940             if (userPower != tmpUserPowerMap.end()) {
941                 userPower->second += info->GetPower();
942             } else {
943                 tmpUserPowerMap.insert(std::pair<int32_t, double>(usr, info->GetPower()));
944             }
945         } else if (id < StatsUtils::INVALID_VALUE && id > BatteryStatsInfo::CONSUMPTION_TYPE_INVALID) {
946             info->SetUid(StatsUtils::INVALID_VALUE);
947             info->SetConsumptioType(static_cast<BatteryStatsInfo::ConsumptionType>(id));
948             info->SetPower(root["Power"][*iter].asDouble());
949         }
950         STATS_HILOGD(COMP_SVC, "Load power:%{public}lfmAh,id:%{public}d,user:%{public}d", info->GetPower(), id, usr);
951         BatteryStatsEntity::UpdateStatsInfoList(info);
952     }
953     for (auto& iter : tmpUserPowerMap) {
954         std::shared_ptr<BatteryStatsInfo> statsInfo = std::make_shared<BatteryStatsInfo>();
955         statsInfo->SetConsumptioType(BatteryStatsInfo::CONSUMPTION_TYPE_USER);
956         statsInfo->SetUserId(iter.first);
957         statsInfo->SetPower(iter.second);
958         BatteryStatsEntity::UpdateStatsInfoList(statsInfo);
959     }
960 }
961 
LoadBatteryStatsData()962 bool BatteryStatsCore::LoadBatteryStatsData()
963 {
964     Json::CharReaderBuilder reader;
965     Json::Value root;
966     std::string errors;
967     std::ifstream ifs(BATTERY_STATS_JSON, std::ios::binary);
968     if (!ifs.is_open()) {
969         STATS_HILOGE(COMP_SVC, "Json file doesn't exist");
970         return false;
971     }
972     if (!parseFromStream(reader, ifs, &root, &errors)) {
973         STATS_HILOGE(COMP_SVC, "Failed to parse the JSON file");
974         ifs.close();
975         return false;
976     }
977     ifs.close();
978     UpdateStatsEntity(root);
979     return true;
980 }
981 
Reset()982 void BatteryStatsCore::Reset()
983 {
984     std::lock_guard lock(mutex_);
985     audioEntity_->Reset();
986     bluetoothEntity_->Reset();
987     cameraEntity_->Reset();
988     cpuEntity_->Reset();
989     flashlightEntity_->Reset();
990     gnssEntity_->Reset();
991     idleEntity_->Reset();
992     phoneEntity_->Reset();
993     screenEntity_->Reset();
994     sensorEntity_->Reset();
995     uidEntity_->Reset();
996     userEntity_->Reset();
997     wifiEntity_->Reset();
998     wakelockEntity_->Reset();
999     alarmEntity_->Reset();
1000     BatteryStatsEntity::ResetStatsEntity();
1001     debugInfo_.clear();
1002 }
1003 } // namespace PowerMgr
1004 } // namespace OHOS
1005