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

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文件。在上层处理关机动画的的流程中，主要根据如下逻辑进行操作的。

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. }