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
49namespace android {
50
51struct sysfsStringEnumMap {
52    const char* s;
53    int val;
54};
55
56static 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
65static 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
84BatteryMonitor::BatteryMonitor() : mHealthdConfig(nullptr), mBatteryDevicePresent(false),
85    mAlwaysPluggedDevice(false), mBatteryFixedCapacity(0), mBatteryFixedTemperature(0) {
86    initBatteryProperties(&props);
87}
88
89int 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
109int 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        { NULL, 0 },
120    };
121
122    ret = mapSysfsString(status, batteryHealthMap);
123    if (ret < 0) {
124        KLOG_WARNING(LOG_TAG, "Unknown battery health '%s'\n", status);
125        ret = BATTERY_HEALTH_UNKNOWN;
126    }
127
128    return ret;
129}
130
131int BatteryMonitor::readFromFile(const String8& path, std::string* buf) {
132    if (android::base::ReadFileToString(path.c_str(), buf)) {
133        *buf = android::base::Trim(*buf);
134    }
135    return buf->length();
136}
137
138BatteryMonitor::PowerSupplyType BatteryMonitor::readPowerSupplyType(const String8& path) {
139    std::string buf;
140    BatteryMonitor::PowerSupplyType ret;
141    struct sysfsStringEnumMap supplyTypeMap[] = {
142            { "Unknown", ANDROID_POWER_SUPPLY_TYPE_UNKNOWN },
143            { "Battery", ANDROID_POWER_SUPPLY_TYPE_BATTERY },
144            { "UPS", ANDROID_POWER_SUPPLY_TYPE_AC },
145            { "Mains", ANDROID_POWER_SUPPLY_TYPE_AC },
146            { "USB", ANDROID_POWER_SUPPLY_TYPE_USB },
147            { "USB_DCP", ANDROID_POWER_SUPPLY_TYPE_AC },
148            { "USB_HVDCP", ANDROID_POWER_SUPPLY_TYPE_AC },
149            { "USB_CDP", ANDROID_POWER_SUPPLY_TYPE_AC },
150            { "USB_ACA", ANDROID_POWER_SUPPLY_TYPE_AC },
151            { "USB_C", ANDROID_POWER_SUPPLY_TYPE_AC },
152            { "USB_PD", ANDROID_POWER_SUPPLY_TYPE_AC },
153            { "USB_PD_DRP", ANDROID_POWER_SUPPLY_TYPE_USB },
154            { "Wireless", ANDROID_POWER_SUPPLY_TYPE_WIRELESS },
155            { NULL, 0 },
156    };
157
158    if (readFromFile(path, &buf) <= 0)
159        return ANDROID_POWER_SUPPLY_TYPE_UNKNOWN;
160
161    ret = (BatteryMonitor::PowerSupplyType)mapSysfsString(buf.c_str(), supplyTypeMap);
162    if (ret < 0) {
163        KLOG_WARNING(LOG_TAG, "Unknown power supply type '%s'\n", buf.c_str());
164        ret = ANDROID_POWER_SUPPLY_TYPE_UNKNOWN;
165    }
166
167    return ret;
168}
169
170bool BatteryMonitor::getBooleanField(const String8& path) {
171    std::string buf;
172    bool value = false;
173
174    if (readFromFile(path, &buf) > 0)
175        if (buf[0] != '0')
176            value = true;
177
178    return value;
179}
180
181int BatteryMonitor::getIntField(const String8& path) {
182    std::string buf;
183    int value = 0;
184
185    if (readFromFile(path, &buf) > 0)
186        android::base::ParseInt(buf, &value);
187
188    return value;
189}
190
191bool BatteryMonitor::update(void) {
192    bool logthis;
193
194    initBatteryProperties(&props);
195
196    if (!mHealthdConfig->batteryPresentPath.isEmpty())
197        props.batteryPresent = getBooleanField(mHealthdConfig->batteryPresentPath);
198    else
199        props.batteryPresent = mBatteryDevicePresent;
200
201    props.batteryLevel = mBatteryFixedCapacity ?
202        mBatteryFixedCapacity :
203        getIntField(mHealthdConfig->batteryCapacityPath);
204    props.batteryVoltage = getIntField(mHealthdConfig->batteryVoltagePath) / 1000;
205
206    if (!mHealthdConfig->batteryCurrentNowPath.isEmpty())
207        props.batteryCurrent = getIntField(mHealthdConfig->batteryCurrentNowPath) / 1000;
208
209    if (!mHealthdConfig->batteryFullChargePath.isEmpty())
210        props.batteryFullCharge = getIntField(mHealthdConfig->batteryFullChargePath);
211
212    if (!mHealthdConfig->batteryCycleCountPath.isEmpty())
213        props.batteryCycleCount = getIntField(mHealthdConfig->batteryCycleCountPath);
214
215    if (!mHealthdConfig->batteryChargeCounterPath.isEmpty())
216        props.batteryChargeCounter = getIntField(mHealthdConfig->batteryChargeCounterPath);
217
218    props.batteryTemperature = mBatteryFixedTemperature ?
219        mBatteryFixedTemperature :
220        getIntField(mHealthdConfig->batteryTemperaturePath);
221
222    // For devices which do not have battery and are always plugged
223    // into power souce.
224    if (mAlwaysPluggedDevice) {
225        props.chargerAcOnline = true;
226        props.batteryPresent = true;
227        props.batteryStatus = BATTERY_STATUS_CHARGING;
228        props.batteryHealth = BATTERY_HEALTH_GOOD;
229    }
230
231    std::string buf;
232
233    if (readFromFile(mHealthdConfig->batteryStatusPath, &buf) > 0)
234        props.batteryStatus = getBatteryStatus(buf.c_str());
235
236    if (readFromFile(mHealthdConfig->batteryHealthPath, &buf) > 0)
237        props.batteryHealth = getBatteryHealth(buf.c_str());
238
239    if (readFromFile(mHealthdConfig->batteryTechnologyPath, &buf) > 0)
240        props.batteryTechnology = String8(buf.c_str());
241
242    unsigned int i;
243    double MaxPower = 0;
244
245    for (i = 0; i < mChargerNames.size(); i++) {
246        String8 path;
247        path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH,
248                          mChargerNames[i].string());
249        if (getIntField(path)) {
250            path.clear();
251            path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH,
252                              mChargerNames[i].string());
253            switch(readPowerSupplyType(path)) {
254            case ANDROID_POWER_SUPPLY_TYPE_AC:
255                props.chargerAcOnline = true;
256                break;
257            case ANDROID_POWER_SUPPLY_TYPE_USB:
258                props.chargerUsbOnline = true;
259                break;
260            case ANDROID_POWER_SUPPLY_TYPE_WIRELESS:
261                props.chargerWirelessOnline = true;
262                break;
263            default:
264                KLOG_WARNING(LOG_TAG, "%s: Unknown power supply type\n",
265                             mChargerNames[i].string());
266            }
267            path.clear();
268            path.appendFormat("%s/%s/current_max", POWER_SUPPLY_SYSFS_PATH,
269                              mChargerNames[i].string());
270            int ChargingCurrent =
271                    (access(path.string(), R_OK) == 0) ? getIntField(path) : 0;
272
273            path.clear();
274            path.appendFormat("%s/%s/voltage_max", POWER_SUPPLY_SYSFS_PATH,
275                              mChargerNames[i].string());
276
277            int ChargingVoltage =
278                (access(path.string(), R_OK) == 0) ? getIntField(path) :
279                DEFAULT_VBUS_VOLTAGE;
280
281            double power = ((double)ChargingCurrent / MILLION) *
282                           ((double)ChargingVoltage / MILLION);
283            if (MaxPower < power) {
284                props.maxChargingCurrent = ChargingCurrent;
285                props.maxChargingVoltage = ChargingVoltage;
286                MaxPower = power;
287            }
288        }
289    }
290
291    logthis = !healthd_board_battery_update(&props);
292
293    if (logthis) {
294        char dmesgline[256];
295        size_t len;
296        if (props.batteryPresent) {
297            snprintf(dmesgline, sizeof(dmesgline),
298                 "battery l=%d v=%d t=%s%d.%d h=%d st=%d",
299                 props.batteryLevel, props.batteryVoltage,
300                 props.batteryTemperature < 0 ? "-" : "",
301                 abs(props.batteryTemperature / 10),
302                 abs(props.batteryTemperature % 10), props.batteryHealth,
303                 props.batteryStatus);
304
305            len = strlen(dmesgline);
306            if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
307                len += snprintf(dmesgline + len, sizeof(dmesgline) - len,
308                                " c=%d", props.batteryCurrent);
309            }
310
311            if (!mHealthdConfig->batteryFullChargePath.isEmpty()) {
312                len += snprintf(dmesgline + len, sizeof(dmesgline) - len,
313                                " fc=%d", props.batteryFullCharge);
314            }
315
316            if (!mHealthdConfig->batteryCycleCountPath.isEmpty()) {
317                len += snprintf(dmesgline + len, sizeof(dmesgline) - len,
318                                " cc=%d", props.batteryCycleCount);
319            }
320        } else {
321            len = snprintf(dmesgline, sizeof(dmesgline),
322                 "battery none");
323        }
324
325        snprintf(dmesgline + len, sizeof(dmesgline) - len, " chg=%s%s%s",
326                 props.chargerAcOnline ? "a" : "",
327                 props.chargerUsbOnline ? "u" : "",
328                 props.chargerWirelessOnline ? "w" : "");
329
330        KLOG_WARNING(LOG_TAG, "%s\n", dmesgline);
331    }
332
333    healthd_mode_ops->battery_update(&props);
334    return props.chargerAcOnline | props.chargerUsbOnline |
335            props.chargerWirelessOnline;
336}
337
338int BatteryMonitor::getChargeStatus() {
339    int result = BATTERY_STATUS_UNKNOWN;
340    if (!mHealthdConfig->batteryStatusPath.isEmpty()) {
341        std::string buf;
342        if (readFromFile(mHealthdConfig->batteryStatusPath, &buf) > 0)
343            result = getBatteryStatus(buf.c_str());
344    }
345    return result;
346}
347
348status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) {
349    status_t ret = BAD_VALUE;
350    std::string buf;
351
352    val->valueInt64 = LONG_MIN;
353
354    switch(id) {
355    case BATTERY_PROP_CHARGE_COUNTER:
356        if (!mHealthdConfig->batteryChargeCounterPath.isEmpty()) {
357            val->valueInt64 =
358                getIntField(mHealthdConfig->batteryChargeCounterPath);
359            ret = NO_ERROR;
360        } else {
361            ret = NAME_NOT_FOUND;
362        }
363        break;
364
365    case BATTERY_PROP_CURRENT_NOW:
366        if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
367            val->valueInt64 =
368                getIntField(mHealthdConfig->batteryCurrentNowPath);
369            ret = NO_ERROR;
370        } else {
371            ret = NAME_NOT_FOUND;
372        }
373        break;
374
375    case BATTERY_PROP_CURRENT_AVG:
376        if (!mHealthdConfig->batteryCurrentAvgPath.isEmpty()) {
377            val->valueInt64 =
378                getIntField(mHealthdConfig->batteryCurrentAvgPath);
379            ret = NO_ERROR;
380        } else {
381            ret = NAME_NOT_FOUND;
382        }
383        break;
384
385    case BATTERY_PROP_CAPACITY:
386        if (!mHealthdConfig->batteryCapacityPath.isEmpty()) {
387            val->valueInt64 =
388                getIntField(mHealthdConfig->batteryCapacityPath);
389            ret = NO_ERROR;
390        } else {
391            ret = NAME_NOT_FOUND;
392        }
393        break;
394
395    case BATTERY_PROP_ENERGY_COUNTER:
396        if (mHealthdConfig->energyCounter) {
397            ret = mHealthdConfig->energyCounter(&val->valueInt64);
398        } else {
399            ret = NAME_NOT_FOUND;
400        }
401        break;
402
403    case BATTERY_PROP_BATTERY_STATUS:
404        if (mAlwaysPluggedDevice) {
405            val->valueInt64 = BATTERY_STATUS_CHARGING;
406        } else {
407            val->valueInt64 = getChargeStatus();
408        }
409        ret = NO_ERROR;
410        break;
411
412    default:
413        break;
414    }
415
416    return ret;
417}
418
419void BatteryMonitor::dumpState(int fd) {
420    int v;
421    char vs[128];
422
423    snprintf(vs, sizeof(vs), "ac: %d usb: %d wireless: %d current_max: %d voltage_max: %d\n",
424             props.chargerAcOnline, props.chargerUsbOnline,
425             props.chargerWirelessOnline, props.maxChargingCurrent,
426             props.maxChargingVoltage);
427    write(fd, vs, strlen(vs));
428    snprintf(vs, sizeof(vs), "status: %d health: %d present: %d\n",
429             props.batteryStatus, props.batteryHealth, props.batteryPresent);
430    write(fd, vs, strlen(vs));
431    snprintf(vs, sizeof(vs), "level: %d voltage: %d temp: %d\n",
432             props.batteryLevel, props.batteryVoltage,
433             props.batteryTemperature);
434    write(fd, vs, strlen(vs));
435
436    if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
437        v = getIntField(mHealthdConfig->batteryCurrentNowPath);
438        snprintf(vs, sizeof(vs), "current now: %d\n", v);
439        write(fd, vs, strlen(vs));
440    }
441
442    if (!mHealthdConfig->batteryCurrentAvgPath.isEmpty()) {
443        v = getIntField(mHealthdConfig->batteryCurrentAvgPath);
444        snprintf(vs, sizeof(vs), "current avg: %d\n", v);
445        write(fd, vs, strlen(vs));
446    }
447
448    if (!mHealthdConfig->batteryChargeCounterPath.isEmpty()) {
449        v = getIntField(mHealthdConfig->batteryChargeCounterPath);
450        snprintf(vs, sizeof(vs), "charge counter: %d\n", v);
451        write(fd, vs, strlen(vs));
452    }
453
454    if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
455        snprintf(vs, sizeof(vs), "current now: %d\n", props.batteryCurrent);
456        write(fd, vs, strlen(vs));
457    }
458
459    if (!mHealthdConfig->batteryCycleCountPath.isEmpty()) {
460        snprintf(vs, sizeof(vs), "cycle count: %d\n", props.batteryCycleCount);
461        write(fd, vs, strlen(vs));
462    }
463
464    if (!mHealthdConfig->batteryFullChargePath.isEmpty()) {
465        snprintf(vs, sizeof(vs), "Full charge: %d\n", props.batteryFullCharge);
466        write(fd, vs, strlen(vs));
467    }
468}
469
470void BatteryMonitor::init(struct healthd_config *hc) {
471    String8 path;
472    char pval[PROPERTY_VALUE_MAX];
473
474    mHealthdConfig = hc;
475    std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(POWER_SUPPLY_SYSFS_PATH), closedir);
476    if (dir == NULL) {
477        KLOG_ERROR(LOG_TAG, "Could not open %s\n", POWER_SUPPLY_SYSFS_PATH);
478    } else {
479        struct dirent* entry;
480
481        while ((entry = readdir(dir.get()))) {
482            const char* name = entry->d_name;
483
484            if (!strcmp(name, ".") || !strcmp(name, ".."))
485                continue;
486
487            // Look for "type" file in each subdirectory
488            path.clear();
489            path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH, name);
490            switch(readPowerSupplyType(path)) {
491            case ANDROID_POWER_SUPPLY_TYPE_AC:
492            case ANDROID_POWER_SUPPLY_TYPE_USB:
493            case ANDROID_POWER_SUPPLY_TYPE_WIRELESS:
494                path.clear();
495                path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, name);
496                if (access(path.string(), R_OK) == 0)
497                    mChargerNames.add(String8(name));
498                break;
499
500            case ANDROID_POWER_SUPPLY_TYPE_BATTERY:
501                mBatteryDevicePresent = true;
502
503                if (mHealthdConfig->batteryStatusPath.isEmpty()) {
504                    path.clear();
505                    path.appendFormat("%s/%s/status", POWER_SUPPLY_SYSFS_PATH,
506                                      name);
507                    if (access(path, R_OK) == 0)
508                        mHealthdConfig->batteryStatusPath = path;
509                }
510
511                if (mHealthdConfig->batteryHealthPath.isEmpty()) {
512                    path.clear();
513                    path.appendFormat("%s/%s/health", POWER_SUPPLY_SYSFS_PATH,
514                                      name);
515                    if (access(path, R_OK) == 0)
516                        mHealthdConfig->batteryHealthPath = path;
517                }
518
519                if (mHealthdConfig->batteryPresentPath.isEmpty()) {
520                    path.clear();
521                    path.appendFormat("%s/%s/present", POWER_SUPPLY_SYSFS_PATH,
522                                      name);
523                    if (access(path, R_OK) == 0)
524                        mHealthdConfig->batteryPresentPath = path;
525                }
526
527                if (mHealthdConfig->batteryCapacityPath.isEmpty()) {
528                    path.clear();
529                    path.appendFormat("%s/%s/capacity", POWER_SUPPLY_SYSFS_PATH,
530                                      name);
531                    if (access(path, R_OK) == 0)
532                        mHealthdConfig->batteryCapacityPath = path;
533                }
534
535                if (mHealthdConfig->batteryVoltagePath.isEmpty()) {
536                    path.clear();
537                    path.appendFormat("%s/%s/voltage_now",
538                                      POWER_SUPPLY_SYSFS_PATH, name);
539                    if (access(path, R_OK) == 0) {
540                        mHealthdConfig->batteryVoltagePath = path;
541                    } else {
542                        path.clear();
543                        path.appendFormat("%s/%s/batt_vol",
544                                          POWER_SUPPLY_SYSFS_PATH, name);
545                        if (access(path, R_OK) == 0)
546                            mHealthdConfig->batteryVoltagePath = path;
547                    }
548                }
549
550                if (mHealthdConfig->batteryFullChargePath.isEmpty()) {
551                    path.clear();
552                    path.appendFormat("%s/%s/charge_full",
553                                      POWER_SUPPLY_SYSFS_PATH, name);
554                    if (access(path, R_OK) == 0)
555                        mHealthdConfig->batteryFullChargePath = path;
556                }
557
558                if (mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
559                    path.clear();
560                    path.appendFormat("%s/%s/current_now",
561                                      POWER_SUPPLY_SYSFS_PATH, name);
562                    if (access(path, R_OK) == 0)
563                        mHealthdConfig->batteryCurrentNowPath = path;
564                }
565
566                if (mHealthdConfig->batteryCycleCountPath.isEmpty()) {
567                    path.clear();
568                    path.appendFormat("%s/%s/cycle_count",
569                                      POWER_SUPPLY_SYSFS_PATH, name);
570                    if (access(path, R_OK) == 0)
571                        mHealthdConfig->batteryCycleCountPath = path;
572                }
573
574                if (mHealthdConfig->batteryCurrentAvgPath.isEmpty()) {
575                    path.clear();
576                    path.appendFormat("%s/%s/current_avg",
577                                      POWER_SUPPLY_SYSFS_PATH, name);
578                    if (access(path, R_OK) == 0)
579                        mHealthdConfig->batteryCurrentAvgPath = path;
580                }
581
582                if (mHealthdConfig->batteryChargeCounterPath.isEmpty()) {
583                    path.clear();
584                    path.appendFormat("%s/%s/charge_counter",
585                                      POWER_SUPPLY_SYSFS_PATH, name);
586                    if (access(path, R_OK) == 0)
587                        mHealthdConfig->batteryChargeCounterPath = path;
588                }
589
590                if (mHealthdConfig->batteryTemperaturePath.isEmpty()) {
591                    path.clear();
592                    path.appendFormat("%s/%s/temp", POWER_SUPPLY_SYSFS_PATH,
593                                      name);
594                    if (access(path, R_OK) == 0) {
595                        mHealthdConfig->batteryTemperaturePath = path;
596                    } else {
597                        path.clear();
598                        path.appendFormat("%s/%s/batt_temp",
599                                          POWER_SUPPLY_SYSFS_PATH, name);
600                        if (access(path, R_OK) == 0)
601                            mHealthdConfig->batteryTemperaturePath = path;
602                    }
603                }
604
605                if (mHealthdConfig->batteryTechnologyPath.isEmpty()) {
606                    path.clear();
607                    path.appendFormat("%s/%s/technology",
608                                      POWER_SUPPLY_SYSFS_PATH, name);
609                    if (access(path, R_OK) == 0)
610                        mHealthdConfig->batteryTechnologyPath = path;
611                }
612
613                break;
614
615            case ANDROID_POWER_SUPPLY_TYPE_UNKNOWN:
616                break;
617            }
618        }
619    }
620
621    // Typically the case for devices which do not have a battery and
622    // and are always plugged into AC mains.
623    if (!mBatteryDevicePresent) {
624        KLOG_WARNING(LOG_TAG, "No battery devices found\n");
625        hc->periodic_chores_interval_fast = -1;
626        hc->periodic_chores_interval_slow = -1;
627        mBatteryFixedCapacity = ALWAYS_PLUGGED_CAPACITY;
628        mBatteryFixedTemperature = FAKE_BATTERY_TEMPERATURE;
629        mAlwaysPluggedDevice = true;
630    } else {
631        if (mHealthdConfig->batteryStatusPath.isEmpty())
632            KLOG_WARNING(LOG_TAG, "BatteryStatusPath not found\n");
633        if (mHealthdConfig->batteryHealthPath.isEmpty())
634            KLOG_WARNING(LOG_TAG, "BatteryHealthPath not found\n");
635        if (mHealthdConfig->batteryPresentPath.isEmpty())
636            KLOG_WARNING(LOG_TAG, "BatteryPresentPath not found\n");
637        if (mHealthdConfig->batteryCapacityPath.isEmpty())
638            KLOG_WARNING(LOG_TAG, "BatteryCapacityPath not found\n");
639        if (mHealthdConfig->batteryVoltagePath.isEmpty())
640            KLOG_WARNING(LOG_TAG, "BatteryVoltagePath not found\n");
641        if (mHealthdConfig->batteryTemperaturePath.isEmpty())
642            KLOG_WARNING(LOG_TAG, "BatteryTemperaturePath not found\n");
643        if (mHealthdConfig->batteryTechnologyPath.isEmpty())
644            KLOG_WARNING(LOG_TAG, "BatteryTechnologyPath not found\n");
645        if (mHealthdConfig->batteryCurrentNowPath.isEmpty())
646            KLOG_WARNING(LOG_TAG, "BatteryCurrentNowPath not found\n");
647        if (mHealthdConfig->batteryFullChargePath.isEmpty())
648            KLOG_WARNING(LOG_TAG, "BatteryFullChargePath not found\n");
649        if (mHealthdConfig->batteryCycleCountPath.isEmpty())
650            KLOG_WARNING(LOG_TAG, "BatteryCycleCountPath not found\n");
651    }
652
653    if (property_get("ro.boot.fake_battery", pval, NULL) > 0
654                                               && strtol(pval, NULL, 10) != 0) {
655        mBatteryFixedCapacity = FAKE_BATTERY_CAPACITY;
656        mBatteryFixedTemperature = FAKE_BATTERY_TEMPERATURE;
657    }
658}
659
660}; // namespace android
661