No shutdown animation in the electricity display only 1%

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

低电量自动关机时无关机动画
1. 问题描述
2. 分析
3. solution
4. 总结

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，所以不会进入上层播放关机动画的逻辑中来，而底层检测到电量低，则直接黑屏关机处理了。

转载于:https://www.cnblogs.com/sayhellowen/p/625e81c3b1dde2d1425eb6c7d739efa7.html