1 /* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "healthd" 18 19 #include <healthd/healthd.h> 20 #include <healthd/BatteryMonitor.h> 21 22 #include <dirent.h> 23 #include <errno.h> 24 #include <fcntl.h> 25 #include <stdio.h> 26 #include <stdlib.h> 27 #include <sys/types.h> 28 #include <unistd.h> 29 #include <memory> 30 31 #include <android-base/file.h> 32 #include <android-base/parseint.h> 33 #include <android-base/strings.h> 34 #include <batteryservice/BatteryService.h> 35 #include <cutils/klog.h> 36 #include <cutils/properties.h> 37 #include <utils/Errors.h> 38 #include <utils/String8.h> 39 #include <utils/Vector.h> 40 41 #define POWER_SUPPLY_SUBSYSTEM "power_supply" 42 #define POWER_SUPPLY_SYSFS_PATH "/sys/class/" POWER_SUPPLY_SUBSYSTEM 43 #define FAKE_BATTERY_CAPACITY 42 44 #define FAKE_BATTERY_TEMPERATURE 424 45 #define ALWAYS_PLUGGED_CAPACITY 100 46 #define MILLION 1.0e6 47 #define DEFAULT_VBUS_VOLTAGE 5000000 48 49 namespace android { 50 51 struct sysfsStringEnumMap { 52 const char* s; 53 int val; 54 }; 55 56 static int mapSysfsString(const char* str, 57 struct sysfsStringEnumMap map[]) { 58 for (int i = 0; map[i].s; i++) 59 if (!strcmp(str, map[i].s)) 60 return map[i].val; 61 62 return -1; 63 } 64 65 static void initBatteryProperties(BatteryProperties* props) { 66 props->chargerAcOnline = false; 67 props->chargerUsbOnline = false; 68 props->chargerWirelessOnline = false; 69 props->maxChargingCurrent = 0; 70 props->maxChargingVoltage = 0; 71 props->batteryStatus = BATTERY_STATUS_UNKNOWN; 72 props->batteryHealth = BATTERY_HEALTH_UNKNOWN; 73 props->batteryPresent = false; 74 props->batteryLevel = 0; 75 props->batteryVoltage = 0; 76 props->batteryTemperature = 0; 77 props->batteryCurrent = 0; 78 props->batteryCycleCount = 0; 79 props->batteryFullCharge = 0; 80 props->batteryChargeCounter = 0; 81 props->batteryTechnology.clear(); 82 } 83 84 BatteryMonitor::BatteryMonitor() : mHealthdConfig(nullptr), mBatteryDevicePresent(false), 85 mAlwaysPluggedDevice(false), mBatteryFixedCapacity(0), mBatteryFixedTemperature(0) { 86 initBatteryProperties(&props); 87 } 88 89 int BatteryMonitor::getBatteryStatus(const char* status) { 90 int ret; 91 struct sysfsStringEnumMap batteryStatusMap[] = { 92 { "Unknown", BATTERY_STATUS_UNKNOWN }, 93 { "Charging", BATTERY_STATUS_CHARGING }, 94 { "Discharging", BATTERY_STATUS_DISCHARGING }, 95 { "Not charging", BATTERY_STATUS_NOT_CHARGING }, 96 { "Full", BATTERY_STATUS_FULL }, 97 { NULL, 0 }, 98 }; 99 100 ret = mapSysfsString(status, batteryStatusMap); 101 if (ret < 0) { 102 KLOG_WARNING(LOG_TAG, "Unknown battery status '%s'\n", status); 103 ret = BATTERY_STATUS_UNKNOWN; 104 } 105 106 return ret; 107 } 108 109 int BatteryMonitor::getBatteryHealth(const char* status) { 110 int ret; 111 struct sysfsStringEnumMap batteryHealthMap[] = { 112 { "Unknown", BATTERY_HEALTH_UNKNOWN }, 113 { "Good", BATTERY_HEALTH_GOOD }, 114 { "Overheat", BATTERY_HEALTH_OVERHEAT }, 115 { "Dead", BATTERY_HEALTH_DEAD }, 116 { "Over voltage", BATTERY_HEALTH_OVER_VOLTAGE }, 117 { "Unspecified failure", BATTERY_HEALTH_UNSPECIFIED_FAILURE }, 118 { "Cold", BATTERY_HEALTH_COLD }, 119 // battery health values from JEITA spec 120 { "Warm", BATTERY_HEALTH_GOOD }, 121 { "Cool", BATTERY_HEALTH_GOOD }, 122 { "Hot", BATTERY_HEALTH_OVERHEAT }, 123 { NULL, 0 }, 124 }; 125 126 ret = mapSysfsString(status, batteryHealthMap); 127 if (ret < 0) { 128 KLOG_WARNING(LOG_TAG, "Unknown battery health '%s'\n", status); 129 ret = BATTERY_HEALTH_UNKNOWN; 130 } 131 132 return ret; 133 } 134 135 int BatteryMonitor::readFromFile(const String8& path, std::string* buf) { 136 if (android::base::ReadFileToString(path.c_str(), buf)) { 137 *buf = android::base::Trim(*buf); 138 } 139 return buf->length(); 140 } 141 142 BatteryMonitor::PowerSupplyType BatteryMonitor::readPowerSupplyType(const String8& path) { 143 std::string buf; 144 BatteryMonitor::PowerSupplyType ret; 145 struct sysfsStringEnumMap supplyTypeMap[] = { 146 { "Unknown", ANDROID_POWER_SUPPLY_TYPE_UNKNOWN }, 147 { "Battery", ANDROID_POWER_SUPPLY_TYPE_BATTERY }, 148 { "UPS", ANDROID_POWER_SUPPLY_TYPE_AC }, 149 { "Mains", ANDROID_POWER_SUPPLY_TYPE_AC }, 150 { "USB", ANDROID_POWER_SUPPLY_TYPE_USB }, 151 { "USB_DCP", ANDROID_POWER_SUPPLY_TYPE_AC }, 152 { "USB_HVDCP", ANDROID_POWER_SUPPLY_TYPE_AC }, 153 { "USB_CDP", ANDROID_POWER_SUPPLY_TYPE_AC }, 154 { "USB_ACA", ANDROID_POWER_SUPPLY_TYPE_AC }, 155 { "USB_C", ANDROID_POWER_SUPPLY_TYPE_AC }, 156 { "USB_PD", ANDROID_POWER_SUPPLY_TYPE_AC }, 157 { "USB_PD_DRP", ANDROID_POWER_SUPPLY_TYPE_USB }, 158 { "Wireless", ANDROID_POWER_SUPPLY_TYPE_WIRELESS }, 159 { NULL, 0 }, 160 }; 161 162 if (readFromFile(path, &buf) <= 0) 163 return ANDROID_POWER_SUPPLY_TYPE_UNKNOWN; 164 165 ret = (BatteryMonitor::PowerSupplyType)mapSysfsString(buf.c_str(), supplyTypeMap); 166 if (ret < 0) { 167 KLOG_WARNING(LOG_TAG, "Unknown power supply type '%s'\n", buf.c_str()); 168 ret = ANDROID_POWER_SUPPLY_TYPE_UNKNOWN; 169 } 170 171 return ret; 172 } 173 174 bool BatteryMonitor::getBooleanField(const String8& path) { 175 std::string buf; 176 bool value = false; 177 178 if (readFromFile(path, &buf) > 0) 179 if (buf[0] != '0') 180 value = true; 181 182 return value; 183 } 184 185 int BatteryMonitor::getIntField(const String8& path) { 186 std::string buf; 187 int value = 0; 188 189 if (readFromFile(path, &buf) > 0) 190 android::base::ParseInt(buf, &value); 191 192 return value; 193 } 194 195 bool BatteryMonitor::update(void) { 196 bool logthis; 197 198 initBatteryProperties(&props); 199 200 if (!mHealthdConfig->batteryPresentPath.isEmpty()) 201 props.batteryPresent = getBooleanField(mHealthdConfig->batteryPresentPath); 202 else 203 props.batteryPresent = mBatteryDevicePresent; 204 205 props.batteryLevel = mBatteryFixedCapacity ? 206 mBatteryFixedCapacity : 207 getIntField(mHealthdConfig->batteryCapacityPath); 208 props.batteryVoltage = getIntField(mHealthdConfig->batteryVoltagePath) / 1000; 209 210 if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) 211 props.batteryCurrent = getIntField(mHealthdConfig->batteryCurrentNowPath) / 1000; 212 213 if (!mHealthdConfig->batteryFullChargePath.isEmpty()) 214 props.batteryFullCharge = getIntField(mHealthdConfig->batteryFullChargePath); 215 216 if (!mHealthdConfig->batteryCycleCountPath.isEmpty()) 217 props.batteryCycleCount = getIntField(mHealthdConfig->batteryCycleCountPath); 218 219 if (!mHealthdConfig->batteryChargeCounterPath.isEmpty()) 220 props.batteryChargeCounter = getIntField(mHealthdConfig->batteryChargeCounterPath); 221 222 props.batteryTemperature = mBatteryFixedTemperature ? 223 mBatteryFixedTemperature : 224 getIntField(mHealthdConfig->batteryTemperaturePath); 225 226 // For devices which do not have battery and are always plugged 227 // into power souce. 228 if (mAlwaysPluggedDevice) { 229 props.chargerAcOnline = true; 230 props.batteryPresent = true; 231 props.batteryStatus = BATTERY_STATUS_CHARGING; 232 props.batteryHealth = BATTERY_HEALTH_GOOD; 233 } 234 235 std::string buf; 236 237 if (readFromFile(mHealthdConfig->batteryStatusPath, &buf) > 0) 238 props.batteryStatus = getBatteryStatus(buf.c_str()); 239 240 if (readFromFile(mHealthdConfig->batteryHealthPath, &buf) > 0) 241 props.batteryHealth = getBatteryHealth(buf.c_str()); 242 243 if (readFromFile(mHealthdConfig->batteryTechnologyPath, &buf) > 0) 244 props.batteryTechnology = String8(buf.c_str()); 245 246 unsigned int i; 247 double MaxPower = 0; 248 249 for (i = 0; i < mChargerNames.size(); i++) { 250 String8 path; 251 path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, 252 mChargerNames[i].string()); 253 if (getIntField(path)) { 254 path.clear(); 255 path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH, 256 mChargerNames[i].string()); 257 switch(readPowerSupplyType(path)) { 258 case ANDROID_POWER_SUPPLY_TYPE_AC: 259 props.chargerAcOnline = true; 260 break; 261 case ANDROID_POWER_SUPPLY_TYPE_USB: 262 props.chargerUsbOnline = true; 263 break; 264 case ANDROID_POWER_SUPPLY_TYPE_WIRELESS: 265 props.chargerWirelessOnline = true; 266 break; 267 default: 268 KLOG_WARNING(LOG_TAG, "%s: Unknown power supply type\n", 269 mChargerNames[i].string()); 270 } 271 path.clear(); 272 path.appendFormat("%s/%s/current_max", POWER_SUPPLY_SYSFS_PATH, 273 mChargerNames[i].string()); 274 int ChargingCurrent = 275 (access(path.string(), R_OK) == 0) ? getIntField(path) : 0; 276 277 path.clear(); 278 path.appendFormat("%s/%s/voltage_max", POWER_SUPPLY_SYSFS_PATH, 279 mChargerNames[i].string()); 280 281 int ChargingVoltage = 282 (access(path.string(), R_OK) == 0) ? getIntField(path) : 283 DEFAULT_VBUS_VOLTAGE; 284 285 double power = ((double)ChargingCurrent / MILLION) * 286 ((double)ChargingVoltage / MILLION); 287 if (MaxPower < power) { 288 props.maxChargingCurrent = ChargingCurrent; 289 props.maxChargingVoltage = ChargingVoltage; 290 MaxPower = power; 291 } 292 } 293 } 294 295 logthis = !healthd_board_battery_update(&props); 296 297 if (logthis) { 298 char dmesgline[256]; 299 size_t len; 300 if (props.batteryPresent) { 301 snprintf(dmesgline, sizeof(dmesgline), 302 "battery l=%d v=%d t=%s%d.%d h=%d st=%d", 303 props.batteryLevel, props.batteryVoltage, 304 props.batteryTemperature < 0 ? "-" : "", 305 abs(props.batteryTemperature / 10), 306 abs(props.batteryTemperature % 10), props.batteryHealth, 307 props.batteryStatus); 308 309 len = strlen(dmesgline); 310 if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) { 311 len += snprintf(dmesgline + len, sizeof(dmesgline) - len, 312 " c=%d", props.batteryCurrent); 313 } 314 315 if (!mHealthdConfig->batteryFullChargePath.isEmpty()) { 316 len += snprintf(dmesgline + len, sizeof(dmesgline) - len, 317 " fc=%d", props.batteryFullCharge); 318 } 319 320 if (!mHealthdConfig->batteryCycleCountPath.isEmpty()) { 321 len += snprintf(dmesgline + len, sizeof(dmesgline) - len, 322 " cc=%d", props.batteryCycleCount); 323 } 324 } else { 325 len = snprintf(dmesgline, sizeof(dmesgline), 326 "battery none"); 327 } 328 329 snprintf(dmesgline + len, sizeof(dmesgline) - len, " chg=%s%s%s", 330 props.chargerAcOnline ? "a" : "", 331 props.chargerUsbOnline ? "u" : "", 332 props.chargerWirelessOnline ? "w" : ""); 333 334 KLOG_WARNING(LOG_TAG, "%s\n", dmesgline); 335 } 336 337 healthd_mode_ops->battery_update(&props); 338 return props.chargerAcOnline | props.chargerUsbOnline | 339 props.chargerWirelessOnline; 340 } 341 342 int BatteryMonitor::getChargeStatus() { 343 int result = BATTERY_STATUS_UNKNOWN; 344 if (!mHealthdConfig->batteryStatusPath.isEmpty()) { 345 std::string buf; 346 if (readFromFile(mHealthdConfig->batteryStatusPath, &buf) > 0) 347 result = getBatteryStatus(buf.c_str()); 348 } 349 return result; 350 } 351 352 status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) { 353 status_t ret = BAD_VALUE; 354 std::string buf; 355 356 val->valueInt64 = LONG_MIN; 357 358 switch(id) { 359 case BATTERY_PROP_CHARGE_COUNTER: 360 if (!mHealthdConfig->batteryChargeCounterPath.isEmpty()) { 361 val->valueInt64 = 362 getIntField(mHealthdConfig->batteryChargeCounterPath); 363 ret = NO_ERROR; 364 } else { 365 ret = NAME_NOT_FOUND; 366 } 367 break; 368 369 case BATTERY_PROP_CURRENT_NOW: 370 if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) { 371 val->valueInt64 = 372 getIntField(mHealthdConfig->batteryCurrentNowPath); 373 ret = NO_ERROR; 374 } else { 375 ret = NAME_NOT_FOUND; 376 } 377 break; 378 379 case BATTERY_PROP_CURRENT_AVG: 380 if (!mHealthdConfig->batteryCurrentAvgPath.isEmpty()) { 381 val->valueInt64 = 382 getIntField(mHealthdConfig->batteryCurrentAvgPath); 383 ret = NO_ERROR; 384 } else { 385 ret = NAME_NOT_FOUND; 386 } 387 break; 388 389 case BATTERY_PROP_CAPACITY: 390 if (!mHealthdConfig->batteryCapacityPath.isEmpty()) { 391 val->valueInt64 = 392 getIntField(mHealthdConfig->batteryCapacityPath); 393 ret = NO_ERROR; 394 } else { 395 ret = NAME_NOT_FOUND; 396 } 397 break; 398 399 case BATTERY_PROP_ENERGY_COUNTER: 400 if (mHealthdConfig->energyCounter) { 401 ret = mHealthdConfig->energyCounter(&val->valueInt64); 402 } else { 403 ret = NAME_NOT_FOUND; 404 } 405 break; 406 407 case BATTERY_PROP_BATTERY_STATUS: 408 if (mAlwaysPluggedDevice) { 409 val->valueInt64 = BATTERY_STATUS_CHARGING; 410 } else { 411 val->valueInt64 = getChargeStatus(); 412 } 413 ret = NO_ERROR; 414 break; 415 416 default: 417 break; 418 } 419 420 return ret; 421 } 422 423 void BatteryMonitor::dumpState(int fd) { 424 int v; 425 char vs[128]; 426 427 snprintf(vs, sizeof(vs), "ac: %d usb: %d wireless: %d current_max: %d voltage_max: %d\n", 428 props.chargerAcOnline, props.chargerUsbOnline, 429 props.chargerWirelessOnline, props.maxChargingCurrent, 430 props.maxChargingVoltage); 431 write(fd, vs, strlen(vs)); 432 snprintf(vs, sizeof(vs), "status: %d health: %d present: %d\n", 433 props.batteryStatus, props.batteryHealth, props.batteryPresent); 434 write(fd, vs, strlen(vs)); 435 snprintf(vs, sizeof(vs), "level: %d voltage: %d temp: %d\n", 436 props.batteryLevel, props.batteryVoltage, 437 props.batteryTemperature); 438 write(fd, vs, strlen(vs)); 439 440 if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) { 441 v = getIntField(mHealthdConfig->batteryCurrentNowPath); 442 snprintf(vs, sizeof(vs), "current now: %d\n", v); 443 write(fd, vs, strlen(vs)); 444 } 445 446 if (!mHealthdConfig->batteryCurrentAvgPath.isEmpty()) { 447 v = getIntField(mHealthdConfig->batteryCurrentAvgPath); 448 snprintf(vs, sizeof(vs), "current avg: %d\n", v); 449 write(fd, vs, strlen(vs)); 450 } 451 452 if (!mHealthdConfig->batteryChargeCounterPath.isEmpty()) { 453 v = getIntField(mHealthdConfig->batteryChargeCounterPath); 454 snprintf(vs, sizeof(vs), "charge counter: %d\n", v); 455 write(fd, vs, strlen(vs)); 456 } 457 458 if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) { 459 snprintf(vs, sizeof(vs), "current now: %d\n", props.batteryCurrent); 460 write(fd, vs, strlen(vs)); 461 } 462 463 if (!mHealthdConfig->batteryCycleCountPath.isEmpty()) { 464 snprintf(vs, sizeof(vs), "cycle count: %d\n", props.batteryCycleCount); 465 write(fd, vs, strlen(vs)); 466 } 467 468 if (!mHealthdConfig->batteryFullChargePath.isEmpty()) { 469 snprintf(vs, sizeof(vs), "Full charge: %d\n", props.batteryFullCharge); 470 write(fd, vs, strlen(vs)); 471 } 472 } 473 474 void BatteryMonitor::init(struct healthd_config *hc) { 475 String8 path; 476 char pval[PROPERTY_VALUE_MAX]; 477 478 mHealthdConfig = hc; 479 std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(POWER_SUPPLY_SYSFS_PATH), closedir); 480 if (dir == NULL) { 481 KLOG_ERROR(LOG_TAG, "Could not open %s\n", POWER_SUPPLY_SYSFS_PATH); 482 } else { 483 struct dirent* entry; 484 485 while ((entry = readdir(dir.get()))) { 486 const char* name = entry->d_name; 487 488 if (!strcmp(name, ".") || !strcmp(name, "..")) 489 continue; 490 491 // Look for "type" file in each subdirectory 492 path.clear(); 493 path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH, name); 494 switch(readPowerSupplyType(path)) { 495 case ANDROID_POWER_SUPPLY_TYPE_AC: 496 case ANDROID_POWER_SUPPLY_TYPE_USB: 497 case ANDROID_POWER_SUPPLY_TYPE_WIRELESS: 498 path.clear(); 499 path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, name); 500 if (access(path.string(), R_OK) == 0) 501 mChargerNames.add(String8(name)); 502 break; 503 504 case ANDROID_POWER_SUPPLY_TYPE_BATTERY: 505 mBatteryDevicePresent = true; 506 507 if (mHealthdConfig->batteryStatusPath.isEmpty()) { 508 path.clear(); 509 path.appendFormat("%s/%s/status", POWER_SUPPLY_SYSFS_PATH, 510 name); 511 if (access(path, R_OK) == 0) 512 mHealthdConfig->batteryStatusPath = path; 513 } 514 515 if (mHealthdConfig->batteryHealthPath.isEmpty()) { 516 path.clear(); 517 path.appendFormat("%s/%s/health", POWER_SUPPLY_SYSFS_PATH, 518 name); 519 if (access(path, R_OK) == 0) 520 mHealthdConfig->batteryHealthPath = path; 521 } 522 523 if (mHealthdConfig->batteryPresentPath.isEmpty()) { 524 path.clear(); 525 path.appendFormat("%s/%s/present", POWER_SUPPLY_SYSFS_PATH, 526 name); 527 if (access(path, R_OK) == 0) 528 mHealthdConfig->batteryPresentPath = path; 529 } 530 531 if (mHealthdConfig->batteryCapacityPath.isEmpty()) { 532 path.clear(); 533 path.appendFormat("%s/%s/capacity", POWER_SUPPLY_SYSFS_PATH, 534 name); 535 if (access(path, R_OK) == 0) 536 mHealthdConfig->batteryCapacityPath = path; 537 } 538 539 if (mHealthdConfig->batteryVoltagePath.isEmpty()) { 540 path.clear(); 541 path.appendFormat("%s/%s/voltage_now", 542 POWER_SUPPLY_SYSFS_PATH, name); 543 if (access(path, R_OK) == 0) { 544 mHealthdConfig->batteryVoltagePath = path; 545 } else { 546 path.clear(); 547 path.appendFormat("%s/%s/batt_vol", 548 POWER_SUPPLY_SYSFS_PATH, name); 549 if (access(path, R_OK) == 0) 550 mHealthdConfig->batteryVoltagePath = path; 551 } 552 } 553 554 if (mHealthdConfig->batteryFullChargePath.isEmpty()) { 555 path.clear(); 556 path.appendFormat("%s/%s/charge_full", 557 POWER_SUPPLY_SYSFS_PATH, name); 558 if (access(path, R_OK) == 0) 559 mHealthdConfig->batteryFullChargePath = path; 560 } 561 562 if (mHealthdConfig->batteryCurrentNowPath.isEmpty()) { 563 path.clear(); 564 path.appendFormat("%s/%s/current_now", 565 POWER_SUPPLY_SYSFS_PATH, name); 566 if (access(path, R_OK) == 0) 567 mHealthdConfig->batteryCurrentNowPath = path; 568 } 569 570 if (mHealthdConfig->batteryCycleCountPath.isEmpty()) { 571 path.clear(); 572 path.appendFormat("%s/%s/cycle_count", 573 POWER_SUPPLY_SYSFS_PATH, name); 574 if (access(path, R_OK) == 0) 575 mHealthdConfig->batteryCycleCountPath = path; 576 } 577 578 if (mHealthdConfig->batteryCurrentAvgPath.isEmpty()) { 579 path.clear(); 580 path.appendFormat("%s/%s/current_avg", 581 POWER_SUPPLY_SYSFS_PATH, name); 582 if (access(path, R_OK) == 0) 583 mHealthdConfig->batteryCurrentAvgPath = path; 584 } 585 586 if (mHealthdConfig->batteryChargeCounterPath.isEmpty()) { 587 path.clear(); 588 path.appendFormat("%s/%s/charge_counter", 589 POWER_SUPPLY_SYSFS_PATH, name); 590 if (access(path, R_OK) == 0) 591 mHealthdConfig->batteryChargeCounterPath = path; 592 } 593 594 if (mHealthdConfig->batteryTemperaturePath.isEmpty()) { 595 path.clear(); 596 path.appendFormat("%s/%s/temp", POWER_SUPPLY_SYSFS_PATH, 597 name); 598 if (access(path, R_OK) == 0) { 599 mHealthdConfig->batteryTemperaturePath = path; 600 } else { 601 path.clear(); 602 path.appendFormat("%s/%s/batt_temp", 603 POWER_SUPPLY_SYSFS_PATH, name); 604 if (access(path, R_OK) == 0) 605 mHealthdConfig->batteryTemperaturePath = path; 606 } 607 } 608 609 if (mHealthdConfig->batteryTechnologyPath.isEmpty()) { 610 path.clear(); 611 path.appendFormat("%s/%s/technology", 612 POWER_SUPPLY_SYSFS_PATH, name); 613 if (access(path, R_OK) == 0) 614 mHealthdConfig->batteryTechnologyPath = path; 615 } 616 617 break; 618 619 case ANDROID_POWER_SUPPLY_TYPE_UNKNOWN: 620 break; 621 } 622 } 623 } 624 625 // Typically the case for devices which do not have a battery and 626 // and are always plugged into AC mains. 627 if (!mBatteryDevicePresent) { 628 KLOG_WARNING(LOG_TAG, "No battery devices found\n"); 629 hc->periodic_chores_interval_fast = -1; 630 hc->periodic_chores_interval_slow = -1; 631 mBatteryFixedCapacity = ALWAYS_PLUGGED_CAPACITY; 632 mBatteryFixedTemperature = FAKE_BATTERY_TEMPERATURE; 633 mAlwaysPluggedDevice = true; 634 } else { 635 if (mHealthdConfig->batteryStatusPath.isEmpty()) 636 KLOG_WARNING(LOG_TAG, "BatteryStatusPath not found\n"); 637 if (mHealthdConfig->batteryHealthPath.isEmpty()) 638 KLOG_WARNING(LOG_TAG, "BatteryHealthPath not found\n"); 639 if (mHealthdConfig->batteryPresentPath.isEmpty()) 640 KLOG_WARNING(LOG_TAG, "BatteryPresentPath not found\n"); 641 if (mHealthdConfig->batteryCapacityPath.isEmpty()) 642 KLOG_WARNING(LOG_TAG, "BatteryCapacityPath not found\n"); 643 if (mHealthdConfig->batteryVoltagePath.isEmpty()) 644 KLOG_WARNING(LOG_TAG, "BatteryVoltagePath not found\n"); 645 if (mHealthdConfig->batteryTemperaturePath.isEmpty()) 646 KLOG_WARNING(LOG_TAG, "BatteryTemperaturePath not found\n"); 647 if (mHealthdConfig->batteryTechnologyPath.isEmpty()) 648 KLOG_WARNING(LOG_TAG, "BatteryTechnologyPath not found\n"); 649 if (mHealthdConfig->batteryCurrentNowPath.isEmpty()) 650 KLOG_WARNING(LOG_TAG, "BatteryCurrentNowPath not found\n"); 651 if (mHealthdConfig->batteryFullChargePath.isEmpty()) 652 KLOG_WARNING(LOG_TAG, "BatteryFullChargePath not found\n"); 653 if (mHealthdConfig->batteryCycleCountPath.isEmpty()) 654 KLOG_WARNING(LOG_TAG, "BatteryCycleCountPath not found\n"); 655 } 656 657 if (property_get("ro.boot.fake_battery", pval, NULL) > 0 658 && strtol(pval, NULL, 10) != 0) { 659 mBatteryFixedCapacity = FAKE_BATTERY_CAPACITY; 660 mBatteryFixedTemperature = FAKE_BATTERY_TEMPERATURE; 661 } 662 } 663 664 }; // namespace android 665
