BatteryMonitor.cpp revision b45f1f5bd00c9a8380960d7c439eb14b3a334f50
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 "BatteryMonitor.h" 20#include "BatteryPropertiesRegistrar.h" 21 22#include <dirent.h> 23#include <errno.h> 24#include <fcntl.h> 25#include <stdio.h> 26#include <stdlib.h> 27#include <unistd.h> 28#include <batteryservice/BatteryService.h> 29#include <cutils/klog.h> 30#include <utils/String8.h> 31#include <utils/Vector.h> 32 33#define POWER_SUPPLY_SUBSYSTEM "power_supply" 34#define POWER_SUPPLY_SYSFS_PATH "/sys/class/" POWER_SUPPLY_SUBSYSTEM 35 36namespace android { 37 38struct sysfsStringEnumMap { 39 char* s; 40 int val; 41}; 42 43static int mapSysfsString(const char* str, 44 struct sysfsStringEnumMap map[]) { 45 for (int i = 0; map[i].s; i++) 46 if (!strcmp(str, map[i].s)) 47 return map[i].val; 48 49 return -1; 50} 51 52int BatteryMonitor::getBatteryStatus(const char* status) { 53 int ret; 54 struct sysfsStringEnumMap batteryStatusMap[] = { 55 { "Unknown", BATTERY_STATUS_UNKNOWN }, 56 { "Charging", BATTERY_STATUS_CHARGING }, 57 { "Discharging", BATTERY_STATUS_DISCHARGING }, 58 { "Not charging", BATTERY_STATUS_NOT_CHARGING }, 59 { "Full", BATTERY_STATUS_FULL }, 60 { NULL, 0 }, 61 }; 62 63 ret = mapSysfsString(status, batteryStatusMap); 64 if (ret < 0) { 65 KLOG_WARNING(LOG_TAG, "Unknown battery status '%s'\n", status); 66 ret = BATTERY_STATUS_UNKNOWN; 67 } 68 69 return ret; 70} 71 72int BatteryMonitor::getBatteryHealth(const char* status) { 73 int ret; 74 struct sysfsStringEnumMap batteryHealthMap[] = { 75 { "Unknown", BATTERY_HEALTH_UNKNOWN }, 76 { "Good", BATTERY_HEALTH_GOOD }, 77 { "Overheat", BATTERY_HEALTH_OVERHEAT }, 78 { "Dead", BATTERY_HEALTH_DEAD }, 79 { "Over voltage", BATTERY_HEALTH_OVER_VOLTAGE }, 80 { "Unspecified failure", BATTERY_HEALTH_UNSPECIFIED_FAILURE }, 81 { "Cold", BATTERY_HEALTH_COLD }, 82 { NULL, 0 }, 83 }; 84 85 ret = mapSysfsString(status, batteryHealthMap); 86 if (ret < 0) { 87 KLOG_WARNING(LOG_TAG, "Unknown battery health '%s'\n", status); 88 ret = BATTERY_HEALTH_UNKNOWN; 89 } 90 91 return ret; 92} 93 94int BatteryMonitor::readFromFile(const String8& path, char* buf, size_t size) { 95 char *cp = NULL; 96 97 if (path.isEmpty()) 98 return -1; 99 int fd = open(path.string(), O_RDONLY, 0); 100 if (fd == -1) { 101 KLOG_ERROR(LOG_TAG, "Could not open '%s'\n", path.string()); 102 return -1; 103 } 104 105 ssize_t count = TEMP_FAILURE_RETRY(read(fd, buf, size)); 106 if (count > 0) 107 cp = (char *)memrchr(buf, '\n', count); 108 109 if (cp) 110 *cp = '\0'; 111 else 112 buf[0] = '\0'; 113 114 close(fd); 115 return count; 116} 117 118BatteryMonitor::PowerSupplyType BatteryMonitor::readPowerSupplyType(const String8& path) { 119 const int SIZE = 128; 120 char buf[SIZE]; 121 int length = readFromFile(path, buf, SIZE); 122 BatteryMonitor::PowerSupplyType ret; 123 struct sysfsStringEnumMap supplyTypeMap[] = { 124 { "Unknown", ANDROID_POWER_SUPPLY_TYPE_UNKNOWN }, 125 { "Battery", ANDROID_POWER_SUPPLY_TYPE_BATTERY }, 126 { "UPS", ANDROID_POWER_SUPPLY_TYPE_AC }, 127 { "Mains", ANDROID_POWER_SUPPLY_TYPE_AC }, 128 { "USB", ANDROID_POWER_SUPPLY_TYPE_USB }, 129 { "USB_DCP", ANDROID_POWER_SUPPLY_TYPE_AC }, 130 { "USB_CDP", ANDROID_POWER_SUPPLY_TYPE_AC }, 131 { "USB_ACA", ANDROID_POWER_SUPPLY_TYPE_AC }, 132 { "Wireless", ANDROID_POWER_SUPPLY_TYPE_WIRELESS }, 133 { NULL, 0 }, 134 }; 135 136 if (length <= 0) 137 return ANDROID_POWER_SUPPLY_TYPE_UNKNOWN; 138 139 ret = (BatteryMonitor::PowerSupplyType)mapSysfsString(buf, supplyTypeMap); 140 if (ret < 0) 141 ret = ANDROID_POWER_SUPPLY_TYPE_UNKNOWN; 142 143 return ret; 144} 145 146bool BatteryMonitor::getBooleanField(const String8& path) { 147 const int SIZE = 16; 148 char buf[SIZE]; 149 150 bool value = false; 151 if (readFromFile(path, buf, SIZE) > 0) { 152 if (buf[0] != '0') { 153 value = true; 154 } 155 } 156 157 return value; 158} 159 160int BatteryMonitor::getIntField(const String8& path) { 161 const int SIZE = 128; 162 char buf[SIZE]; 163 164 int value = 0; 165 if (readFromFile(path, buf, SIZE) > 0) { 166 value = strtol(buf, NULL, 0); 167 } 168 return value; 169} 170 171bool BatteryMonitor::update(void) { 172 struct BatteryProperties props; 173 174 props.chargerAcOnline = false; 175 props.chargerUsbOnline = false; 176 props.chargerWirelessOnline = false; 177 props.batteryStatus = BATTERY_STATUS_UNKNOWN; 178 props.batteryHealth = BATTERY_HEALTH_UNKNOWN; 179 props.batteryCurrentNow = INT_MIN; 180 props.batteryChargeCounter = INT_MIN; 181 182 if (!mBatteryPresentPath.isEmpty()) 183 props.batteryPresent = getBooleanField(mBatteryPresentPath); 184 else 185 props.batteryPresent = true; 186 187 props.batteryLevel = getIntField(mBatteryCapacityPath); 188 props.batteryVoltage = getIntField(mBatteryVoltagePath) / 1000; 189 190 if (!mBatteryCurrentNowPath.isEmpty()) 191 props.batteryCurrentNow = getIntField(mBatteryCurrentNowPath) / 1000; 192 193 if (!mBatteryChargeCounterPath.isEmpty()) 194 props.batteryChargeCounter = getIntField(mBatteryChargeCounterPath) / 1000; 195 196 props.batteryTemperature = getIntField(mBatteryTemperaturePath); 197 198 const int SIZE = 128; 199 char buf[SIZE]; 200 String8 btech; 201 202 if (readFromFile(mBatteryStatusPath, buf, SIZE) > 0) 203 props.batteryStatus = getBatteryStatus(buf); 204 205 if (readFromFile(mBatteryHealthPath, buf, SIZE) > 0) 206 props.batteryHealth = getBatteryHealth(buf); 207 208 if (readFromFile(mBatteryTechnologyPath, buf, SIZE) > 0) 209 props.batteryTechnology = String8(buf); 210 211 unsigned int i; 212 213 for (i = 0; i < mChargerNames.size(); i++) { 214 String8 path; 215 path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, 216 mChargerNames[i].string()); 217 218 if (readFromFile(path, buf, SIZE) > 0) { 219 if (buf[0] != '0') { 220 path.clear(); 221 path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH, 222 mChargerNames[i].string()); 223 switch(readPowerSupplyType(path)) { 224 case ANDROID_POWER_SUPPLY_TYPE_AC: 225 props.chargerAcOnline = true; 226 break; 227 case ANDROID_POWER_SUPPLY_TYPE_USB: 228 props.chargerUsbOnline = true; 229 break; 230 case ANDROID_POWER_SUPPLY_TYPE_WIRELESS: 231 props.chargerWirelessOnline = true; 232 break; 233 default: 234 KLOG_WARNING(LOG_TAG, "%s: Unknown power supply type\n", 235 mChargerNames[i].string()); 236 } 237 } 238 } 239 } 240 241 char dmesgline[256]; 242 snprintf(dmesgline, sizeof(dmesgline), 243 "battery l=%d v=%d t=%s%d.%d h=%d st=%d", 244 props.batteryLevel, props.batteryVoltage, 245 props.batteryTemperature < 0 ? "-" : "", 246 abs(props.batteryTemperature / 10), 247 abs(props.batteryTemperature % 10), props.batteryHealth, 248 props.batteryStatus); 249 250 if (!mBatteryCurrentNowPath.isEmpty()) { 251 char b[20]; 252 253 snprintf(b, sizeof(b), " c=%d", props.batteryCurrentNow); 254 strlcat(dmesgline, b, sizeof(dmesgline)); 255 } 256 257 KLOG_INFO(LOG_TAG, "%s chg=%s%s%s\n", dmesgline, 258 props.chargerAcOnline ? "a" : "", 259 props.chargerUsbOnline ? "u" : "", 260 props.chargerWirelessOnline ? "w" : ""); 261 262 if (mBatteryPropertiesRegistrar != NULL) 263 mBatteryPropertiesRegistrar->notifyListeners(props); 264 265 return props.chargerAcOnline | props.chargerUsbOnline | 266 props.chargerWirelessOnline; 267} 268 269void BatteryMonitor::init(bool nosvcmgr) { 270 String8 path; 271 272 DIR* dir = opendir(POWER_SUPPLY_SYSFS_PATH); 273 if (dir == NULL) { 274 KLOG_ERROR(LOG_TAG, "Could not open %s\n", POWER_SUPPLY_SYSFS_PATH); 275 } else { 276 struct dirent* entry; 277 278 while ((entry = readdir(dir))) { 279 const char* name = entry->d_name; 280 281 if (!strcmp(name, ".") || !strcmp(name, "..")) 282 continue; 283 284 char buf[20]; 285 // Look for "type" file in each subdirectory 286 path.clear(); 287 path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH, name); 288 switch(readPowerSupplyType(path)) { 289 case ANDROID_POWER_SUPPLY_TYPE_AC: 290 case ANDROID_POWER_SUPPLY_TYPE_USB: 291 case ANDROID_POWER_SUPPLY_TYPE_WIRELESS: 292 path.clear(); 293 path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, name); 294 if (access(path.string(), R_OK) == 0) 295 mChargerNames.add(String8(name)); 296 break; 297 298 case ANDROID_POWER_SUPPLY_TYPE_BATTERY: 299 path.clear(); 300 path.appendFormat("%s/%s/status", POWER_SUPPLY_SYSFS_PATH, name); 301 if (access(path, R_OK) == 0) 302 mBatteryStatusPath = path; 303 path.clear(); 304 path.appendFormat("%s/%s/health", POWER_SUPPLY_SYSFS_PATH, name); 305 if (access(path, R_OK) == 0) 306 mBatteryHealthPath = path; 307 path.clear(); 308 path.appendFormat("%s/%s/present", POWER_SUPPLY_SYSFS_PATH, name); 309 if (access(path, R_OK) == 0) 310 mBatteryPresentPath = path; 311 path.clear(); 312 path.appendFormat("%s/%s/capacity", POWER_SUPPLY_SYSFS_PATH, name); 313 if (access(path, R_OK) == 0) 314 mBatteryCapacityPath = path; 315 316 path.clear(); 317 path.appendFormat("%s/%s/voltage_now", POWER_SUPPLY_SYSFS_PATH, name); 318 if (access(path, R_OK) == 0) { 319 mBatteryVoltagePath = path; 320 } else { 321 path.clear(); 322 path.appendFormat("%s/%s/batt_vol", POWER_SUPPLY_SYSFS_PATH, name); 323 if (access(path, R_OK) == 0) 324 mBatteryVoltagePath = path; 325 } 326 327 path.clear(); 328 path.appendFormat("%s/%s/current_now", POWER_SUPPLY_SYSFS_PATH, name); 329 if (access(path, R_OK) == 0) 330 mBatteryCurrentNowPath = path; 331 332 path.clear(); 333 path.appendFormat("%s/%s/charge_counter", POWER_SUPPLY_SYSFS_PATH, name); 334 if (access(path, R_OK) == 0) 335 mBatteryChargeCounterPath = path; 336 337 path.clear(); 338 path.appendFormat("%s/%s/temp", POWER_SUPPLY_SYSFS_PATH, name); 339 if (access(path, R_OK) == 0) { 340 mBatteryTemperaturePath = path; 341 } else { 342 path.clear(); 343 path.appendFormat("%s/%s/batt_temp", POWER_SUPPLY_SYSFS_PATH, name); 344 if (access(path, R_OK) == 0) 345 mBatteryTemperaturePath = path; 346 } 347 348 path.clear(); 349 path.appendFormat("%s/%s/technology", POWER_SUPPLY_SYSFS_PATH, name); 350 if (access(path, R_OK) == 0) 351 mBatteryTechnologyPath = path; 352 break; 353 354 case ANDROID_POWER_SUPPLY_TYPE_UNKNOWN: 355 break; 356 } 357 } 358 closedir(dir); 359 } 360 361 if (!mChargerNames.size()) 362 KLOG_ERROR(LOG_TAG, "No charger supplies found\n"); 363 if (mBatteryStatusPath.isEmpty()) 364 KLOG_WARNING(LOG_TAG, "BatteryStatusPath not found\n"); 365 if (mBatteryHealthPath.isEmpty()) 366 KLOG_WARNING("BatteryHealthPath not found\n"); 367 if (mBatteryPresentPath.isEmpty()) 368 KLOG_WARNING(LOG_TAG, "BatteryPresentPath not found\n"); 369 if (mBatteryCapacityPath.isEmpty()) 370 KLOG_WARNING(LOG_TAG, "BatteryCapacityPath not found\n"); 371 if (mBatteryVoltagePath.isEmpty()) 372 KLOG_WARNING(LOG_TAG, "BatteryVoltagePath not found\n"); 373 if (mBatteryTemperaturePath.isEmpty()) 374 KLOG_WARNING(LOG_TAG, "BatteryTemperaturePath not found\n"); 375 if (mBatteryTechnologyPath.isEmpty()) 376 KLOG_WARNING(LOG_TAG, "BatteryTechnologyPath not found\n"); 377 378 if (nosvcmgr == false) { 379 mBatteryPropertiesRegistrar = new BatteryPropertiesRegistrar(this); 380 mBatteryPropertiesRegistrar->publish(); 381 } 382} 383 384}; // namespace android 385