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