低电量自动关机时无关机动画

1. 问题描述

  • DEFECT DESCRIPTION:

    No shutdown animation in the electricity display only 1%.
  • REPRODUCING PROCEDURES:

    电量消耗显示只有1%时，手机突然黑屏关机，没有关机动画，长按power键后手机又可以正常开机使用.(黑屏关机后插上充电器，电量显示为1%)
  • EXPECTED BEHAVIOUR:

    There should a shutdown animation in the electricity display only 1%.

2. 分析

关机动画的逻辑主要是在上层进行控制的，该上层的入口是文件BatteryService.java。系统会通过Binder机制将底层检测的到电池电量传入到属性mBatteryLevel中，然后对属性mBatteryLevel进行if操作。

  • 首先，底层由c/c++来检测电池信息并周期性更新电池状态。
  • 系统通过bingder机制将底层检测到的电池状态传入上层(BatteryService.java)
  • 上层接收底层传来的电池信息，并根据不同的电池状态做出相应的操作，如当电池电量为0时，会播放关机动画。

1.电池信息

更新电池电量的服务位于health守护进程中，其在init.rc中的定义如下：

  1. service healthd /sbin/healthd
  2. class core
  3. critical
  4. seclabel u:r:healthd:s0
  5. group root system wakelock

而该服务的相关代码位于目录system/core/health下，文件health.cpp的main函数如下：

  1. int main(int argc,char**argv){
  2. int ch;
  3. int ret;
  4. klog_set_level(KLOG_LEVEL);
  5. healthd_mode_ops =&android_ops;
  6. /*通过main函数的参数来判断当前手机状态*/
  7. if(!strcmp(basename(argv[0]),"charger")){
  8. /*从字面意思看 应该是在充电状态*/
  9. healthd_mode_ops =&charger_ops;
  10. }else{
  11. while((ch = getopt(argc, argv,"cr"))!=-1){
  12. switch(ch){
  13. case'c':
  14. healthd_mode_ops =&charger_ops;
  15. break;
  16. case'r':
  17. healthd_mode_ops =&recovery_ops;
  18. break;
  19. case'?':
  20. default:
  21. KLOG_ERROR(LOG_TAG,"Unrecognized healthd option: %c\n",
  22. optopt);
  23. exit(1);
  24. }
  25. }
  26. }
  27. ret = healthd_init();
  28. /*错误处理*/
  29. if(ret){
  30. KLOG_ERROR("Initialization failed, exiting\n");
  31. exit(2);
  32. }
  33. /*进入循环，也就是说手机从开启该服务开始，之后一直停留在循环中*/
  34. healthd_mainloop();
  35. KLOG_ERROR("Main loop terminated, exiting\n");
  36. return3;
  37. }

然后看看函数healthd_init()做了些什么事，其代码如下：

  1. staticint healthd_init(){
  2. /*没看懂是什么意思，好像是调用的bionic基础库的方法*/
  3. epollfd = epoll_create(MAX_EPOLL_EVENTS);
  4. if(epollfd ==-1){
  5. KLOG_ERROR(LOG_TAG,
  6. "epoll_create failed; errno=%d\n",
  7. errno);
  8. return-1;
  9. }
  10. /*看名字该是用电池配置信息进行初始化操作*/
  11. healthd_board_init(&healthd_config);
  12. /*应该是设置电池模式之类的操作*/
  13. healthd_mode_ops->init(&healthd_config);
  14. /*创建一个定时器*/
  15. wakealarm_init();
  16. /*初始化uevent环境*/
  17. uevent_init();
  18. /*创建BatteryMonitor对象*/
  19. gBatteryMonitor =newBatteryMonitor();
  20. /*对创建的BatteryMonitor对象进行初始化*/
  21. gBatteryMonitor->init(&healthd_config);
  22. return0;
  23. }

然后看看这个定时器怎么创建的，具体代码如下：

  1. staticvoid wakealarm_init(void){
  2. wakealarm_fd = timerfd_create(CLOCK_BOOTTIME_ALARM, TFD_NONBLOCK);
  3. if(wakealarm_fd ==-1){
  4. KLOG_ERROR(LOG_TAG,"wakealarm_init: timerfd_create failed\n");
  5. return;
  6. }
  7. if(healthd_register_event(wakealarm_fd, wakealarm_event))
  8. KLOG_ERROR(LOG_TAG,
  9. "Registration of wakealarm event failed\n"); wakealarm_set_interval(healthd_config.periodic_chores_interval_fast);
  10. }

用方法timerfd_create()创建一个定时器句柄，然后把它存入到全局变量wakealarm_fd中，函数wakealarm_set_interval()设置超时时间。

然后会创建一个BatteryMonitor对象并调用该对象的init方法，BatteryMonitor文件位于system/core/healthd/BatteryMonitor.cpp，该文件主要是读取电池的各种参数并返回给上层，先来看看该对象的init方法，具体如下：

  1. voidBatteryMonitor::init(struct healthd_config *hc){
  2. String8 path;
  3. char pval[PROPERTY_VALUE_MAX];
  5. mHealthdConfig = hc;
  6. /*
  7. #define POWER_SUPPLY_SUBSYSTEM "power_supply"
  8. #define POWER_SUPPLY_SYSFS_PATH "/sys/class/" POWER_SUPPLY_SUBSYSTEM
  9. 根据宏定义 POWER_SUPPLY_SYSFS_PATH="/sys/class/power_supply"即打开该目录
  10. ，而这个目录下的文件就是存储了电池的各中信息，如我们需要的电池电量值就在/sys/class/power_supply/battery/capacity文件中
  11. ，通过命令cat /sys/class/power_supply/battery/capacity就可以查看到当前电池电量值
  12. */
  13. DIR* dir = opendir(POWER_SUPPLY_SYSFS_PATH);
  14. if(dir == NULL){
  15. KLOG_ERROR(LOG_TAG,"Could not open %s\n", POWER_SUPPLY_SYSFS_PATH);
  16. }else{
  17. struct dirent* entry;
  19. while((entry = readdir(dir))){
  20. constchar* name = entry->d_name;
  21. /*过滤掉./目录和../目录*/
  22. if(!strcmp(name,".")||!strcmp(name,".."))
  23. continue;
  24. // Look for "type" file in each subdirectory
  25. path.clear();
  26. path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH, name);
  27. switch(readPowerSupplyType(path)){
  28. case ANDROID_POWER_SUPPLY_TYPE_AC:
  29. case ANDROID_POWER_SUPPLY_TYPE_USB:
  30. case ANDROID_POWER_SUPPLY_TYPE_WIRELESS:
  31. path.clear();
  32. path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, name);
  33. if(access(path.string(), R_OK)==0)
  34. mChargerNames.add(String8(name));
  35. break;
  37. case ANDROID_POWER_SUPPLY_TYPE_BATTERY:
  38. mBatteryDevicePresent =true;
  40. if(mHealthdConfig->batteryStatusPath.isEmpty()){
  41. path.clear();
  42. path.appendFormat("%s/%s/status", POWER_SUPPLY_SYSFS_PATH,
  43. name);
  44. if(access(path, R_OK)==0)
  45. mHealthdConfig->batteryStatusPath = path;
  46. }
  48. if(mHealthdConfig->batteryHealthPath.isEmpty()){
  49. path.clear();
  50. path.appendFormat("%s/%s/health", POWER_SUPPLY_SYSFS_PATH,
  51. name);
  52. if(access(path, R_OK)==0)
  53. mHealthdConfig->batteryHealthPath = path;
  54. }
  56. if(mHealthdConfig->batteryPresentPath.isEmpty()){
  57. path.clear();
  58. path.appendFormat("%s/%s/present", POWER_SUPPLY_SYSFS_PATH,
  59. name);
  60. if(access(path, R_OK)==0)
  61. mHealthdConfig->batteryPresentPath = path;
  62. }
  63. /*此处就是读取电池电量值，并把读到的值保存到mHealthdConfig成员变量中*/
  64. if(mHealthdConfig->batteryCapacityPath.isEmpty()){
  65. path.clear();
  66. path.appendFormat("%s/%s/capacity", POWER_SUPPLY_SYSFS_PATH,
  67. name);
  68. if(access(path, R_OK)==0)
  69. mHealthdConfig->batteryCapacityPath = path;
  70. }
  72. if(mHealthdConfig->batteryVoltagePath.isEmpty()){
  73. path.clear();
  74. path.appendFormat("%s/%s/voltage_now",
  75. POWER_SUPPLY_SYSFS_PATH, name);
  76. if(access(path, R_OK)==0){
  77. mHealthdConfig->batteryVoltagePath = path;
  78. }else{
  79. path.clear();
  80. path.appendFormat("%s/%s/batt_vol",
  81. POWER_SUPPLY_SYSFS_PATH, name);
  82. if(access(path, R_OK)==0)
  83. mHealthdConfig->batteryVoltagePath = path;
  84. }
  85. }
  87. if(mHealthdConfig->batteryFullChargePath.isEmpty()){
  88. path.clear();
  89. path.appendFormat("%s/%s/charge_full",
  90. POWER_SUPPLY_SYSFS_PATH, name);
  91. if(access(path, R_OK)==0)
  92. mHealthdConfig->batteryFullChargePath = path;
  93. }
  95. if(mHealthdConfig->batteryCurrentNowPath.isEmpty()){
  96. path.clear();
  97. path.appendFormat("%s/%s/current_now",
  98. POWER_SUPPLY_SYSFS_PATH, name);
  99. if(access(path, R_OK)==0)
  100. mHealthdConfig->batteryCurrentNowPath = path;
  101. }
  103. if(mHealthdConfig->batteryCycleCountPath.isEmpty()){
  104. path.clear();
  105. path.appendFormat("%s/%s/cycle_count",
  106. POWER_SUPPLY_SYSFS_PATH, name);
  107. if(access(path, R_OK)==0)
  108. mHealthdConfig->batteryCycleCountPath = path;
  109. }
  111. if(mHealthdConfig->batteryCurrentAvgPath.isEmpty()){
  112. path.clear();
  113. path.appendFormat("%s/%s/current_avg",
  114. POWER_SUPPLY_SYSFS_PATH, name);
  115. if(access(path, R_OK)==0)
  116. mHealthdConfig->batteryCurrentAvgPath = path;
  117. }
  119. if(mHealthdConfig->batteryChargeCounterPath.isEmpty()){
  120. path.clear();
  121. path.appendFormat("%s/%s/charge_counter",
  122. POWER_SUPPLY_SYSFS_PATH, name);
  123. if(access(path, R_OK)==0)
  124. mHealthdConfig->batteryChargeCounterPath = path;
  125. }
  127. if(mHealthdConfig->batteryTemperaturePath.isEmpty()){
  128. path.clear();
  129. path.appendFormat("%s/%s/temp", POWER_SUPPLY_SYSFS_PATH,
  130. name);
  131. if(access(path, R_OK)==0){
  132. mHealthdConfig->batteryTemperaturePath = path;
  133. }else{
  134. path.clear();
  135. path.appendFormat("%s/%s/batt_temp",
  136. POWER_SUPPLY_SYSFS_PATH, name);
  137. if(access(path, R_OK)==0)
  138. mHealthdConfig->batteryTemperaturePath = path;
  139. }
  140. }
  142. if(mHealthdConfig->batteryTechnologyPath.isEmpty()){
  143. path.clear();
  144. path.appendFormat("%s/%s/technology",
  145. POWER_SUPPLY_SYSFS_PATH, name);
  146. if(access(path, R_OK)==0)
  147. mHealthdConfig->batteryTechnologyPath = path;
  148. }
  150. if(mHealthdConfig->batteryStatusPath_smb.isEmpty()){
  151. path.clear();
  152. path.appendFormat("%s/%s/status_smb", POWER_SUPPLY_SYSFS_PATH,
  153. name);
  154. if(access(path, R_OK)==0)
  155. mHealthdConfig->batteryStatusPath_smb = path;
  156. }
  158. if(mHealthdConfig->batteryPresentPath_smb.isEmpty()){
  159. path.clear();
  160. path.appendFormat("%s/%s/present_smb", POWER_SUPPLY_SYSFS_PATH,
  161. name);
  162. if(access(path, R_OK)==0)
  163. mHealthdConfig->batteryPresentPath_smb = path;
  164. }
  166. if(mHealthdConfig->batteryCapacityPath_smb.isEmpty()){
  167. path.clear();
  168. path.appendFormat("%s/%s/capacity_smb", POWER_SUPPLY_SYSFS_PATH,
  169. name);
  170. if(access(path, R_OK)==0)
  171. mHealthdConfig->batteryCapacityPath_smb = path;
  172. }
  174. if(mHealthdConfig->batteryAdjustPowerPath.isEmpty()){
  175. path.clear();
  176. path.appendFormat("%s/%s/adjust_power",
  177. POWER_SUPPLY_SYSFS_PATH, name);
  178. if(access(path, R_OK)==0)
  179. mHealthdConfig->batteryAdjustPowerPath = path;
  180. }
  181. break;
  183. case ANDROID_POWER_SUPPLY_TYPE_UNKNOWN:
  184. break;
  185. }
  186. }
  187. closedir(dir);
  188. }
  190. // Typically the case for devices which do not have a battery and
  191. // and are always plugged into AC mains.
  192. if(!mBatteryDevicePresent){
  193. KLOG_WARNING(LOG_TAG,"No battery devices found\n");
  194. hc->periodic_chores_interval_fast =-1;
  195. hc->periodic_chores_interval_slow =-1;
  196. mBatteryFixedCapacity = ALWAYS_PLUGGED_CAPACITY;
  197. mBatteryFixedTemperature = FAKE_BATTERY_TEMPERATURE;
  198. mAlwaysPluggedDevice =true;
  199. }else{
  200. if(mHealthdConfig->batteryStatusPath.isEmpty())
  201. KLOG_WARNING(LOG_TAG,"BatteryStatusPath not found\n");
  202. if(mHealthdConfig->batteryHealthPath.isEmpty())
  203. KLOG_WARNING(LOG_TAG,"BatteryHealthPath not found\n");
  204. if(mHealthdConfig->batteryPresentPath.isEmpty())
  205. KLOG_WARNING(LOG_TAG,"BatteryPresentPath not found\n");
  206. if(mHealthdConfig->batteryCapacityPath.isEmpty())
  207. KLOG_WARNING(LOG_TAG,"BatteryCapacityPath not found\n");
  208. if(mHealthdConfig->batteryVoltagePath.isEmpty())
  209. KLOG_WARNING(LOG_TAG,"BatteryVoltagePath not found\n");
  210. if(mHealthdConfig->batteryTemperaturePath.isEmpty())
  211. KLOG_WARNING(LOG_TAG,"BatteryTemperaturePath not found\n");
  212. if(mHealthdConfig->batteryTechnologyPath.isEmpty())
  213. KLOG_WARNING(LOG_TAG,"BatteryTechnologyPath not found\n");
  214. if(mHealthdConfig->batteryCurrentNowPath.isEmpty())
  215. KLOG_WARNING(LOG_TAG,"BatteryCurrentNowPath not found\n");
  216. if(mHealthdConfig->batteryFullChargePath.isEmpty())
  217. KLOG_WARNING(LOG_TAG,"BatteryFullChargePath not found\n");
  218. if(mHealthdConfig->batteryCycleCountPath.isEmpty())
  219. KLOG_WARNING(LOG_TAG,"BatteryCycleCountPath not found\n");
  220. if(mHealthdConfig->batteryPresentPath_smb.isEmpty())
  221. KLOG_WARNING(LOG_TAG,"BatteryPresentPath_smb not found\n");
  222. if(mHealthdConfig->batteryCapacityPath_smb.isEmpty())
  223. KLOG_WARNING(LOG_TAG,"BatteryCapacityPath_smb not found\n");
  224. if(mHealthdConfig->batteryStatusPath_smb.isEmpty())
  225. KLOG_WARNING(LOG_TAG,"BatteryStatusPath_smb not found\n");
  226. }
  228. if(property_get("ro.boot.fake_battery", pval, NULL)>0
  229. && strtol(pval, NULL,10)!=0){
  230. mBatteryFixedCapacity = FAKE_BATTERY_CAPACITY;
  231. mBatteryFixedCapacity_smb = FAKE_BATTERY_CAPACITY_SMB;
  232. mBatteryFixedTemperature = FAKE_BATTERY_TEMPERATURE;
  233. }
  234. }

该方法会打开/sys/class/power_supply目录，该目录中包含了一些子目录，/sys/class/power_supply/battery目录下存放得就是电池信息。在case ANDROID_POWER_SUPPLY_TYPE_BATTERY:情况下会生成与电池相关的文件名，并把对应的信息保存到成员变量中，方便后面读取使用。

然后是main函数进入healthd_mainloop()循环，其代码如下：

  1. staticvoid healthd_mainloop(void){
  2. while(1){
  3. struct epoll_event events[eventct];
  4. int nevents;
  5. int timeout = awake_poll_interval;
  6. int mode_timeout;
  7. mode_timeout = healthd_mode_ops->preparetowait();
  8. if(timeout <0||(mode_timeout >0&& mode_timeout < timeout))
  9. timeout = mode_timeout;
  10. nevents = epoll_wait(epollfd, events, eventct, timeout);
  11. if(nevents ==-1){
  12. if(errno == EINTR)
  13. continue;
  14. KLOG_ERROR(LOG_TAG,"healthd_mainloop: epoll_wait failed\n");
  15. break;
  16. }
  17. for(int n =0; n < nevents;++n){
  18. if(events[n].data.ptr)
  19. /* (*(void (*)(int))events[n].data.ptr)(events[n].events)这一行代码看起来好狗屎
  20. ，应该是把events[n].data.ptr(应该是某个函数指针)强制转换为参数为int型的返回值为空的函数的指针
  21. ，反正是一个指定类型的函数指针，然后再加了*号，表示调用该函数*/
  22. (*(void(*)(int))events[n].data.ptr)(events[n].events);
  23. }
  24. if(!nevents)
  25. periodic_chores();
  26. healthd_mode_ops->heartbeat();
  27. }
  28. return;
  29. }
  1. staticvoid wakealarm_event(uint32_t/*epevents*/){
  2. unsignedlonglong wakeups;
  3. if(read(wakealarm_fd,&wakeups,sizeof(wakeups))==-1){
  4. KLOG_ERROR(LOG_TAG,"wakealarm_event: read wakealarm fd failed\n");
  5. return;
  6. }
  7. periodic_chores();
  8. }
  1. staticvoid periodic_chores(){
  2. healthd_battery_update();
  3. }
  4. void healthd_battery_update(void){
  5. // Fast wake interval when on charger (watch for overheat);
  6. // slow wake interval when on battery (watch for drained battery).
  7. /*调用BatteryMonitor的update方法更新电池状态*/
  8. int new_wake_interval = gBatteryMonitor->update()?
  9. healthd_config.periodic_chores_interval_fast :
  10. healthd_config.periodic_chores_interval_slow;
  11. if(new_wake_interval != wakealarm_wake_interval)
  12. wakealarm_set_interval(new_wake_interval);
  13. // During awake periods poll at fast rate. If wake alarm is set at fast
  14. // rate then just use the alarm; if wake alarm is set at slow rate then
  15. // poll at fast rate while awake and let alarm wake up at slow rate when
  16. // asleep.
  17. if(healthd_config.periodic_chores_interval_fast ==-1)
  18. awake_poll_interval =-1;
  19. else
  20. awake_poll_interval =
  21. new_wake_interval == healthd_config.periodic_chores_interval_fast ?
  22. -1: healthd_config.periodic_chores_interval_fast *1000;
  23. }

然后查看文件system/core/healthd/BatteryMonitor.cpp中的update，该方法主要是用来读取电池信息，在health的main方法中，会通过health_mainloop()函数周期性调用它。

  1. boolBatteryMonitor::update(void){
  2. bool logthis;
  3. /*每次调用前会把BatteryProperties 对象中的值清空*/
  4. initBatteryProperties(&props);
  6. if(!mHealthdConfig->batteryPresentPath.isEmpty())
  7. props.batteryPresent = getBooleanField(mHealthdConfig->batteryPresentPath);
  8. else
  9. props.batteryPresent = mBatteryDevicePresent;
  10. /*将保存在mHealthdConfig中的电池信息赋值给BatteryProperties对象props中的各个成员变量，后面还会通过该对象把电池信息发送给上层*/
  11. props.batteryLevel = mBatteryFixedCapacity ?
  12. mBatteryFixedCapacity :
  13. getIntField(mHealthdConfig->batteryCapacityPath);
  14. props.batteryVoltage = getIntField(mHealthdConfig->batteryVoltagePath);
  16. if(!mHealthdConfig->batteryCurrentNowPath.isEmpty())
  17. props.batteryCurrent = getIntField(mHealthdConfig->batteryCurrentNowPath)/1000;
  19. if(!mHealthdConfig->batteryFullChargePath.isEmpty())
  20. props.batteryFullCharge = getIntField(mHealthdConfig->batteryFullChargePath);
  22. if(!mHealthdConfig->batteryCycleCountPath.isEmpty())
  23. props.batteryCycleCount = getIntField(mHealthdConfig->batteryCycleCountPath);
  25. if(!mHealthdConfig->batteryChargeCounterPath.isEmpty())
  26. props.batteryChargeCounter = getIntField(mHealthdConfig->batteryChargeCounterPath);
  28. props.batteryTemperature = mBatteryFixedTemperature ?
  29. mBatteryFixedTemperature :
  30. getIntField(mHealthdConfig->batteryTemperaturePath);
  31. update_smb();
  32. // For devices which do not have battery and are always plugged
  33. // into power souce.
  34. if(mAlwaysPluggedDevice){
  35. props.chargerAcOnline =true;
  36. props.batteryPresent =true;
  37. props.batteryStatus = BATTERY_STATUS_CHARGING;
  38. props.batteryHealth = BATTERY_HEALTH_GOOD;
  39. }
  41. constint SIZE =128;
  42. char buf[SIZE];
  43. String8 btech;
  45. if(readFromFile(mHealthdConfig->batteryStatusPath, buf, SIZE)>0)
  46. props.batteryStatus = getBatteryStatus(buf);
  48. if(readFromFile(mHealthdConfig->batteryHealthPath, buf, SIZE)>0)
  49. props.batteryHealth = getBatteryHealth(buf);
  51. if(readFromFile(mHealthdConfig->batteryTechnologyPath, buf, SIZE)>0)
  52. props.batteryTechnology =String8(buf);
  54. unsignedint i;
  55. doubleMaxPower=0;
  57. for(i =0; i < mChargerNames.size(); i++){
  58. String8 path;
  59. path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH,
  60. mChargerNames[i].string());
  62. if(readFromFile(path, buf, SIZE)>0){
  63. if(buf[0]!='0'){
  64. path.clear();
  65. path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH,
  66. mChargerNames[i].string());
  67. switch(readPowerSupplyType(path)){
  68. case ANDROID_POWER_SUPPLY_TYPE_AC:
  69. props.chargerAcOnline =true;
  70. break;
  71. case ANDROID_POWER_SUPPLY_TYPE_USB:
  72. props.chargerUsbOnline =true;
  73. break;
  74. case ANDROID_POWER_SUPPLY_TYPE_WIRELESS:
  75. props.chargerWirelessOnline =true;
  76. break;
  77. default:
  78. KLOG_WARNING(LOG_TAG,"%s: Unknown power supply type\n",
  79. mChargerNames[i].string());
  80. }
  81. path.clear();
  82. path.appendFormat("%s/%s/current_max", POWER_SUPPLY_SYSFS_PATH,
  83. mChargerNames[i].string());
  84. intChargingCurrent=
  85. (access(path.string(), R_OK)==0)? getIntField(path):0;
  87. path.clear();
  88. path.appendFormat("%s/%s/voltage_max", POWER_SUPPLY_SYSFS_PATH,
  89. mChargerNames[i].string());
  91. intChargingVoltage=
  92. (access(path.string(), R_OK)==0)? getIntField(path):
  93. DEFAULT_VBUS_VOLTAGE;
  95. double power =((double)ChargingCurrent/ MILLION)*
  96. ((double)ChargingVoltage/ MILLION);
  97. if(MaxPower< power){
  98. props.maxChargingCurrent =ChargingCurrent;
  99. props.maxChargingVoltage =ChargingVoltage;
  100. MaxPower= power;
  101. }
  102. }
  103. }
  104. }
  106. logthis =!healthd_board_battery_update(&props);
  108. if(logthis){
  109. char dmesgline[256];
  110. size_t len;
  111. if(props.batteryPresent){
  112. snprintf(dmesgline,sizeof(dmesgline),
  113. "battery l=%d v=%d t=%s%d.%d h=%d st=%d",
  114. props.batteryLevel, props.batteryVoltage,
  115. props.batteryTemperature <0?"-":"",
  116. abs(props.batteryTemperature /10),
  117. abs(props.batteryTemperature %10), props.batteryHealth,
  118. props.batteryStatus);
  120. len = strlen(dmesgline);
  122. if(props.batteryPresent_smb){
  123. snprintf(dmesgline,sizeof(dmesgline),
  124. "battery l2=%d st2=%d ext=%d",
  125. props.batteryLevel_smb,
  126. props.batteryStatus_smb,
  127. props.batteryPresent_smb);
  128. }
  130. if(!mHealthdConfig->batteryCurrentNowPath.isEmpty()){
  131. len += snprintf(dmesgline + len,sizeof(dmesgline)- len,
  132. " c=%d", props.batteryCurrent);
  133. }
  135. if(!mHealthdConfig->batteryFullChargePath.isEmpty()){
  136. len += snprintf(dmesgline + len,sizeof(dmesgline)- len,
  137. " fc=%d", props.batteryFullCharge);
  138. }
  140. if(!mHealthdConfig->batteryCycleCountPath.isEmpty()){
  141. len += snprintf(dmesgline + len,sizeof(dmesgline)- len,
  142. " cc=%d", props.batteryCycleCount);
  143. }
  144. }else{
  145. snprintf(dmesgline,sizeof(dmesgline),
  146. "battery none");
  147. }
  149. len = strlen(dmesgline);
  151. KLOG_WARNING(LOG_TAG,"%s chg=%s%s%s\n", dmesgline,
  152. props.chargerAcOnline ?"a":"",
  153. props.chargerUsbOnline ?"u":"",
  154. props.chargerWirelessOnline ?"w":"");
  156. snprintf(dmesgline + len,sizeof(dmesgline)- len," chg=%s%s%s",
  157. props.chargerAcOnline ?"a":"",
  158. props.chargerUsbOnline ?"u":"",
  159. props.chargerWirelessOnline ?"w":"");
  161. KLOG_WARNING(LOG_TAG,"%s\n", dmesgline);
  162. }
  163. cmd_send();
  164. healthd_mode_ops->battery_update(&props);
  165. return props.chargerAcOnline | props.chargerUsbOnline |
  166. props.chargerWirelessOnline;
  167. }

然后是通过binder把电池信息props传入到上层batteryService中，在该Service中有个BatteryListener对象，该类的定义如下：

  1. privatefinalclassBatteryListenerextendsIBatteryPropertiesListener.Stub{
  2. @Overridepublicvoid batteryPropertiesChanged(BatteryProperties props){
  3. finallong identity =Binder.clearCallingIdentity();
  4. try{
  5. BatteryService.this.update(props);
  6. }finally{
  7. Binder.restoreCallingIdentity(identity);
  8. }
  9. }
  10. }

然后会把传入的BatteryProperties对象props(里面包含的都是电池信息)通过update方法赋值给mLastBatteryProps属性，update方法具体如下：

  1. privatevoid update(BatteryProperties props){
  2. synchronized(mLock){
  3. if(!mUpdatesStopped){
  4. mBatteryProps = props;
  5. if(SystemProperties.get("ro.mtk_ipo_support").equals("1")){
  6. if(mIPOShutdown)
  7. return;
  8. }
  9. // Process the new values.
  10. if(mBootCompleted)
  11. processValuesLocked(false);
  12. }else{
  13. mLastBatteryProps.set(props);
  14. }
  15. }
  16. }

然后看看BatteryProperties类里到底有些什么，具体如下：

  1. publicclassBatteryPropertiesimplementsParcelable{
  2. publicboolean chargerAcOnline;
  3. publicboolean chargerUsbOnline;
  4. publicboolean chargerWirelessOnline;
  5. publicint maxChargingCurrent;
  6. publicint maxChargingVoltage;
  7. publicint batteryStatus;
  8. publicint batteryStatus_smb;
  9. publicint batteryHealth;
  10. publicboolean batteryPresent;
  11. publicboolean batteryPresent_smb;
  12. publicint batteryLevel;
  13. publicint batteryLevel_smb;
  14. publicint batteryVoltage;
  15. publicint batteryTemperature;
  16. publicint batteryCurrentNow;
  17. publicint batteryChargeCounter;
  18. publicint adjustPower;
  19. publicString batteryTechnology;
  21. publicBatteryProperties(){
  22. }
  24. publicvoid set(BatteryProperties other){
  25. chargerAcOnline = other.chargerAcOnline;
  26. chargerUsbOnline = other.chargerUsbOnline;
  27. chargerWirelessOnline = other.chargerWirelessOnline;
  28. maxChargingCurrent = other.maxChargingCurrent;
  29. maxChargingVoltage = other.maxChargingVoltage;
  30. batteryStatus = other.batteryStatus;
  31. batteryHealth = other.batteryHealth;
  32. batteryPresent = other.batteryPresent;
  33. batteryLevel = other.batteryLevel;
  34. batteryVoltage = other.batteryVoltage;
  35. batteryTemperature = other.batteryTemperature;
  36. batteryStatus_smb = other.batteryStatus_smb;
  37. batteryPresent_smb = other.batteryPresent_smb;
  38. batteryLevel_smb = other.batteryLevel_smb;
  39. batteryCurrentNow = other.batteryCurrentNow;
  40. batteryChargeCounter = other.batteryChargeCounter;
  41. adjustPower = other.adjustPower;
  42. batteryTechnology = other.batteryTechnology;
  43. }
  45. /*
  46. * Parcel read/write code must be kept in sync with
  47. * frameworks/native/services/batteryservice/BatteryProperties.cpp
  48. */
  50. privateBatteryProperties(Parcel p){
  51. chargerAcOnline = p.readInt()==1?true:false;
  52. chargerUsbOnline = p.readInt()==1?true:false;
  53. chargerWirelessOnline = p.readInt()==1?true:false;
  54. maxChargingCurrent = p.readInt();
  55. maxChargingVoltage = p.readInt();
  56. batteryStatus = p.readInt();
  57. batteryHealth = p.readInt();
  58. batteryPresent = p.readInt()==1?true:false;
  59. batteryLevel = p.readInt();
  60. batteryVoltage = p.readInt();
  61. batteryTemperature = p.readInt();
  62. batteryStatus_smb = p.readInt();
  63. batteryPresent_smb = p.readInt()==1?true:false;
  64. batteryLevel_smb = p.readInt();
  65. batteryCurrentNow = p.readInt();
  66. batteryChargeCounter = p.readInt();
  67. adjustPower = p.readInt();
  68. batteryTechnology = p.readString();
  69. }
  71. publicvoid writeToParcel(Parcel p,int flags){
  72. p.writeInt(chargerAcOnline ?1:0);
  73. p.writeInt(chargerUsbOnline ?1:0);
  74. p.writeInt(chargerWirelessOnline ?1:0);
  75. p.writeInt(maxChargingCurrent);
  76. p.writeInt(maxChargingVoltage);
  77. p.writeInt(batteryStatus);
  78. p.writeInt(batteryHealth);
  79. p.writeInt(batteryPresent ?1:0);
  80. p.writeInt(batteryLevel);
  81. p.writeInt(batteryVoltage);
  82. p.writeInt(batteryTemperature);
  83. p.writeInt(batteryStatus_smb);
  84. p.writeInt(batteryPresent_smb ?1:0);
  85. p.writeInt(batteryLevel_smb);
  86. p.writeInt(batteryCurrentNow);
  87. p.writeInt(batteryChargeCounter);
  88. p.writeInt(adjustPower);
  89. p.writeString(batteryTechnology);
  90. }
  92. publicstaticfinalParcelable.Creator<BatteryProperties> CREATOR
  93. =newParcelable.Creator<BatteryProperties>(){
  94. publicBatteryProperties createFromParcel(Parcel p){
  95. returnnewBatteryProperties(p);
  96. }
  98. publicBatteryProperties[] newArray(int size){
  99. returnnewBatteryProperties[size];
  100. }
  101. };
  103. publicint describeContents(){
  104. return0;
  105. }
  106. }

这个类是个工具类，主要用来打包存放电池信息和为各个电池属性进行赋值操作。然后转入batteryService.java文件。在上层处理关机动画的的流程中，主要根据如下逻辑进行操作的。

Created with Raphaël 2.1.4StartBatteryService.java中shutdownIfNoPowerLocked()方法 ShutdownActivity.javaPowerManagerService.javaShutdownThread.javaPowerManager.javaEnd
  1. st=>start:Start
  2. e=>end:End
  3. op1=>operation:BatteryService.java中shutdownIfNoPowerLocked()方法
  4. op2=>operation:ShutdownActivity.java
  5. op3=>operation:PowerManagerService.java
  6. op4=>operation:ShutdownThread.java
  7. op5=>operation:PowerManager.java
  8. st->op1->op2->op3->op4->op5->e

首先看看batteryService类的构造方法，具体代码如下：

  1. publicBatteryService(Context context){
  2. super(context);
  4. mContext = context;
  5. mHandler =newHandler(true/*async*/);
  6. mLed =newLed(context, getLocalService(LightsManager.class));
  7. mSettingsObserver =newSettingsObserver();
  8. mBatteryStats =BatteryStatsService.getService();
  10. mCriticalBatteryLevel = mContext.getResources().getInteger(
  11. com.android.internal.R.integer.config_criticalBatteryWarningLevel);
  12. mLowBatteryWarningLevel = mContext.getResources().getInteger(
  13. com.android.internal.R.integer.config_lowBatteryWarningLevel);
  14. mLowBatteryCloseWarningLevel = mLowBatteryWarningLevel + mContext.getResources().getInteger(
  15. com.android.internal.R.integer.config_lowBatteryCloseWarningBump);
  16. mShutdownBatteryTemperature = mContext.getResources().getInteger(
  17. com.android.internal.R.integer.config_shutdownBatteryTemperature);
  19. // watch for invalid charger messages if the invalid_charger switch exists
  20. if(newFile("/sys/devices/virtual/switch/invalid_charger/state").exists()){
  21. UEventObserver invalidChargerObserver =newUEventObserver(){
  22. @Override
  23. publicvoid onUEvent(UEvent event){
  24. finalint invalidCharger ="1".equals(event.get("SWITCH_STATE"))?1:0;
  25. synchronized(mLock){
  26. if(mInvalidCharger != invalidCharger){
  27. mInvalidCharger = invalidCharger;
  28. }
  29. }
  30. }
  31. };
  32. invalidChargerObserver.startObserving(
  33. "DEVPATH=/devices/virtual/switch/invalid_charger");
  34. }
  35. }

构造方法中会先获得BatteryStatsService的对象，BatteryStatsService主要功能是手机系统中各个模块和进程的耗电情况，通过BatteryStatsService来得到相关数据。然后是系统设定各种低电量报警值：

  • mLowBatteryWarningLevel

    这个是电池电量不足，系统将自动发出警报
  • mLowBatteryCloseWarningLevel

    表示停止电量不足警告的值
  • mShutdownBatteryTemperature

    表示电池温度过高，系统将自动关闭
  • mCriticalBatteryLevel

    表示电池电量太低了，低于它会自动关机

然后还会创建一个UEventObserver对象，用来监听UEvent事件，主要监听设备插入无效充电器的事件，如果发生该事件，会调用onUEvent方法。

根据控件生命周期该服务会执行onStart()方法，该方法具体代码如下：

  1. publicvoid onStart(){
  2. IBinder b =ServiceManager.getService("batteryproperties");
  3. finalIBatteryPropertiesRegistrar batteryPropertiesRegistrar =
  4. IBatteryPropertiesRegistrar.Stub.asInterface(b);
  5. try{
  6. /*系统注册监听，实时获得底层传来的电池信息*/
  7. batteryPropertiesRegistrar.registerListener(newBatteryListener());
  8. }catch(RemoteException e){
  9. // Should never happen.
  10. }
  11. /*这个if里面的逻辑实际上不会调用*/
  12. if(SystemProperties.get("ro.mtk_ipo_support").equals("1")){
  13. IntentFilter filter =newIntentFilter();
  14. filter.addAction(IPO_POWER_ON);
  15. filter.addAction(IPO_POWER_OFF);
  16. mContext.registerReceiver(newBroadcastReceiver(){
  17. @Override
  18. publicvoid onReceive(Context context,Intent intent){
  19. if(IPO_POWER_ON.equals(intent.getAction())){
  20. mIPOShutdown =false;
  21. mIPOBoot =true;
  22. // Let BatteryService to handle low battery warning.
  23. mLastBatteryLevel = mLowBatteryWarningLevel +1;
  24. update(mBatteryProps);
  25. }else
  26. if(IPO_POWER_OFF.equals(intent.getAction())){
  27. mIPOShutdown =true;
  28. }
  29. }
  30. }, filter);
  31. }
  33. mBinderService =newBinderService();
  34. publishBinderService("battery", mBinderService);
  35. publishLocalService(BatteryManagerInternal.class,newLocalService());
  36. }

该方法中主要是注册一个监听BatteryListener()，接收底层传来的电池信息，并调用 processValuesLocked()方法,BatteryListener类的具体实现前面已经展示过，这里不再累述。接下来看看processValuesLocked方法的具体实现：

  1. privatevoid processValuesLocked(boolean force){
  2. boolean logOutlier =false;
  3. long dischargeDuration =0;
  4. mBatteryLevelCritical =(mBatteryProps.batteryLevel <= mCriticalBatteryLevel);
  5. /*设置手机连接充电设备的方法*/
  6. if(mBatteryProps.chargerAcOnline){
  7. mPlugType =BatteryManager.BATTERY_PLUGGED_AC;
  8. }elseif(mBatteryProps.chargerUsbOnline){
  9. mPlugType =BatteryManager.BATTERY_PLUGGED_USB;
  10. }elseif(mBatteryProps.chargerWirelessOnline){
  11. mPlugType =BatteryManager.BATTERY_PLUGGED_WIRELESS;
  12. }else{
  13. mPlugType = BATTERY_PLUGGED_NONE;
  14. }
  16. /// M: Add for DUAL_INPUT_CHARGER_SUPPORT @{
  17. if(SystemProperties.get("ro.mtk_diso_support").equals("true")){
  18. if(mBatteryProps.chargerAcOnline && mBatteryProps.chargerUsbOnline){
  19. mPlugType =BatteryManager.BATTERY_PLUGGED_AC |BatteryManager.BATTERY_PLUGGED_USB;
  20. }
  21. }
  22. /// M: @}
  24. if(DEBUG){
  25. Slog.d(TAG,"Processing new values: "
  26. +"chargerAcOnline="+ mBatteryProps.chargerAcOnline
  27. +", chargerUsbOnline="+ mBatteryProps.chargerUsbOnline
  28. +", chargerWirelessOnline="+ mBatteryProps.chargerWirelessOnline
  29. +", maxChargingCurrent"+ mBatteryProps.maxChargingCurrent
  30. +", maxChargingVoltage"+ mBatteryProps.maxChargingVoltage
  31. +", chargeCounter"+ mBatteryProps.batteryChargeCounter
  32. +", batteryStatus="+ mBatteryProps.batteryStatus
  33. +", batteryHealth="+ mBatteryProps.batteryHealth
  34. +", batteryPresent="+ mBatteryProps.batteryPresent
  35. +", batteryLevel="+ mBatteryProps.batteryLevel
  36. +", batteryTechnology="+ mBatteryProps.batteryTechnology
  37. +", batteryVoltage="+ mBatteryProps.batteryVoltage
  38. +", batteryTemperature="+ mBatteryProps.batteryTemperature
  39. +", mBatteryLevelCritical="+ mBatteryLevelCritical
  40. +", mPlugType="+ mPlugType);
  41. }
  42. if(mLastBatteryVoltage != mBatteryProps.batteryVoltage){
  43. Log.d(TAG,"mBatteryVoltage="+ mBatteryProps.batteryVoltage +", batteryLevel="+ mBatteryProps.batteryLevel_smb);
  44. }
  45. // Update the battery LED
  46. mLed.updateLightsLocked();
  48. // Let the battery stats keep track of the current level.
  49. try{
  50. mBatteryStats.setBatteryState(mBatteryProps.batteryStatus, mBatteryProps.batteryHealth,
  51. mPlugType, mBatteryProps.batteryLevel, mBatteryProps.batteryTemperature,
  52. mBatteryProps.batteryVoltage, mBatteryProps.batteryChargeCounter);
  53. }catch(RemoteException e){
  54. // Should never happen.
  55. }
  56. /*这里就是判断低电量关机的逻辑*/
  57. shutdownIfNoPowerLocked();
  58. shutdownIfOverTempLocked();
  60. if(force ||(mBatteryProps.batteryStatus != mLastBatteryStatus ||
  61. mBatteryProps.batteryStatus_smb != mLastBatteryStatus_smb ||
  62. mBatteryProps.batteryHealth != mLastBatteryHealth ||
  63. mBatteryProps.batteryPresent != mLastBatteryPresent ||
  64. mBatteryProps.batteryPresent_smb != mLastBatteryPresent_smb ||
  65. mBatteryProps.batteryLevel != mLastBatteryLevel ||
  66. mBatteryProps.batteryLevel_smb != mLastBatteryLevel_smb ||
  67. mPlugType != mLastPlugType ||
  68. mBatteryProps.batteryVoltage != mLastBatteryVoltage ||
  69. mBatteryProps.batteryTemperature != mLastBatteryTemperature ||
  70. mBatteryProps.maxChargingCurrent != mLastMaxChargingCurrent ||
  71. mBatteryProps.maxChargingVoltage != mLastMaxChargingVoltage ||
  72. mBatteryProps.batteryChargeCounter != mLastChargeCounter ||
  73. mInvalidCharger != mLastInvalidCharger)){
  75. if(mPlugType != mLastPlugType){
  76. if(mLastPlugType == BATTERY_PLUGGED_NONE){
  77. // discharging -> charging
  79. // There's no value in this data unless we've discharged at least once and the
  80. // battery level has changed; so don't log until it does.
  81. if(mDischargeStartTime !=0&& mDischargeStartLevel != mBatteryProps.batteryLevel){
  82. dischargeDuration =SystemClock.elapsedRealtime()- mDischargeStartTime;
  83. logOutlier =true;
  84. EventLog.writeEvent(EventLogTags.BATTERY_DISCHARGE, dischargeDuration,
  85. mDischargeStartLevel, mBatteryProps.batteryLevel);
  86. // make sure we see a discharge event before logging again
  87. mDischargeStartTime =0;
  88. }
  89. }elseif(mPlugType == BATTERY_PLUGGED_NONE){
  90. // charging -> discharging or we just powered up
  91. mDischargeStartTime =SystemClock.elapsedRealtime();
  92. mDischargeStartLevel = mBatteryProps.batteryLevel;
  93. }
  94. }
  95. if(mBatteryProps.batteryStatus != mLastBatteryStatus ||
  96. mBatteryProps.batteryHealth != mLastBatteryHealth ||
  97. mBatteryProps.batteryPresent != mLastBatteryPresent ||
  98. mPlugType != mLastPlugType){
  99. EventLog.writeEvent(EventLogTags.BATTERY_STATUS,
  100. mBatteryProps.batteryStatus, mBatteryProps.batteryHealth, mBatteryProps.batteryPresent ?1:0,
  101. mPlugType, mBatteryProps.batteryTechnology);
  102. }
  103. if(mBatteryProps.batteryLevel != mLastBatteryLevel){
  104. // Don't do this just from voltage or temperature changes, that is
  105. // too noisy.
  106. EventLog.writeEvent(EventLogTags.BATTERY_LEVEL,
  107. mBatteryProps.batteryLevel, mBatteryProps.batteryVoltage, mBatteryProps.batteryTemperature);
  108. }
  109. if(mBatteryLevelCritical &&!mLastBatteryLevelCritical &&
  110. mPlugType == BATTERY_PLUGGED_NONE){
  111. // We want to make sure we log discharge cycle outliers
  112. // if the battery is about to die.
  113. dischargeDuration =SystemClock.elapsedRealtime()- mDischargeStartTime;
  114. logOutlier =true;
  115. }
  117. if(!mBatteryLevelLow){
  118. // Should we now switch in to low battery mode?
  119. if(mPlugType == BATTERY_PLUGGED_NONE
  120. && mBatteryProps.batteryLevel <= mLowBatteryWarningLevel){
  121. mBatteryLevelLow =true;
  122. }
  123. }else{
  124. // Should we now switch out of low battery mode?
  125. if(mPlugType != BATTERY_PLUGGED_NONE){
  126. mBatteryLevelLow =false;
  127. }elseif(mBatteryProps.batteryLevel >= mLowBatteryCloseWarningLevel){
  128. mBatteryLevelLow =false;
  129. }elseif(force && mBatteryProps.batteryLevel >= mLowBatteryWarningLevel){
  130. // If being forced, the previous state doesn't matter, we will just
  131. // absolutely check to see if we are now above the warning level.
  132. mBatteryLevelLow =false;
  133. }
  134. }
  136. sendIntentLocked();
  138. // Separate broadcast is sent for power connected / not connected
  139. // since the standard intent will not wake any applications and some
  140. // applications may want to have smart behavior based on this.
  141. if(mPlugType !=0&& mLastPlugType ==0){
  142. mHandler.post(newRunnable(){
  143. @Override
  144. publicvoid run(){
  145. Intent statusIntent =newIntent(Intent.ACTION_POWER_CONNECTED);
  146. statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
  147. mContext.sendBroadcastAsUser(statusIntent,UserHandle.ALL);
  148. }
  149. });
  150. }
  151. elseif(mPlugType ==0&& mLastPlugType !=0){
  152. mHandler.post(newRunnable(){
  153. @Override
  154. publicvoid run(){
  155. Intent statusIntent =newIntent(Intent.ACTION_POWER_DISCONNECTED);
  156. statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
  157. mContext.sendBroadcastAsUser(statusIntent,UserHandle.ALL);
  158. }
  159. });
  160. }
  162. if(shouldSendBatteryLowLocked()){
  163. mSentLowBatteryBroadcast =true;
  164. mHandler.post(newRunnable(){
  165. @Override
  166. publicvoid run(){
  167. Intent statusIntent =newIntent(Intent.ACTION_BATTERY_LOW);
  168. statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
  169. mContext.sendBroadcastAsUser(statusIntent,UserHandle.ALL);
  170. }
  171. });
  172. }elseif(mSentLowBatteryBroadcast && mLastBatteryLevel >= mLowBatteryCloseWarningLevel){
  173. mSentLowBatteryBroadcast =false;
  174. mHandler.post(newRunnable(){
  175. @Override
  176. publicvoid run(){
  177. Intent statusIntent =newIntent(Intent.ACTION_BATTERY_OKAY);
  178. statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
  179. mContext.sendBroadcastAsUser(statusIntent,UserHandle.ALL);
  180. }
  181. });
  182. }
  184. if(mBatteryProps.batteryStatus != mLastBatteryStatus &&
  185. mBatteryProps.batteryStatus ==BatteryManager.BATTERY_STATUS_CMD_DISCHARGING){
  186. mHandler.post(newRunnable(){
  187. @Override
  188. publicvoid run(){
  189. finalString ACTION_IGNORE_DATA_USAGE_ALERT =
  190. "android.intent.action.IGNORE_DATA_USAGE_ALERT";
  192. Log.d(TAG,"sendBroadcast ACTION_IGNORE_DATA_USAGE_ALERT");
  193. Intent statusIntent =newIntent(ACTION_IGNORE_DATA_USAGE_ALERT);
  194. statusIntent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
  195. mContext.sendBroadcastAsUser(statusIntent,UserHandle.ALL);
  196. }
  197. });
  198. }
  200. // Update the battery LED
  201. // mLed.updateLightsLocked();
  203. // This needs to be done after sendIntent() so that we get the lastest battery stats.
  204. if(logOutlier && dischargeDuration !=0){
  205. logOutlierLocked(dischargeDuration);
  206. }
  208. mLastBatteryStatus = mBatteryProps.batteryStatus;
  209. mLastBatteryStatus_smb = mBatteryProps.batteryStatus_smb;
  210. mLastBatteryHealth = mBatteryProps.batteryHealth;
  211. mLastBatteryPresent = mBatteryProps.batteryPresent;
  212. mLastBatteryPresent_smb = mBatteryProps.batteryPresent_smb;
  213. mLastBatteryLevel = mBatteryProps.batteryLevel;
  214. mLastBatteryLevel_smb = mBatteryProps.batteryLevel_smb;
  215. mLastPlugType = mPlugType;
  216. mLastBatteryVoltage = mBatteryProps.batteryVoltage;
  217. mLastBatteryTemperature = mBatteryProps.batteryTemperature;
  218. mLastMaxChargingCurrent = mBatteryProps.maxChargingCurrent;
  219. mLastMaxChargingVoltage = mBatteryProps.maxChargingVoltage;
  220. mLastChargeCounter = mBatteryProps.batteryChargeCounter;
  221. mLastBatteryLevelCritical = mBatteryLevelCritical;
  222. mLastInvalidCharger = mInvalidCharger;
  223. }
  224. }

每次有电池信息改变是，都会调用processValuesLocked这个方法，并通过shutdownIfNoPowerLocked();来判断是否进入低电量关机逻辑。然后看看shutdownIfNoPowerLocked的实现：

  1. privatevoid shutdownIfNoPowerLocked(){
  2. // shut down gracefully if our battery is critically low and we are not powered.
  3. // wait until the system has booted before attempting to display the shutdown dialog.
  4. /*即判断如果电池电量为0，并且没有连接充电设备 就进入if逻辑中*/
  5. if(mBatteryProps.batteryLevel ==0&&!isPoweredLocked(BatteryManager.BATTERY_PLUGGED_ANY)){
  6. mHandler.post(newRunnable(){
  7. @Override
  8. publicvoid run(){
  9. if(ActivityManagerNative.isSystemReady()){
  10. if(SystemProperties.get("ro.mtk_ipo_support").equals("1")){
  11. SystemProperties.set("sys.ipo.battlow","1");
  12. }
  13. Intent intent =newIntent(Intent.ACTION_REQUEST_SHUTDOWN);
  14. /*把一些相关信息通过intent，传入目标activity中*/
  15. intent.putExtra(Intent.EXTRA_KEY_CONFIRM,false);
  16. intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  17. mContext.startActivityAsUser(intent,UserHandle.CURRENT);
  18. }
  19. }
  20. });
  21. }
  22. }
  1. <activityandroid:name="com.android.internal.app.ShutdownActivity"
  2. android:permission="android.permission.SHUTDOWN"
  3. android:theme="@style/Theme.NoDisplay"
  4. android:excludeFromRecents="true">
  5. <intent-filter>
  6. <actionandroid:name="android.intent.action.ACTION_REQUEST_SHUTDOWN"/>
  7. <categoryandroid:name="android.intent.category.DEFAULT"/>
  8. </intent-filter>
  9. <intent-filter>
  10. <actionandroid:name="android.intent.action.REBOOT"/>
  11. <categoryandroid:name="android.intent.category.DEFAULT"/>
  12. </intent-filter>
  13. </activity>

然后查看ShutdownActivity.java的具体实现

  1. publicclassShutdownActivityextendsActivity{
  3. privatestaticfinalString TAG ="ShutdownActivity";
  4. privateboolean mReboot;
  5. privateboolean mConfirm;
  6. privateboolean mUserRequested;
  8. @Override
  9. protectedvoid onCreate(Bundle savedInstanceState){
  10. super.onCreate(savedInstanceState);
  12. Intent intent = getIntent();
  13. mReboot =Intent.ACTION_REBOOT.equals(intent.getAction());
  14. mConfirm = intent.getBooleanExtra(Intent.EXTRA_KEY_CONFIRM,false);
  15. mUserRequested = intent.getBooleanExtra(Intent.EXTRA_USER_REQUESTED_SHUTDOWN,false);
  16. Slog.i(TAG,"onCreate(): confirm="+ mConfirm);
  18. Thread thr =newThread("ShutdownActivity"){
  19. @Override
  20. publicvoid run(){
  21. IPowerManager pm =IPowerManager.Stub.asInterface(
  22. ServiceManager.getService(Context.POWER_SERVICE));
  23. try{
  24. if(mReboot){
  25. pm.reboot(mConfirm,null,false);
  26. }else{
  27. pm.shutdown(mConfirm,
  28. mUserRequested ?PowerManager.SHUTDOWN_USER_REQUESTED :null,
  29. false);
  30. }
  31. }catch(RemoteException e){
  32. }
  33. }
  34. };
  35. thr.start();
  36. finish();
  37. // Wait for us to tell the power manager to shutdown.
  38. try{
  39. thr.join();
  40. }catch(InterruptedException e){
  41. }
  42. }
  43. }

在该activity中，首先会得到intent中的附件信息，然后创建一个线程，在线程中获得一个IPowerManager对象，并调用它的相关方法。然后转到PowerManagerService.java，PowerManagerService继承了SystemService，它的shutdown方法具体实现如下：

  1. publicvoid shutdown(boolean confirm,String reason,boolean wait){ mContext.enforceCallingOrSelfPermission(android.Manifest.permission.REBOOT,null);
  2. finallong ident =Binder.clearCallingIdentity();
  3. try{
  4. shutdownOrRebootInternal(HALT_MODE_SHUTDOWN, confirm, reason, wait);
  5. }finally{
  6. Binder.restoreCallingIdentity(ident);
  7. }
  8. }
  9. privatevoid shutdownOrRebootInternal(final@HaltModeint haltMode,finalboolean confirm,
  10. finalString reason,boolean wait){
  11. if(mHandler ==null||!mSystemReady){
  12. thrownewIllegalStateException("Too early to call shutdown() or reboot()");
  13. }
  14. /*创建一个线程来做关机出来*/
  15. Runnable runnable =newRunnable(){
  16. @Override
  17. publicvoid run(){
  18. synchronized(this){
  19. /*选择重启或关机*/
  20. if(haltMode == HALT_MODE_REBOOT_SAFE_MODE){
  21. ShutdownThread.rebootSafeMode(mContext, confirm);
  22. }elseif(haltMode == HALT_MODE_REBOOT){
  23. ShutdownThread.reboot(mContext, reason, confirm);
  24. }else{
  25. ShutdownThread.shutdown(mContext, reason, confirm);
  26. }
  27. }
  28. }
  29. };
  31. // ShutdownThread must run on a looper capable of displaying the UI.
  32. Message msg =Message.obtain(mHandler, runnable);
  33. msg.setAsynchronous(true);
  34. /*把线程对象通过Message发出去？？*/
  35. mHandler.sendMessage(msg);
  37. // PowerManager.reboot() is documented not to return so just wait for the inevitable.
  38. if(wait){
  39. synchronized(runnable){
  40. while(true){
  41. try{
  42. runnable.wait();
  43. }catch(InterruptedException e){
  44. }
  45. }
  46. }
  47. }
  48. }

然后查看ShutdownThread.java的shutdown方法，其实现如下：

  1. publicstaticvoid shutdown(finalContext context,String reason,boolean confirm){
  2. mReboot =false;
  3. mRebootSafeMode =false;
  4. mReason = reason;
  6. Log.d(TAG,"!!! Request to shutdown !!!");
  8. if(mSpew){
  9. StackTraceElement[] stack =newThrowable().getStackTrace();
  10. for(StackTraceElement element : stack)
  11. {
  12. Log.d(TAG," |----"+ element.toString());
  13. }
  14. }
  16. if(SystemProperties.getBoolean("ro.monkey",false)){
  17. Log.d(TAG,"Cannot request to shutdown when Monkey is running, returning.");
  18. return;
  19. }
  21. shutdownInner(context, confirm);
  22. }
  24. staticvoid shutdownInner(finalContext context,boolean confirm){
  25. // ensure that only one thread is trying to power down.
  26. // any additional calls are just returned
  27. synchronized(sIsStartedGuard){
  28. if(sIsStarted){
  29. Log.d(TAG,"Request to shutdown already running, returning.");
  30. return;
  31. }
  32. }
  33. bConfirmForAnimation = confirm;
  35. finalint longPressBehavior = context.getResources().getInteger(
  36. com.android.internal.R.integer.config_longPressOnPowerBehavior);
  37. finalint resourceId = mRebootSafeMode
  38. ? com.android.internal.R.string.reboot_safemode_confirm
  39. :(mReboot
  40. ? com.android.internal.R.string.reboot_confirm
  41. : com.android.internal.R.string.shutdown_confirm);
  43. Log.d(TAG,"Notifying thread to start shutdown longPressBehavior="+ longPressBehavior);
  44. /*低电量关机流程时，confirm==false，因此走else分支*/
  45. if(confirm){
  46. finalCloseDialogReceiver closer =newCloseDialogReceiver(context);
  47. if(sConfirmDialog !=null){
  48. sConfirmDialog.dismiss();
  49. }
  50. bConfirmForAnimation = confirm;
  51. Log.d(TAG,"PowerOff dialog doesn't exist. Create it first");
  52. sConfirmDialog =newAlertDialog.Builder(context)
  53. .setTitle(mRebootSafeMode
  54. ? com.android.internal.R.string.reboot_safemode_title
  55. :(mReboot
  56. ? com.android.internal.R.string.reboot_title
  57. : com.android.internal.R.string.power_off))
  59. /*OLD : com.android.internal.R.string.power_off)*/
  60. .setMessage(resourceId)
  61. .setPositiveButton(mReboot
  62. ? com.android.internal.R.string.yes
  63. : com.android.internal.R.string.power_off_confirm_bt,
  64. newDialogInterface.OnClickListener(){
  65. publicvoid onClick(DialogInterface dialog,int which){
  66. beginShutdownSequence(context);
  67. }
  68. })
  69. .setNegativeButton(com.android.internal.R.string.no,null)
  70. .create();
  71. closer.dialog = sConfirmDialog;
  72. sConfirmDialog.setOnDismissListener(closer);
  73. sConfirmDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG);
  74. sConfirmDialog.show();
  75. }else{/*进入低电量关机流程*/
  76. beginShutdownSequence(context);
  77. }
  78. }
  1. privatestaticvoid beginShutdownSequence(Context context){
  2. Intent newIntent =newIntent("begin.Shutdown.Sequence");
  3. context.sendBroadcast(newIntent);
  4. synchronized(sIsStartedGuard){
  5. if(sIsStarted){
  6. Log.d(TAG,"Shutdown sequence already running, returning.");
  7. return;
  8. }
  9. sIsStarted =true;
  10. }
  11. // Throw up a system dialog to indicate the device is rebooting / shutting down.
  12. /*此处应该是创建Dialog，如正常关机前 会让用户选择是重启 ？关机？ 飞行模式？等等 ，不过低电量关机 和这个Dialog 没什么关系*/
  13. ProgressDialog pd =newProgressDialog(context);
  14. // Path 1: Reboot to recovery for update
  15. // Condition: mReason == REBOOT_RECOVERY_UPDATE
  16. //
  17. // Path 1a: uncrypt needed
  18. // Condition: if /cache/recovery/uncrypt_file exists but
  19. // /cache/recovery/block.map doesn't.
  20. // UI: determinate progress bar (mRebootHasProgressBar == True)
  21. //
  22. // * Path 1a is expected to be removed once the GmsCore shipped on
  23. // device always calls uncrypt prior to reboot.
  24. //
  25. // Path 1b: uncrypt already done
  26. // UI: spinning circle only (no progress bar)
  27. //
  28. // Path 2: Reboot to recovery for factory reset
  29. // Condition: mReason == REBOOT_RECOVERY
  30. // UI: spinning circle only (no progress bar)
  31. //
  32. // Path 3: Regular reboot / shutdown
  33. // Condition: Otherwise
  34. // UI: spinning circle only (no progress bar)
  35. /*又是一大拨if 判断 */
  36. if(PowerManager.REBOOT_RECOVERY_UPDATE.equals(mReason)){
  37. // We need the progress bar if uncrypt will be invoked during the
  38. // reboot, which might be time-consuming.
  39. mRebootHasProgressBar =RecoverySystem.UNCRYPT_PACKAGE_FILE.exists()
  40. &&!(RecoverySystem.BLOCK_MAP_FILE.exists());
  41. pd.setTitle(context.getText(com.android.internal.R.string.reboot_to_update_title));
  42. if(mRebootHasProgressBar){
  43. pd.setMax(100);
  44. pd.setProgress(0);
  45. pd.setIndeterminate(false);
  46. pd.setProgressNumberFormat(null);
  47. pd.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
  48. pd.setMessage(context.getText(
  49. com.android.internal.R.string.reboot_to_update_prepare));
  50. pd.setCancelable(false);
  51. pd.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG);
  52. pd.show();
  53. sInstance.mProgressDialog = pd;
  54. }else{
  55. pd.setIndeterminate(true);
  56. pd.setMessage(context.getText(
  57. com.android.internal.R.string.reboot_to_update_reboot));
  58. }
  59. }elseif(PowerManager.REBOOT_RECOVERY.equals(mReason)){
  60. // Factory reset path. Set the dialog message accordingly.
  61. pd.setTitle(context.getText(com.android.internal.R.string.reboot_to_reset_title));
  62. pd.setMessage(context.getText(
  63. com.android.internal.R.string.reboot_to_reset_message));
  64. pd.setIndeterminate(true);
  65. }else{
  66. pd.setTitle(context.getText(com.android.internal.R.string.power_off));
  67. pd.setMessage(context.getText(com.android.internal.R.string.shutdown_progress));
  68. pd.setIndeterminate(true);
  69. }
  70. pd.setCancelable(false);
  71. pd.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG);
  73. // start the thread that initiates shutdown
  74. sInstance.mContext = context;
  75. sInstance.mPowerManager =(PowerManager)context.getSystemService(Context.POWER_SERVICE);
  76. sInstance.mHandler =newHandler(){
  77. };
  79. beginAnimationTime =0;
  80. /*关机动画客制化*/
  81. boolean mShutOffAnimation = configShutdownAnimation(context);
  82. /*即获得关机时 动画的播放时间？??*/
  83. int screenTurnOffTime = getScreenTurnOffTime(context);
  84. synchronized(mEnableAnimatingSync){
  85. if(mEnableAnimating){
  86. if(mRebootHasProgressBar){
  87. pd.show();
  88. screenTurnOffTime += MAX_UNCRYPT_WAIT_TIME;
  89. sInstance.mProgressDialog = pd;
  90. }else{
  91. /*低电量关机会走这个分支*/
  92. Log.d(TAG,"mIBootAnim.isCustBootAnim() is true");
  93. /*这里调用 bootanimCust方法来播放关机动画，实际上是开启一个播放关机动画的服务*/
  94. bootanimCust(context);
  95. }
  96. sInstance.mHandler.postDelayed(mDelayDim, screenTurnOffTime);
  97. }
  98. }
  100. // make sure we never fall asleep again
  101. sInstance.mCpuWakeLock =null;
  102. try{
  103. sInstance.mCpuWakeLock = sInstance.mPowerManager.newWakeLock(
  104. PowerManager.PARTIAL_WAKE_LOCK, TAG +"-cpu");
  105. sInstance.mCpuWakeLock.setReferenceCounted(false);
  106. sInstance.mCpuWakeLock.acquire();
  107. }catch(SecurityException e){
  108. Log.w(TAG,"No permission to acquire wake lock", e);
  109. sInstance.mCpuWakeLock =null;
  110. }
  112. // also make sure the screen stays on for better user experience
  113. sInstance.mScreenWakeLock =null;
  114. if(sInstance.mPowerManager.isScreenOn()){
  115. try{
  116. sInstance.mScreenWakeLock = sInstance.mPowerManager.newWakeLock(
  117. PowerManager.FULL_WAKE_LOCK, TAG +"-screen");
  118. sInstance.mScreenWakeLock.setReferenceCounted(false);
  119. sInstance.mScreenWakeLock.acquire();
  120. }catch(SecurityException e){
  121. Log.w(TAG,"No permission to acquire wake lock", e);
  122. sInstance.mScreenWakeLock =null;
  123. }
  124. }
  126. // also make sure the screen stays on for better user experience
  127. //sInstance.mScreenWakeLock = null;
  128. if(sInstance.mPowerManager.isScreenOn()){
  129. // if Screen old state is on, keep it on
  130. if(sInstance.mScreenWakeLock ==null){
  131. Log.d(TAG,"Screen old state is on, keep screen on !");
  132. try{
  133. sInstance.mScreenWakeLock = sInstance.mPowerManager.newWakeLock(
  134. PowerManager.FULL_WAKE_LOCK, TAG +"-screen");
  135. sInstance.mScreenWakeLock.setReferenceCounted(false);
  136. sInstance.mScreenWakeLock.acquire();
  137. }catch(SecurityException e){
  138. Log.w(TAG,"No permission to acquire wake lock", e);
  139. sInstance.mScreenWakeLock =null;
  140. }
  141. }else{
  142. Log.d(TAG,"Screen is already wake up !");
  143. }
  144. }else{
  145. // WARING: if system is in low power level, pls charge your phone immediately
  146. Log.d(TAG,"First time wake up Screen failed, try to wake up Screen second time !");
  147. wakeUpScreen();
  148. }
  150. if(sInstance.getState()!=Thread.State.NEW || sInstance.isAlive()){
  151. if(sInstance.mShutdownFlow == IPO_SHUTDOWN_FLOW){
  152. Log.d(TAG,"ShutdownThread exists already");
  153. checkShutdownFlow();
  154. synchronized(mShutdownThreadSync){
  155. mShutdownThreadSync.notify();
  156. }
  157. }else{
  158. Log.e(TAG,"Thread state is not normal! froce to shutdown!");
  159. delayForPlayAnimation();
  160. //unmout data/cache partitions while performing shutdown
  161. sInstance.mPowerManager.goToSleep(SystemClock.uptimeMillis(),
  162. PowerManager.GO_TO_SLEEP_REASON_SHUTDOWN,0);
  163. PowerManagerService.lowLevelShutdown(mReason);
  164. }
  165. }else{
  166. /*开启线程 关闭系统的所有服务*/
  167. sInstance.start();
  168. }
  169. }

beginShutdownSequence主要处理关机过程中的一系列流程，通过调用bootanimCust(context)来开机播放关机动画的服务，然后会计算关机动画时间并保证这个时间中屏幕不会熄灭，同时开启一个sInstance线程来关闭系统中的服务。bootanimCust方法现象代码如下：

  1. privatestaticvoid bootanimCust(Context context){
  2. // [MTK] fix shutdown animation timing issue
  3. //==================================================================
  4. SystemProperties.set("service.shutanim.running","0");
  5. Log.i(TAG,"set service.shutanim.running to 0");
  6. //==================================================================
  7. boolean isRotaionEnabled =false;
  8. try{
  9. isRotaionEnabled =Settings.System.getInt(context.getContentResolver(),
  10. Settings.System.ACCELEROMETER_ROTATION,1)!=0;
  11. if(isRotaionEnabled){
  12. finalIWindowManager wm =IWindowManager.Stub.asInterface(
  13. ServiceManager.getService(Context.WINDOW_SERVICE));
  14. if(wm !=null){
  15. wm.freezeRotation(Surface.ROTATION_0);
  16. }
  17. Settings.System.putInt(context.getContentResolver(),
  18. Settings.System.ACCELEROMETER_ROTATION,0);
  19. Settings.System.putInt(context.getContentResolver(),
  20. Settings.System.ACCELEROMETER_ROTATION_RESTORE,1);
  21. }
  22. }catch(NullPointerException ex){
  23. Log.e(TAG,"check Rotation: context object is null when get Rotation");
  24. }catch(RemoteException e){
  25. e.printStackTrace();
  26. }
  27. beginAnimationTime =SystemClock.elapsedRealtime()+ MIN_SHUTDOWN_ANIMATION_PLAY_TIME;
  28. try{
  29. finalIWindowManager wm =IWindowManager.Stub.asInterface(
  30. ServiceManager.getService(Context.WINDOW_SERVICE));
  31. if(wm !=null){
  32. wm.setEventDispatching(false);
  33. }
  34. }catch(RemoteException e){
  35. e.printStackTrace();
  36. }
  37. startBootAnimation();
  38. }
  39. privatestaticvoid startBootAnimation(){
  40. Log.d(TAG,"Set 'service.bootanim.exit' = 0).");
  41. SystemProperties.set("service.bootanim.exit","0");
  43. if(bPlayaudio){
  44. /*在文件ServiceManager.cpp中有如下注释
  45. - Starting a service is done by writing its name to the "ctl.start" system property. This triggers the init daemon to actually start
  46. the service for us.
  47. 大概意思就是向ctl.start属性中写入某个服务名，触发器会开启该服务吧（英文不好 反正大概知道是会开启某个服务的意思）
  48. Stopping the service is done by writing its name to "ctl.stop"
  49. in a similar way
  50. 低电量关机进入if逻辑中 此处会开启一个服务来播放关机动画*/
  51. SystemProperties.set("ctl.start","banim_shutmp3");
  52. Log.d(TAG,"bootanim:shut mp3");
  53. }else{
  54. //SystemProperties.set("ctl.start", "bootanim:shut nomp3");
  55. SystemProperties.set("ctl.start","banim_shutnomp3");
  56. Log.d(TAG,"bootanim:shut nomp3");
  57. }
  58. }

然后SystemProperties.set("ctl.start", "banim_shutmp3");到底会开启什么服务呢？通过文件frameworks/base/cmds/bootanimation/bootanim.rc可以看到如下代码：

  1. service bootanim /system/bin/bootanimation
  2. class core
  3. user graphics
  4. group graphics audio
  5. disabled
  6. oneshot
  8. # MTK add
  9. service banim_shutmp3 /system/bin/bootanimation shut mp3
  10. class core
  11. user graphics
  12. group graphics audio
  13. disabled
  14. oneshot
  16. service banim_shutnomp3 /system/bin/bootanimation shut nomp3
  17. class core
  18. user graphics
  19. group graphics audio
  20. disabled
  21. oneshot

所以会开启banim_shutmp3这个服务器，该服务的可执行文件为/system/bin/bootanimation，这个服务就是播放关机动画的服务了，该服务的实现代码在frameworks/base/cmds/bootanimation/目录下。

首先查看下frameworks/base/cmds/bootanimation/bootanimation_main.cpp具体代码：

  1. int main(int argc,char** argv)
  2. {
  3. setpriority(PRIO_PROCESS,0, ANDROID_PRIORITY_DISPLAY);
  5. char value[PROPERTY_VALUE_MAX];
  6. /*获得debug.sf.nobootanimation的值 存入value属性中 如果为1 不会进入下面的if中即不会播放动画*/
  7. property_get("debug.sf.nobootanimation", value,"0");
  8. int noBootAnimation = atoi(value);
  9. ALOGI_IF(noBootAnimation,"boot animation disabled");
  10. if(!noBootAnimation){
  12. sp<ProcessState> proc(ProcessState::self());
  13. ProcessState::self()->startThreadPool();
  15. /* M: use our construction method, because we support shut down animation @{
  16. // create the boot animation object
  17. sp<BootAnimation> boot = new BootAnimation();
  19. @} */
  20. bool setBoot =true;
  21. bool setRotated =false;
  22. bool sePaly =true;
  23. /*因为传入了2个参数shut和mp3 */
  24. if(argc >1){
  25. if(!strcmp(argv[1],"shut"))
  26. /*会进入该逻辑*/
  27. setBoot =false;
  28. }
  29. if(argc >2){
  30. if(!strcmp(argv[2],"nomp3"))
  31. sePaly =false;
  32. }
  33. if(argc >3){
  34. if(!strcmp(argv[3],"rotate"))
  35. setRotated =true;
  36. }
  37. ALOGD("[BootAnimation %s %d]setBoot=%d,sePaly=%d,setRotated=%d",__FUNCTION__,__LINE__,setBoot,sePaly,setRotated);
  38. char volume[PROPERTY_VALUE_MAX];
  39. intLoopCounter=60;
  40. int nVolume =-1;
  41. while(LoopCounter-->0&&(nVolume ==-1)){
  42. property_get("persist.sys.mute.state", volume,"-1");
  43. nVolume = atoi(volume);
  44. ALOGD("BootAnimation wait for sample ready, sleep 100ms");
  45. usleep(100*1000);
  46. }
  47. ALOGD("[BootAnimation %s %d]nVolume=%d",__FUNCTION__,__LINE__,nVolume);
  48. if(nVolume ==0|| nVolume ==1){
  49. sePaly =false;
  50. }
  51. ALOGD("before new BootAnimation...");
  52. ALOGD("[BootAnimation %s %d]before new BootAnimation...",__FUNCTION__,__LINE__);
  53. /*创建一个BootAnimation对象 其中 参数值setBoot=0,sePaly=1,setRotated=0*/
  54. sp<BootAnimation> boot =newBootAnimation(setBoot,sePaly,setRotated);
  55. ALOGD("joinThreadPool...");
  56. ALOGD("[BootAnimation %s %d]before joinThreadPool...",__FUNCTION__,__LINE__);
  57. IPCThreadState::self()->joinThreadPool();
  59. }
  60. ALOGD("[BootAnimation %s %s %d]end",__FILE__,__FUNCTION__,__LINE__);
  61. return0;
  62. }

然后看看BootAnimation类，该类的声明如下：

  1. classBootAnimation:publicThread,publicIBinder::DeathRecipient
  2. {
  3. public:
  4. BootAnimation();
  5. BootAnimation(bool bSetBootOrShutDown,bool bSetPlayMP3,bool bSetRotated);
  6. virtual~BootAnimation();
  7. void setBootVideoPlayState(int playState);
  9. sp<SurfaceComposerClient> session()const;
  11. private:
  12. virtualbool threadLoop();
  13. virtualstatus_t readyToRun();
  14. virtualvoid onFirstRef();
  15. virtualvoid binderDied(const wp<IBinder>& who);
  17. structTexture{
  18. GLint w;
  19. GLint h;
  20. GLuint name;
  21. };
  23. structAnimation{
  24. structFrame{
  25. String8 name;
  26. FileMap* map;
  27. String8 fullPath;
  28. mutableGLuint tid;
  29. booloperator<(constFrame& rhs)const{
  30. return name < rhs.name;
  31. }
  32. };
  33. structPart{
  34. int count;// The number of times this part should repeat, 0 for infinite
  35. int pause;// The number of frames to pause for at the end of this part
  36. int clockPosY;// The y position of the clock, in pixels, from the bottom of the
  37. // display (the clock is centred horizontally). -1 to disable the clock
  38. String8 path;
  39. SortedVector<Frame> frames;
  40. bool playUntilComplete;
  41. float backgroundColor[3];
  42. FileMap* audioFile;
  43. Animation* animation;
  44. };
  45. int fps;
  46. int width;
  47. int height;
  48. Vector<Part> parts;
  49. String8 audioConf;
  50. String8 fileName;
  51. ZipFileRO* zip;
  52. };
  54. status_t initTexture(Texture* texture,AssetManager& asset,constchar* name);
  55. status_t initTexture(constAnimation::Frame& frame);
  56. bool android();
  57. bool movie();
  58. status_t initTexture(constSkBitmap* bitmap);
  59. bool gifMovie();
  60. void drawTime(constTexture& clockTex,constint yPos);
  61. Animation* loadAnimation(constString8&);
  62. bool playAnimation(constAnimation&);
  63. void releaseAnimation(Animation*)const;
  64. bool parseAnimationDesc(Animation&);
  65. bool preloadZip(Animation&animation);
  67. void checkExit();
  69. sp<SurfaceComposerClient> mSession;
  70. sp<AudioPlayer> mAudioPlayer;
  71. AssetManager mAssets;
  72. Texture mAndroid[2];
  73. Texture mClock;
  74. int mWidth;
  75. int mHeight;
  76. EGLDisplay mDisplay;
  77. EGLDisplay mContext;
  78. EGLDisplay mSurface;
  79. sp<SurfaceControl> mFlingerSurfaceControl;
  80. sp<Surface> mFlingerSurface;
  82. bool mClockEnabled;
  83. String8 mZipFileName;
  84. SortedVector<String8> mLoadedFiles;
  86. ZipFileRO*mZip;
  87. status_t initTexture(constchar*EntryName);
  88. void initBootanimationZip(char* naimationname);
  89. void initShutanimationZip(char* naimationname);
  90. constchar* initAudioPath();
  91. bool ETC1movie();
  92. void initShader();
  93. GLuint buildShader(constchar* source,GLenum shaderType);
  94. GLuint buildProgram (constchar* vertexShaderSource,constchar* fragmentShaderSource);
  96. bool bBootOrShutDown;
  97. bool bShutRotate;
  98. bool bPlayMP3;
  99. GLuint mProgram;
  100. GLint mAttribPosition;
  101. GLint mAttribTexCoord;
  102. GLint mUniformTexture;
  103. bool bETC1Movie;
  104. int mBootVideoPlayType;
  105. int mBootVideoPlayState;
  106. SkMovie* mSkMovie;
  107. Texture mJRD;
  108. int mMcc;
  109. int mMnc;
  110. int mSpn;
  111. bool isTelefonica;
  112. char mMccMnc[PROPERTY_VALUE_MAX];
  113. char mOperator[PROPERTY_VALUE_MAX];
  114. bool mEnableSsv;
  115. bool mIsValidMccMnc;
  116. char mSsvAnimationPath[PROPERTY_VALUE_MAX];
  117. void getSsvAnimationPath(char* ssvAnimationPath,constchar* mccmnc,constchar* animationName);
  118. void initSsv();
  119. };

3. solution

通过查看关机log，发现电量值为0的时候，方法shutdownIfNoPowerLocked()通过binder接受到从底层传入的电池电量值并不为0，即条件判断if (mBatteryProps.batteryLevel == 0 && !isPoweredLocked(BatteryManager.BATTERY_PLUGGED_ANY))为false。所以后面的播放关机动画的逻辑是不会走的，而电池的实际电量值已经为0了，所以才会没有播放关机动画就黑屏关机。

既然找到了问题，所以查看为什么在电池电量值为0的时候，上层收到mBatteryProps.batteryLevel属性并不为0呢。在文件battery_common_fg_20.c中函数mt_battery_update_EM实现如下：

  1. staticvoid mt_battery_update_EM(struct battery_data *bat_data)
  2. {
  3. if((BMT_status.UI_SOC2 <=0)&&(BMT_status.bat_vol >= SYSTEM_OFF_VOLTAGE ))
  4. bat_data->BAT_CAPACITY =1;
  5. else
  6. bat_data->BAT_CAPACITY = BMT_status.UI_SOC2;
  7. bat_data->BAT_TemperatureR = BMT_status.temperatureR;/* API */
  8. bat_data->BAT_TempBattVoltage = BMT_status.temperatureV;/* API */
  9. bat_data->BAT_InstatVolt = BMT_status.bat_vol;/* VBAT */
  10. bat_data->BAT_BatteryAverageCurrent = BMT_status.ICharging;
  11. bat_data->BAT_BatterySenseVoltage = BMT_status.bat_vol;
  12. bat_data->BAT_ISenseVoltage = BMT_status.Vsense;/* API */
  13. bat_data->BAT_ChargerVoltage = BMT_status.charger_vol;
  14. bat_data->BAT_batt_id = BMT_status.id_vol;
  15. /* Dual battery */
  16. bat_data->status_smb = g_status_smb;
  17. bat_data->capacity_smb = g_capacity_smb;
  18. bat_data->present_smb = g_present_smb;
  19. battery_log(BAT_LOG_FULL,"status_smb = %d, capacity_smb = %d, present_smb = %d\n",
  20. bat_data->status_smb, bat_data->capacity_smb, bat_data->present_smb);
  21. if((BMT_status.UI_SOC2 ==100)&&(BMT_status.charger_exist == KAL_TRUE)
  22. &&(BMT_status.bat_charging_state != CHR_ERROR))
  23. bat_data->BAT_STATUS = POWER_SUPPLY_STATUS_FULL;
  25. #ifdef CONFIG_MTK_DISABLE_POWER_ON_OFF_VOLTAGE_LIMITATION
  26. if(bat_data->BAT_CAPACITY <=0)
  27. bat_data->BAT_CAPACITY =1;
  29. battery_log(BAT_LOG_CRTI,
  30. "BAT_CAPACITY=1, due to define CONFIG_MTK_DISABLE_POWER_ON_OFF_VOLTAGE_LIMITATION\r\n");
  31. #endif
  32. }

在该函数中就是将电池驱动的信息写入对应节点的操作，属性BMT_status.UI_SOC2就是对应电池的实际电量值。在该if条件语句中，首先判断实际电量值是否低于或等于0，如果是ture就继续判断电池电压值BMT_status.bat_vol是否高于设定关机电压，如果电量值为0但是电压值还是过高(高于SYSTEM_OFF_VOLTAGE)，会将bat_data->BAT_CAPACITY设定为1，即不进行关机操作，会让实际电压值继续降一段时间。等到同时满足BMT_status.UI_SOC2 =0而且电压值BMT_status.bat_vol低于设定的关机电压时，进入else逻辑中，即让属性bat_data->BAT_CAPACITY = BMT_status.UI_SOC2;即bat_data->BAT_CAPACITY置为0，然后将bat_data->BAT_CAPACITY值写入节点/sys/class/power_supply/battery/capacity。然后BatteryMonitor.cpp会读取该节点，然后将读到的电量值props.batteryLevel传入上层。

导致本问题出现的原因是设置的关机电压值BMT_status.bat_vol过低，在达到低电量关机条件的时候BMT_status.UI_SOC2 <=0)&&(BMT_status.bat_vol >= SYSTEM_OFF_VOLTAGE依然为true，所以传到上层的bat_data->BAT_CAPACITY不为0，无播放关机动画。

最后需要修改battery_common.h文件中的宏定义#define SYSTEM_OFF_VOLTAGE，把它的值调整的高一点即可，具体修改到多少，可根据具体情况而定。

4. 总结

这个问题解决，首先需要了解电池电量值的读取、传递的逻辑，手机中的电量值会通过底层电池驱动把电池信息写入对应的节点中，然后通过BatteryMonitor.cpp来读取相关信息，然后通过binder机制将电池信息不间断的传到上层，然后上层通过获得的电池信息值来做出相关操作，如电量低时通过广播来发送警告，如果电池电量值非常低时，进行关机操作。同时在关机操作前，还会开机线程来对系统中的所有服务进行关闭操作。至于关机动画则是通过开启一个播放关机动画的服务来处理。通过关机log来定位问题，发现在电量值为0的时候底层通过binder传入到上层的电量值不是0，所以不会进入上层播放关机动画的逻辑中来，而底层检测到电量低，则直接黑屏关机处理了。

No shutdown animation in the electricity display only 1%的更多相关文章

  1. 百度前端技术学院2018笔记 之 利用 CSS animation 制作一个炫酷的 Slider

    前言 题目地址 利用 CSS animation 制作一个炫酷的 Slider 思路整理 首先页面包含三种东西 一个是type为radio的input其实就是单选框 二是每个单选框对应的label 三 ...

  2. Android 开机动画源码分析

    Android系统在启动SystemServer进程时,通过两个阶段来启动系统所有服务,在第一阶段启动本地服务,如SurfaceFlinger,SensorService等,在第二阶段则启动一系列的J ...

  3. Android 开机画面和wallpaper总结

    Android 开机画面和wallpaper总结  1 kernel的开机画面修改 1.图片需求:图片格式:png图片大小:1024x600(具体示lcd分辨率而定). 2.转换图片png图片. 假设 ...

  4. [原创]webapp/css3实战，制作一个《炉石传说》宣传页

    在移动网页,尤其是webapp中常需要用到大量的css3动画,来获得良好交互体验 我之前帮朋友做了一个,可惜没帮上忙现在和大家分享一下 目标是要做一个<炉石传说>游戏的介绍宣传页面,文字内 ...

  5. Java性能提示（全）

    http://www.onjava.com/pub/a/onjava/2001/05/30/optimization.htmlComparing the performance of LinkedLi ...

  6. 一. Linux 常用命令总结

    1. linux 基础命令 who, which, basename, dirname, echo, type, hash, whatis, makewhatis, man, info, help,  ...

  7. vue2.0 transition -- demo实践填坑

    前言 vue1.0版本和2.0版本的过渡系统改变还是蛮彻底的,具体请自行详看文档介绍:https://vuefe.cn/v2/guide/migration.html#过渡.在使用2.0版本做过渡效果 ...

  8. Android 系统默认参数的修改

    转自: http://www.th7.cn/Program/Android/201505/447097.shtml 写在前面的话 一般在新项目开始之初,我们需要针对客户需求进行各种系统默认属性的配置, ...

  9. 绝对炫的幻灯片插件-SKITTER

    绝对炫的幻灯片插件-SKITTER 所属分类:媒体-幻灯片和轮播图,图片展示,滑块和旋转 Includes code source // Styles <link href="css/ ...

随机推荐

  1. 丈量你的代码，从cloc开始

    如果我想统计我当前的项目有多少代码量?行数最高的代码文件有哪些?并且排除某些目录,怎么统计?要统计出注释多少行,和代码多少行?使用cloc就行. cloc是一款使用Perl语言开发的开源代码统计工具, ...

  2. mapbox获取各种经纬度

    点击地图即可获取经纬度,也可以手动输入经纬度来换算 在线查看运行效果 实现方法 mapbox中通过地图点击事件来获取到坐标,然后转换为其他的坐标系并输出在屏幕上即可 获取坐标 方法很简单,给地图添加一 ...

  3. 测试开发实战[提测平台]17-Flask&Vue文件上传实现

    微信搜索[大奇测试开],关注这个坚持分享测试开发干货的家伙. 先回顾下在此系列第8次分享给出的预期实现的产品原型和需求说明,如下图整体上和前两节实现很相似,只不过一般测试报告要写的内容可能比较多,就多 ...

  4. Spring Boot发布2.6.2、2.5.8：升级log4j2到2.17.0

    12月22日,Spring官方发布了Spring Boot 2.5.8(包括46个错误修复.文档改进和依赖项升级)和2.6.2(包括55个错误修复.文档改进和依赖项升级). 这两个版本均为缺陷修复版本 ...

  5. 分布式文件系统fastdfs安装以及python调用

    fastfds的安装和使用 一.所需依赖 操作系统:centos7.x(注意的是centos使用yum安装相关依赖) fastdfs:V6.06.tar.gz libfastcommon:V1.0.4 ...

  6. Python 属性方法、类方法、静态方法、 特殊属性__doc__ (内建属性)

    总结:和类的关联性讲:属性方法>类方法>静态方法 属性方法@property:仅仅是调用方式不用+括号. 类方法@classmethod:访问不了累的属性变量,只可以访问类变量. 静态方法 ...

  7. Linux C++获取磁盘剩余空间和可用空间

    完整源码 #include <sys/statfs.h> #include <string> #include <iostream> #include <li ...

  8. google protobuf学习笔记：windows下环境配置

    欢迎转载,转载请注明原文地址:http://blog.csdn.net/majianfei1023/article/details/45371743 protobuf的使用和原理,请查看:http:/ ...

  9. 【LeetCode】87. Scramble String 解题报告（Python & C++）

    作者: 负雪明烛 id: fuxuemingzhu 个人博客: http://fuxuemingzhu.cn/ 目录 题目描述 题目大意 解题方法 递归 动态规划 日期 题目地址:https://le ...

  10. 【LeetCode】526. Beautiful Arrangement 解题报告（Python & C++）

    作者: 负雪明烛 id: fuxuemingzhu 个人博客: http://fuxuemingzhu.cn/ 目录 题目描述 题目大意 解题方法 日期 题目地址:https://leetcode.c ...