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_service.h"
17 
18 #include <cstdio>
19 #include <ctime>
20 #include <functional>
21 #include <new>
22 
23 #include "ability_manager_client.h"
24 #ifdef BATTERY_MANAGER_ENABLE_CHARGING_SOUND
25 #include "charging_sound.h"
26 #endif
27 #include "errors.h"
28 #include "hdf_device_class.h"
29 #include "hdf_service_status.h"
30 #include "ipc_skeleton.h"
31 #include "iremote_object.h"
32 #include "permission.h"
33 #include "power_common.h"
34 #include "power_mgr_client.h"
35 #include "ffrt_utils.h"
36 #include "sysparam.h"
37 #include "system_ability_definition.h"
38 #include "xcollie/watchdog.h"
39 
40 #include "battery_callback.h"
41 #include "battery_config.h"
42 #include "battery_dump.h"
43 #include "battery_log.h"
44 #include "power_vibrator.h"
45 #include "v2_0/ibattery_callback.h"
46 
47 using namespace OHOS::HDI::Battery;
48 using namespace OHOS::AAFwk;
49 
50 namespace OHOS {
51 namespace PowerMgr {
52 namespace {
53 constexpr const char* BATTERY_SERVICE_NAME = "BatteryService";
54 constexpr const char* BATTERY_HDI_NAME = "battery_interface_service";
55 constexpr int32_t BATTERY_FULL_CAPACITY = 100;
56 constexpr uint32_t RETRY_TIME = 1000;
57 constexpr uint32_t SHUTDOWN_DELAY_TIME_MS = 60000;
58 const std::string BATTERY_VIBRATOR_CONFIG_FILE = "etc/battery/battery_vibrator.json";
59 const std::string VENDOR_BATTERY_VIBRATOR_CONFIG_FILE = "/vendor/etc/battery/battery_vibrator.json";
60 const std::string SYSTEM_BATTERY_VIBRATOR_CONFIG_FILE = "/system/etc/battery/battery_vibrator.json";
61 sptr<BatteryService> g_service = DelayedSpSingleton<BatteryService>::GetInstance();
62 FFRTQueue g_queue("battery_service");
63 FFRTHandle g_lowCapacityShutdownHandle = nullptr;
64 BatteryPluggedType g_lastPluggedType = BatteryPluggedType::PLUGGED_TYPE_NONE;
65 SysParam::BootCompletedCallback g_bootCompletedCallback;
66 }
67 std::atomic_bool BatteryService::isBootCompleted_ = false;
68 
69 const bool G_REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(
70     DelayedSpSingleton<BatteryService>::GetInstance().GetRefPtr());
71 
BatteryService()72 BatteryService::BatteryService()
73     : SystemAbility(POWER_MANAGER_BATT_SERVICE_ID, true)
74 {
75 }
76 
~BatteryService()77 BatteryService::~BatteryService() {}
78 
GetCurrentTime()79 static int64_t GetCurrentTime()
80 {
81     constexpr int32_t SEC_TO_MSEC = 1000;
82     constexpr int32_t NSEC_TO_MSEC = 1000000;
83     timespec tm {};
84     clock_gettime(CLOCK_MONOTONIC, &tm);
85 
86     return tm.tv_sec * SEC_TO_MSEC + (tm.tv_nsec / NSEC_TO_MSEC);
87 }
88 
OnStart()89 void BatteryService::OnStart()
90 {
91     if (ready_) {
92         BATTERY_HILOGD(COMP_SVC, "Service is ready, nothing to do");
93         return;
94     }
95     if (!(Init())) {
96         BATTERY_HILOGE(COMP_SVC, "Call init failed");
97         return;
98     }
99     RegisterHdiStatusListener();
100     if (!Publish(this)) {
101         BATTERY_HILOGE(COMP_SVC, "Register to system ability manager failed");
102         return;
103     }
104     AddSystemAbilityListener(MISCDEVICE_SERVICE_ABILITY_ID);
105     ready_ = true;
106 }
107 
Init()108 bool BatteryService::Init()
109 {
110     InitConfig();
111     if (!batteryNotify_) {
112         batteryNotify_ = std::make_unique<BatteryNotify>();
113     }
114     VibratorInit();
115     RegisterBootCompletedCallback();
116     return true;
117 }
118 
RegisterBootCompletedCallback()119 void BatteryService::RegisterBootCompletedCallback()
120 {
121     g_bootCompletedCallback = []() {
122         isBootCompleted_ = true;
123     };
124     SysParam::RegisterBootCompletedCallback(g_bootCompletedCallback);
125 }
126 
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)127 void BatteryService::OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
128 {
129     BATTERY_HILOGI(COMP_SVC, "systemAbilityId=%{public}d, deviceId=%{private}s", systemAbilityId, deviceId.c_str());
130     if (systemAbilityId == MISCDEVICE_SERVICE_ABILITY_ID) {
131         batteryLight_.InitLight();
132     }
133 }
134 
RegisterBatteryHdiCallback()135 bool BatteryService::RegisterBatteryHdiCallback()
136 {
137     std::lock_guard<std::shared_mutex> lock(mutex_);
138     if (iBatteryInterface_ == nullptr) {
139         iBatteryInterface_ = V2_0::IBatteryInterface::Get();
140         BATTERY_HILOGE(COMP_SVC, "failed to get battery hdi interface");
141         RETURN_IF_WITH_RET(iBatteryInterface_ == nullptr, false);
142     }
143     sptr<V2_0::IBatteryCallback> callback = new BatteryCallback();
144     ErrCode ret = iBatteryInterface_->Register(callback);
145     if (ret < 0) {
146         BATTERY_HILOGE(COMP_SVC, "register callback failed");
147         return false;
148     }
149 
150     BatteryCallback::BatteryEventCallback eventCb =
151         [this](const V2_0::BatteryInfo& event) -> int32_t { return this->HandleBatteryCallbackEvent(event); };
152     BatteryCallback::RegisterBatteryEvent(eventCb);
153     return true;
154 }
155 
InitConfig()156 void BatteryService::InitConfig()
157 {
158     auto& batteryConfig = BatteryConfig::GetInstance();
159     batteryConfig.ParseConfig();
160 
161     warnCapacity_ = batteryConfig.GetInt("soc.warning", warnCapacity_);
162     highTemperature_ = batteryConfig.GetInt("temperature.high", highTemperature_);
163     lowTemperature_ = batteryConfig.GetInt("temperature.low", lowTemperature_);
164     shutdownCapacityThreshold_ = batteryConfig.GetInt("soc.shutdown", shutdownCapacityThreshold_);
165     criticalCapacityThreshold_ = batteryConfig.GetInt("soc.critical", criticalCapacityThreshold_);
166     warningCapacityThreshold_ = batteryConfig.GetInt("soc.warning", warningCapacityThreshold_);
167     lowCapacityThreshold_ = batteryConfig.GetInt("soc.low", lowCapacityThreshold_);
168     normalCapacityThreshold_ = batteryConfig.GetInt("soc.normal", normalCapacityThreshold_);
169     highCapacityThreshold_ = batteryConfig.GetInt("soc.high", highCapacityThreshold_);
170     fullCapacityThreshold_ = batteryConfig.GetInt("soc.full", fullCapacityThreshold_);
171     BATTERY_HILOGI(COMP_SVC, "warnCapacity_=%{public}d, highTemperature_=%{public}d,\
172         lowTemperature_=%{public}d, shutdownCapacityThreshold_=%{public}d,\
173         criticalCapacityThreshold_=%{public}d, warningCapacityThreshold_=%{public}d, lowCapacityThreshold_=%{public}d,\
174         normalCapacityThreshold_=%{public}d, highCapacityThreshold_=%{public}d, fullCapacityThreshold_=%{public}d",
175         warnCapacity_, highTemperature_, lowTemperature_, shutdownCapacityThreshold_, criticalCapacityThreshold_,
176         warningCapacityThreshold_, lowCapacityThreshold_, normalCapacityThreshold_, highCapacityThreshold_,
177         fullCapacityThreshold_);
178 }
179 
HandleBatteryCallbackEvent(const V2_0::BatteryInfo & event)180 int32_t BatteryService::HandleBatteryCallbackEvent(const V2_0::BatteryInfo& event)
181 {
182     if (isMockUnplugged_ || isMockCapacity_ || isMockUevent_) {
183         return ERR_OK;
184     }
185 
186     ConvertingEvent(event);
187     RETURN_IF_WITH_RET(lastBatteryInfo_ == batteryInfo_, ERR_OK);
188     HandleBatteryInfo();
189     return ERR_OK;
190 }
191 
ConvertingEvent(const V2_0::BatteryInfo & event)192 void BatteryService::ConvertingEvent(const V2_0::BatteryInfo& event)
193 {
194     if (!isMockCapacity_) {
195         batteryInfo_.SetCapacity(event.capacity);
196     }
197     if (!isMockUnplugged_) {
198         batteryInfo_.SetPluggedType(BatteryPluggedType(event.pluggedType));
199         batteryInfo_.SetPluggedMaxCurrent(event.pluggedMaxCurrent);
200         batteryInfo_.SetPluggedMaxVoltage(event.pluggedMaxVoltage);
201         batteryInfo_.SetChargeState(BatteryChargeState(event.chargeState));
202     }
203     batteryInfo_.SetVoltage(event.voltage);
204     batteryInfo_.SetTemperature(event.temperature);
205     batteryInfo_.SetHealthState(BatteryHealthState(event.healthState));
206     batteryInfo_.SetChargeCounter(event.chargeCounter);
207     batteryInfo_.SetTotalEnergy(event.totalEnergy);
208     batteryInfo_.SetCurAverage(event.curAverage);
209     batteryInfo_.SetRemainEnergy(event.remainEnergy);
210     batteryInfo_.SetPresent(event.present);
211     batteryInfo_.SetTechnology(event.technology);
212     batteryInfo_.SetNowCurrent(event.curNow);
213     batteryInfo_.SetChargeType(GetChargeType());
214     if (!isMockUevent_) {
215         batteryInfo_.SetUevent(event.uevent);
216     }
217 }
218 
InitBatteryInfo()219 void BatteryService::InitBatteryInfo()
220 {
221     batteryInfo_.SetCapacity(GetCapacity());
222     batteryInfo_.SetPluggedType(GetPluggedType());
223     batteryInfo_.SetChargeState(GetChargingStatus());
224     batteryInfo_.SetVoltage(GetVoltage());
225     batteryInfo_.SetTemperature(GetBatteryTemperature());
226     batteryInfo_.SetHealthState(GetHealthStatus());
227     batteryInfo_.SetTotalEnergy(GetTotalEnergy());
228     batteryInfo_.SetCurAverage(GetCurrentAverage());
229     batteryInfo_.SetRemainEnergy(GetRemainEnergy());
230     batteryInfo_.SetPresent(GetPresent());
231     batteryInfo_.SetTechnology(GetTechnology());
232     batteryInfo_.SetNowCurrent(GetNowCurrent());
233     batteryInfo_.SetChargeType(GetChargeType());
234     HandleBatteryInfo();
235 }
236 
HandleBatteryInfo()237 void BatteryService::HandleBatteryInfo()
238 {
239     BATTERY_HILOGI(FEATURE_BATT_INFO, "capacity=%{public}d, voltage=%{public}d, temperature=%{public}d, "
240         "healthState=%{public}d, pluggedType=%{public}d, pluggedMaxCurrent=%{public}d, "
241         "pluggedMaxVoltage=%{public}d, chargeState=%{public}d, chargeCounter=%{public}d, present=%{public}d, "
242         "technology=%{public}s, currNow=%{public}d, totalEnergy=%{public}d, curAverage=%{public}d, "
243         "remainEnergy=%{public}d, chargeType=%{public}d, event=%{public}s", batteryInfo_.GetCapacity(),
244         batteryInfo_.GetVoltage(), batteryInfo_.GetTemperature(), batteryInfo_.GetHealthState(),
245         batteryInfo_.GetPluggedType(), batteryInfo_.GetPluggedMaxCurrent(), batteryInfo_.GetPluggedMaxVoltage(),
246         batteryInfo_.GetChargeState(), batteryInfo_.GetChargeCounter(), batteryInfo_.IsPresent(),
247         batteryInfo_.GetTechnology().c_str(), batteryInfo_.GetNowCurrent(), batteryInfo_.GetTotalEnergy(),
248         batteryInfo_.GetCurAverage(), batteryInfo_.GetRemainEnergy(), batteryInfo_.GetChargeType(),
249         batteryInfo_.GetUevent().c_str());
250 
251     batteryLight_.UpdateColor(batteryInfo_.GetChargeState(), batteryInfo_.GetCapacity());
252     WakeupDevice(batteryInfo_.GetPluggedType());
253     CalculateRemainingChargeTime(batteryInfo_.GetCapacity(), batteryInfo_.GetChargeState());
254 
255     batteryNotify_->PublishEvents(batteryInfo_);
256     HandleTemperature(batteryInfo_.GetTemperature());
257     HandleCapacity(batteryInfo_.GetCapacity(), batteryInfo_.GetChargeState());
258     lastBatteryInfo_ = batteryInfo_;
259 }
260 
RegisterHdiStatusListener()261 bool BatteryService::RegisterHdiStatusListener()
262 {
263     hdiServiceMgr_ = OHOS::HDI::ServiceManager::V1_0::IServiceManager::Get();
264     if (hdiServiceMgr_ == nullptr) {
265         BATTERY_HILOGW(COMP_SVC, "hdi service manager is nullptr, Try again after %{public}u second", RETRY_TIME);
266         FFRTTask retryTask = [this] {
267             return RegisterHdiStatusListener();
268         };
269         FFRTUtils::SubmitDelayTask(retryTask, RETRY_TIME, g_queue);
270         return false;
271     }
272 
273     hdiServStatListener_ = new HdiServiceStatusListener(HdiServiceStatusListener::StatusCallback(
274         [this](const OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) {
275             RETURN_IF(status.serviceName != BATTERY_HDI_NAME || status.deviceClass != DEVICE_CLASS_DEFAULT);
276 
277             std::lock_guard<std::shared_mutex> lock(mutex_);
278             if (status.status == SERVIE_STATUS_START) {
279                 FFRTTask task = [this] {
280                     (void)RegisterBatteryHdiCallback();
281 #ifdef BATTERY_MANAGER_SET_LOW_CAPACITY_THRESHOLD
282                     SetLowCapacityThreshold();
283 #endif
284                     InitBatteryInfo();
285                     return;
286                 };
287                 FFRTUtils::SubmitTask(task);
288                 BATTERY_HILOGD(COMP_SVC, "battery interface service start");
289             } else if (status.status == SERVIE_STATUS_STOP && iBatteryInterface_) {
290                 iBatteryInterface_->UnRegister();
291                 iBatteryInterface_ = nullptr;
292                 BATTERY_HILOGW(COMP_SVC, "battery interface service stop, unregister interface");
293             }
294         }
295     ));
296 
297     int32_t status = hdiServiceMgr_->RegisterServiceStatusListener(hdiServStatListener_, DEVICE_CLASS_DEFAULT);
298     if (status != ERR_OK) {
299         BATTERY_HILOGW(COMP_SVC, "Register hdi failed, Try again after %{public}u second", RETRY_TIME);
300         FFRTTask retryTask = [this] {
301             return RegisterHdiStatusListener();
302         };
303         FFRTUtils::SubmitDelayTask(retryTask, RETRY_TIME, g_queue);
304         return false;
305     }
306     return true;
307 }
308 
OnStop()309 void BatteryService::OnStop()
310 {
311     if (!ready_) {
312         return;
313     }
314     ready_ = false;
315     isBootCompleted_ = false;
316 
317     std::lock_guard<std::shared_mutex> lock(mutex_);
318     if (iBatteryInterface_ != nullptr) {
319         iBatteryInterface_->UnRegister();
320         iBatteryInterface_ = nullptr;
321     }
322     if (hdiServiceMgr_ != nullptr) {
323         hdiServiceMgr_->UnregisterServiceStatusListener(hdiServStatListener_);
324         hdiServiceMgr_ = nullptr;
325     }
326 }
327 
IsLastPlugged()328 bool BatteryService::IsLastPlugged()
329 {
330     if (g_lastPluggedType != BatteryPluggedType::PLUGGED_TYPE_NONE &&
331         g_lastPluggedType != BatteryPluggedType::PLUGGED_TYPE_BUTT) {
332         return true;
333     }
334     return false;
335 }
336 
IsNowPlugged(BatteryPluggedType pluggedType)337 bool BatteryService::IsNowPlugged(BatteryPluggedType pluggedType)
338 {
339     if (pluggedType != BatteryPluggedType::PLUGGED_TYPE_NONE &&
340         pluggedType != BatteryPluggedType::PLUGGED_TYPE_BUTT) {
341         return true;
342     }
343     return false;
344 }
345 
IsPlugged(BatteryPluggedType pluggedType)346 bool BatteryService::IsPlugged(BatteryPluggedType pluggedType)
347 {
348     if (!IsLastPlugged() && IsNowPlugged(pluggedType)) {
349         return true;
350     }
351     return false;
352 }
353 
IsUnplugged(BatteryPluggedType pluggedType)354 bool BatteryService::IsUnplugged(BatteryPluggedType pluggedType)
355 {
356     if (IsLastPlugged() && !IsNowPlugged(pluggedType)) {
357         return true;
358     }
359     return false;
360 }
361 
IsCharging(BatteryChargeState chargeState)362 bool BatteryService::IsCharging(BatteryChargeState chargeState)
363 {
364     return chargeState == BatteryChargeState::CHARGE_STATE_ENABLE;
365 }
366 
IsInExtremePowerSaveMode()367 bool BatteryService::IsInExtremePowerSaveMode()
368 {
369     PowerMode mode = PowerMgrClient::GetInstance().GetDeviceMode();
370     return mode == PowerMode::EXTREME_POWER_SAVE_MODE;
371 }
372 
WakeupDevice(BatteryPluggedType pluggedType)373 void BatteryService::WakeupDevice(BatteryPluggedType pluggedType)
374 {
375     if (IsPlugged(pluggedType) || IsUnplugged(pluggedType)) {
376         PowerMgrClient::GetInstance().WakeupDevice();
377     }
378     g_lastPluggedType = pluggedType;
379 }
380 
HandleTemperature(int32_t temperature)381 void BatteryService::HandleTemperature(int32_t temperature)
382 {
383     if (((temperature <= lowTemperature_) || (temperature >= highTemperature_)) &&
384         (highTemperature_ != lowTemperature_)) {
385         PowerMgrClient::GetInstance().ShutDownDevice("TemperatureOutOfRange");
386     }
387 }
388 
HandleCapacity(int32_t capacity,BatteryChargeState chargeState)389 void BatteryService::HandleCapacity(int32_t capacity, BatteryChargeState chargeState)
390 {
391     if ((capacity <= shutdownCapacityThreshold_) &&
392         (g_lowCapacityShutdownHandle == nullptr) &&
393         (!IsCharging(chargeState))) {
394         BATTERY_HILOGI(COMP_SVC, "HandleCapacity begin to submit task");
395         FFRTTask task = [&] {
396             if (!IsInExtremePowerSaveMode()) {
397                 BATTERY_HILOGI(COMP_SVC, "HandleCapacity begin to shutdown");
398                 PowerMgrClient::GetInstance().ShutDownDevice("LowCapacity");
399             }
400         };
401         g_lowCapacityShutdownHandle = FFRTUtils::SubmitDelayTask(task, SHUTDOWN_DELAY_TIME_MS, g_queue);
402     }
403 
404     if (IsCharging(chargeState) && g_lowCapacityShutdownHandle != nullptr) {
405         BATTERY_HILOGI(COMP_SVC, "HandleCapacity cancel shutdown task");
406         FFRTUtils::CancelTask(g_lowCapacityShutdownHandle, g_queue);
407         g_lowCapacityShutdownHandle = nullptr;
408     }
409 }
410 
GetCapacity()411 int32_t BatteryService::GetCapacity()
412 {
413     if (isMockCapacity_) {
414         BATTERY_HILOGD(FEATURE_BATT_INFO, "Return mock battery capacity");
415         return batteryInfo_.GetCapacity();
416     }
417     std::shared_lock<std::shared_mutex> lock(mutex_);
418     int32_t capacity = BATTERY_FULL_CAPACITY;
419     if (iBatteryInterface_ == nullptr) {
420         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
421         return capacity;
422     }
423     iBatteryInterface_->GetCapacity(capacity);
424     return capacity;
425 }
426 
ChangePath(const std::string path)427 bool BatteryService::ChangePath(const std::string path)
428 {
429     BATTERY_HILOGD(FEATURE_BATT_INFO, "Enter");
430     std::shared_lock<std::shared_mutex> lock(mutex_);
431     if (iBatteryInterface_ == nullptr) {
432         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
433         return false;
434     }
435     iBatteryInterface_->ChangePath(path);
436     return true;
437 }
438 
439 #ifdef BATTERY_MANAGER_SET_LOW_CAPACITY_THRESHOLD
SetLowCapacityThreshold()440 void BatteryService::SetLowCapacityThreshold()
441 {
442     const std::string thers = "low_battery_thers";
443     if (iBatteryInterface_ == nullptr) {
444             BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
445         return;
446     }
447     BATTERY_HILOGI(FEATURE_BATT_INFO, "set low capacity thres: shutdownCapacityThreshold_ = %{public}d",
448         shutdownCapacityThreshold_);
449     iBatteryInterface_->SetBatteryConfig(thers, std::to_string(shutdownCapacityThreshold_));
450 }
451 #endif
452 
SetBatteryConfig(const std::string & sceneName,const std::string & value)453 BatteryError BatteryService::SetBatteryConfig(const std::string& sceneName, const std::string& value)
454 {
455     if (!Permission::IsSystem() || !Permission::IsNativePermissionGranted("ohos.permission.POWER_OPTIMIZATION")) {
456         BATTERY_HILOGI(FEATURE_BATT_INFO, "SetBatteryConfig failed, System permission intercept");
457         return BatteryError::ERR_SYSTEM_API_DENIED;
458     }
459 
460     BATTERY_HILOGD(FEATURE_BATT_INFO, "Enter SetBatteryConfig");
461     std::shared_lock<std::shared_mutex> lock(mutex_);
462     if (iBatteryInterface_ == nullptr) {
463         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
464         return BatteryError::ERR_FAILURE;
465     }
466     return iBatteryInterface_->SetBatteryConfig(sceneName, value) == ERR_OK ?
467         BatteryError::ERR_OK : BatteryError::ERR_FAILURE;
468 }
469 
GetBatteryConfig(const std::string & sceneName,std::string & result)470 BatteryError BatteryService::GetBatteryConfig(const std::string& sceneName, std::string& result)
471 {
472     if (!Permission::IsSystem()) {
473         BATTERY_HILOGI(FEATURE_BATT_INFO, "GetBatteryConfig failed, System permission intercept");
474         return BatteryError::ERR_SYSTEM_API_DENIED;
475     }
476 
477     BATTERY_HILOGD(FEATURE_BATT_INFO, "Enter GetBatteryConfig");
478     std::shared_lock<std::shared_mutex> lock(mutex_);
479     if (iBatteryInterface_ == nullptr) {
480         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
481         return BatteryError::ERR_FAILURE;
482     }
483 
484     int32_t ret = iBatteryInterface_->GetBatteryConfig(sceneName, result);
485     if (ret != ERR_OK) {
486         BATTERY_HILOGE(FEATURE_BATT_INFO, "get charge config failed, key:%{public}s", sceneName.c_str());
487         return BatteryError::ERR_FAILURE;
488     }
489 
490     return BatteryError::ERR_OK;
491 }
492 
IsBatteryConfigSupported(const std::string & sceneName,bool & result)493 BatteryError BatteryService::IsBatteryConfigSupported(const std::string& sceneName, bool& result)
494 {
495     if (!Permission::IsSystem()) {
496         BATTERY_HILOGI(FEATURE_BATT_INFO, "IsBatteryConfigSupported failed, System permission intercept");
497         return BatteryError::ERR_SYSTEM_API_DENIED;
498     }
499 
500     BATTERY_HILOGD(FEATURE_BATT_INFO, "Enter IsBatteryConfigSupported");
501     std::shared_lock<std::shared_mutex> lock(mutex_);
502     if (iBatteryInterface_ == nullptr) {
503         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
504         return BatteryError::ERR_FAILURE;
505     }
506 
507     int32_t ret = iBatteryInterface_->IsBatteryConfigSupported(sceneName, result);
508     if (ret != ERR_OK) {
509         BATTERY_HILOGE(FEATURE_BATT_INFO, "get support charge config failed, key:%{public}s", sceneName.c_str());
510         return BatteryError::ERR_FAILURE;
511     }
512     return BatteryError::ERR_OK;
513 }
514 
GetChargingStatus()515 BatteryChargeState BatteryService::GetChargingStatus()
516 {
517     if (isMockUnplugged_) {
518         BATTERY_HILOGD(FEATURE_BATT_INFO, "Return mock charge status");
519         return batteryInfo_.GetChargeState();
520     }
521     std::shared_lock<std::shared_mutex> lock(mutex_);
522     V2_0::BatteryChargeState chargeState = V2_0::BatteryChargeState(0);
523     if (iBatteryInterface_ == nullptr) {
524         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
525         return BatteryChargeState(chargeState);
526     }
527     iBatteryInterface_->GetChargeState(chargeState);
528     return BatteryChargeState(chargeState);
529 }
530 
GetHealthStatus()531 BatteryHealthState BatteryService::GetHealthStatus()
532 {
533     BATTERY_HILOGD(FEATURE_BATT_INFO, "Enter");
534     std::shared_lock<std::shared_mutex> lock(mutex_);
535     V2_0::BatteryHealthState healthState = V2_0::BatteryHealthState(0);
536     if (iBatteryInterface_ == nullptr) {
537         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
538         return BatteryHealthState(healthState);
539     }
540 
541     iBatteryInterface_->GetHealthState(healthState);
542     return BatteryHealthState(healthState);
543 }
544 
GetPluggedType()545 BatteryPluggedType BatteryService::GetPluggedType()
546 {
547     if (isMockUnplugged_) {
548         BATTERY_HILOGD(FEATURE_BATT_INFO, "Return mock plugged type");
549         return batteryInfo_.GetPluggedType();
550     }
551     std::shared_lock<std::shared_mutex> lock(mutex_);
552     V2_0::BatteryPluggedType pluggedType = V2_0::BatteryPluggedType(0);
553     if (iBatteryInterface_ == nullptr) {
554         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
555         return BatteryPluggedType(pluggedType);
556     }
557     iBatteryInterface_->GetPluggedType(pluggedType);
558     return BatteryPluggedType(pluggedType);
559 }
560 
GetVoltage()561 int32_t BatteryService::GetVoltage()
562 {
563     std::shared_lock<std::shared_mutex> lock(mutex_);
564     if (iBatteryInterface_ == nullptr) {
565         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
566         return ERR_NO_INIT;
567     }
568     int32_t voltage = INVALID_BATT_INT_VALUE;
569     iBatteryInterface_->GetVoltage(voltage);
570     return voltage;
571 }
572 
GetPresent()573 bool BatteryService::GetPresent()
574 {
575     std::shared_lock<std::shared_mutex> lock(mutex_);
576     bool present = false;
577     if (iBatteryInterface_ == nullptr) {
578         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
579         return present;
580     }
581 
582     iBatteryInterface_->GetPresent(present);
583     return present;
584 }
585 
GetTechnology()586 std::string BatteryService::GetTechnology()
587 {
588     std::shared_lock<std::shared_mutex> lock(mutex_);
589     if (iBatteryInterface_ == nullptr) {
590         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
591         return "";
592     }
593 
594     std::string technology;
595     iBatteryInterface_->GetTechnology(technology);
596     return technology;
597 }
598 
GetBatteryTemperature()599 int32_t BatteryService::GetBatteryTemperature()
600 {
601     std::shared_lock<std::shared_mutex> lock(mutex_);
602     if (iBatteryInterface_ == nullptr) {
603         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
604         return batteryInfo_.GetTemperature();
605     }
606     int32_t temperature = INVALID_BATT_INT_VALUE;
607     iBatteryInterface_->GetTemperature(temperature);
608     return temperature;
609 }
610 
GetTotalEnergy()611 int32_t BatteryService::GetTotalEnergy()
612 {
613     int32_t totalEnergy = INVALID_BATT_INT_VALUE;
614     if (!Permission::IsSystem()) {
615         BATTERY_HILOGD(FEATURE_BATT_INFO, "GetTotalEnergy totalEnergy: %{public}d", totalEnergy);
616         return totalEnergy;
617     }
618     std::shared_lock<std::shared_mutex> lock(mutex_);
619     if (iBatteryInterface_ == nullptr) {
620         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
621         return batteryInfo_.GetTotalEnergy();
622     }
623     iBatteryInterface_->GetTotalEnergy(totalEnergy);
624     return totalEnergy;
625 }
626 
GetCurrentAverage()627 int32_t BatteryService::GetCurrentAverage()
628 {
629     std::shared_lock<std::shared_mutex> lock(mutex_);
630     if (iBatteryInterface_ == nullptr) {
631         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
632         return batteryInfo_.GetCurAverage();
633     }
634     int32_t curAverage = INVALID_BATT_INT_VALUE;
635     iBatteryInterface_->GetCurrentAverage(curAverage);
636     return curAverage;
637 }
638 
GetNowCurrent()639 int32_t BatteryService::GetNowCurrent()
640 {
641     int32_t nowCurr = INVALID_BATT_INT_VALUE;
642     std::shared_lock<std::shared_mutex> lock(mutex_);
643     if (iBatteryInterface_ == nullptr) {
644         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
645         return batteryInfo_.GetNowCurrent();
646     }
647     iBatteryInterface_->GetCurrentNow(nowCurr);
648     return nowCurr;
649 }
650 
GetRemainEnergy()651 int32_t BatteryService::GetRemainEnergy()
652 {
653     int32_t remainEnergy = INVALID_BATT_INT_VALUE;
654     if (!Permission::IsSystem()) {
655         BATTERY_HILOGD(FEATURE_BATT_INFO, "GetRemainEnergy remainEnergy: %{public}d", remainEnergy);
656         return remainEnergy;
657     }
658     std::shared_lock<std::shared_mutex> lock(mutex_);
659     if (iBatteryInterface_ == nullptr) {
660         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
661         return batteryInfo_.GetRemainEnergy();
662     }
663     iBatteryInterface_->GetRemainEnergy(remainEnergy);
664     return remainEnergy;
665 }
666 
GetChargeType()667 ChargeType BatteryService::GetChargeType()
668 {
669     std::shared_lock<std::shared_mutex> lock(mutex_);
670     V2_0::ChargeType chargeType = V2_0::ChargeType::CHARGE_TYPE_NONE;
671     if (iBatteryInterface_ == nullptr) {
672         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
673         return ChargeType(chargeType);
674     }
675 
676     iBatteryInterface_->GetChargeType(chargeType);
677     return ChargeType(chargeType);
678 }
679 
CalculateRemainingChargeTime(int32_t capacity,BatteryChargeState chargeState)680 void BatteryService::CalculateRemainingChargeTime(int32_t capacity, BatteryChargeState chargeState)
681 {
682     if (capacity > BATTERY_FULL_CAPACITY) {
683         BATTERY_HILOGE(FEATURE_BATT_INFO, "capacity error");
684         return;
685     }
686 
687     if (chargeState != BatteryChargeState::CHARGE_STATE_ENABLE) {
688         remainTime_ = 0;
689         chargeFlag_ = false;
690         return;
691     }
692 
693     if (!chargeFlag_) {
694         lastCapacity_ = capacity;
695         lastTime_ = GetCurrentTime();
696         chargeFlag_ = true;
697     }
698 
699     if (capacity < lastCapacity_) {
700         lastCapacity_ = capacity;
701     }
702 
703     if (((capacity - lastCapacity_) >= 1) && (lastCapacity_ >= 0) && chargeFlag_) {
704         int64_t onceTime = (GetCurrentTime() - lastTime_) / (capacity - lastCapacity_);
705         remainTime_ = (BATTERY_FULL_CAPACITY - capacity) * onceTime;
706         lastCapacity_ = capacity;
707         lastTime_ = GetCurrentTime();
708     }
709 }
710 
GetRemainingChargeTime()711 int64_t BatteryService::GetRemainingChargeTime()
712 {
713     if (!Permission::IsSystem()) {
714         BATTERY_HILOGW(FEATURE_BATT_INFO, "system permission denied.");
715         return INVALID_REMAINING_CHARGE_TIME_VALUE;
716     }
717     return remainTime_;
718 }
719 
IsCapacityLevelDefined(int32_t capacityThreshold)720 bool IsCapacityLevelDefined(int32_t capacityThreshold)
721 {
722     return capacityThreshold != INVALID_BATT_INT_VALUE;
723 }
724 
GetCapacityLevel()725 BatteryCapacityLevel BatteryService::GetCapacityLevel()
726 {
727     BatteryCapacityLevel batteryCapacityLevel = BatteryCapacityLevel::LEVEL_NONE;
728     int32_t capacity = GetCapacity();
729     if (IsCapacityLevelDefined(shutdownCapacityThreshold_) && capacity > 0 && capacity <= shutdownCapacityThreshold_) {
730         batteryCapacityLevel = BatteryCapacityLevel::LEVEL_SHUTDOWN;
731     } else if (IsCapacityLevelDefined(criticalCapacityThreshold_) && capacity > shutdownCapacityThreshold_ &&
732         capacity <= criticalCapacityThreshold_) {
733         batteryCapacityLevel = BatteryCapacityLevel::LEVEL_CRITICAL;
734     } else if (IsCapacityLevelDefined(warningCapacityThreshold_) && capacity > criticalCapacityThreshold_ &&
735         capacity <= warningCapacityThreshold_) {
736         batteryCapacityLevel = BatteryCapacityLevel::LEVEL_WARNING;
737     } else if (IsCapacityLevelDefined(lowCapacityThreshold_) && capacity > warningCapacityThreshold_ &&
738         capacity <= lowCapacityThreshold_) {
739         batteryCapacityLevel = BatteryCapacityLevel::LEVEL_LOW;
740     } else if (IsCapacityLevelDefined(normalCapacityThreshold_) && capacity > lowCapacityThreshold_ &&
741         capacity <= normalCapacityThreshold_) {
742         batteryCapacityLevel = BatteryCapacityLevel::LEVEL_NORMAL;
743     } else if (IsCapacityLevelDefined(highCapacityThreshold_) && capacity > normalCapacityThreshold_ &&
744         capacity <= highCapacityThreshold_) {
745         batteryCapacityLevel = BatteryCapacityLevel::LEVEL_HIGH;
746     } else if (IsCapacityLevelDefined(fullCapacityThreshold_) && capacity > highCapacityThreshold_ &&
747         capacity <= fullCapacityThreshold_) {
748         batteryCapacityLevel = BatteryCapacityLevel::LEVEL_FULL;
749     }
750     return batteryCapacityLevel;
751 }
752 
Dump(int32_t fd,const std::vector<std::u16string> & args)753 int32_t BatteryService::Dump(int32_t fd, const std::vector<std::u16string> &args)
754 {
755     if (!isBootCompleted_) {
756         return ERR_NO_INIT;
757     }
758     if (!Permission::IsSystem()) {
759         return ERR_PERMISSION_DENIED;
760     }
761     BatteryDump& batteryDump = BatteryDump::GetInstance();
762     if ((args.empty()) || (args[0].compare(u"-h") == 0)) {
763         batteryDump.DumpBatteryHelp(fd);
764         return ERR_OK;
765     }
766     bool getBatteryInfo = batteryDump.GetBatteryInfo(fd, g_service, args);
767     bool unplugged = batteryDump.MockUnplugged(fd, g_service, args);
768     bool mockedCapacity = batteryDump.MockCapacity(fd, g_service, args);
769     bool mockedUevent = batteryDump.MockUevent(fd, g_service, args);
770     bool reset = batteryDump.Reset(fd, g_service, args);
771     bool total = getBatteryInfo + unplugged + mockedCapacity + mockedUevent + reset;
772     if (!total) {
773         dprintf(fd, "cmd param is invalid\n");
774         batteryDump.DumpBatteryHelp(fd);
775         return ERR_NO_INIT;
776     }
777 
778     return ERR_OK;
779 }
780 
MockUnplugged()781 void BatteryService::MockUnplugged()
782 {
783     std::shared_lock<std::shared_mutex> lock(mutex_);
784     if (!iBatteryInterface_) {
785         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
786         return;
787     }
788     isMockUnplugged_ = true;
789     V2_0::BatteryInfo event;
790     iBatteryInterface_->GetBatteryInfo(event);
791     ConvertingEvent(event);
792     batteryInfo_.SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_NONE);
793     batteryInfo_.SetPluggedMaxCurrent(0);
794     batteryInfo_.SetPluggedMaxVoltage(0);
795     batteryInfo_.SetChargeState(BatteryChargeState::CHARGE_STATE_NONE);
796     HandleBatteryInfo();
797 }
798 
IsMockUnplugged()799 bool BatteryService::IsMockUnplugged()
800 {
801     return isMockUnplugged_;
802 }
803 
MockCapacity(int32_t capacity)804 void BatteryService::MockCapacity(int32_t capacity)
805 {
806     std::shared_lock<std::shared_mutex> lock(mutex_);
807     if (!iBatteryInterface_) {
808         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
809         return;
810     }
811     isMockCapacity_ = true;
812     V2_0::BatteryInfo event;
813     iBatteryInterface_->GetBatteryInfo(event);
814     ConvertingEvent(event);
815     batteryInfo_.SetCapacity(capacity);
816     HandleBatteryInfo();
817 }
818 
IsMockCapacity()819 bool BatteryService::IsMockCapacity()
820 {
821     return isMockCapacity_;
822 }
823 
MockUevent(const std::string & uevent)824 void BatteryService::MockUevent(const std::string& uevent)
825 {
826     std::shared_lock<std::shared_mutex> lock(mutex_);
827     if (!iBatteryInterface_) {
828         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
829         return;
830     }
831     isMockUevent_ = true;
832     V2_0::BatteryInfo event;
833     iBatteryInterface_->GetBatteryInfo(event);
834     ConvertingEvent(event);
835     batteryInfo_.SetUevent(uevent);
836     HandleBatteryInfo();
837 }
838 
Reset()839 void BatteryService::Reset()
840 {
841     std::shared_lock<std::shared_mutex> lock(mutex_);
842     if (!iBatteryInterface_) {
843         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
844         return;
845     }
846     isMockUnplugged_ = false;
847     isMockCapacity_ = false;
848     isMockUevent_ = false;
849     V2_0::BatteryInfo event;
850     iBatteryInterface_->GetBatteryInfo(event);
851     ConvertingEvent(event);
852     HandleBatteryInfo();
853 }
854 
VibratorInit()855 void BatteryService::VibratorInit()
856 {
857     std::shared_ptr<PowerVibrator> vibrator = PowerVibrator::GetInstance();
858     vibrator->LoadConfig(BATTERY_VIBRATOR_CONFIG_FILE,
859         VENDOR_BATTERY_VIBRATOR_CONFIG_FILE, SYSTEM_BATTERY_VIBRATOR_CONFIG_FILE);
860 }
861 } // namespace PowerMgr
862 } // namespace OHOS
863