android 4.4 电池电量管理底层分析(C\C++层)（http://blog.csdn.net/daweibalang717/article/details/41446993）

先贴一张类与类之间的关系图：


android开机过程中会加载系统BatteryService ,说一下电池电量相关的,本文主要讲述关于JAVA 层代码。文件路径：\frameworks\base\services\java\com\android\server\BatteryService.java 下面贴出源码。我把注释加上。个人理解，仅参考。

[java] view plain copy
  1. /*
  2. *Copyright(C)2006TheAndroidOpenSourceProject
  3. *
  4. *LicensedundertheApacheLicense,Version2.0(the"License");
  5. *youmaynotusethisfileexceptincompliancewiththeLicense.
  6. *YoumayobtainacopyoftheLicenseat
  7. *
  8. *http://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
  11. *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
  12. *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
  13. *SeetheLicenseforthespecificlanguagegoverningpermissionsand
  14. *limitationsundertheLicense.
  15. */
  17. packagecom.android.server;
  19. importandroid.os.BatteryStats;
  20. importcom.android.internal.app.IBatteryStats;
  21. importcom.android.server.am.BatteryStatsService;
  23. importandroid.app.ActivityManagerNative;
  24. importandroid.content.ContentResolver;
  25. importandroid.content.Context;
  26. importandroid.content.Intent;
  27. importandroid.content.pm.PackageManager;
  28. importandroid.os.BatteryManager;
  29. importandroid.os.BatteryProperties;
  30. importandroid.os.Binder;
  31. importandroid.os.FileUtils;
  32. importandroid.os.Handler;
  33. importandroid.os.IBatteryPropertiesListener;
  34. importandroid.os.IBatteryPropertiesRegistrar;
  35. importandroid.os.IBinder;
  36. importandroid.os.DropBoxManager;
  37. importandroid.os.RemoteException;
  38. importandroid.os.ServiceManager;
  39. importandroid.os.SystemClock;
  40. importandroid.os.UEventObserver;
  41. importandroid.os.UserHandle;
  42. importandroid.provider.Settings;
  43. importandroid.util.EventLog;
  44. importandroid.util.Slog;
  46. importjava.io.File;
  47. importjava.io.FileDescriptor;
  48. importjava.io.FileOutputStream;
  49. importjava.io.IOException;
  50. importjava.io.PrintWriter;
  53. /**
  54. *<p>BatteryServicemonitorsthechargingstatus,andchargelevelofthedevice
  55. *battery.Whenthesevalueschangethisservicebroadcaststhenewvalues
  56. *toall{@linkandroid.content.BroadcastReceiverIntentReceivers}thatare
  57. *watchingthe{@linkandroid.content.Intent#ACTION_BATTERY_CHANGED
  58. *BATTERY_CHANGED}action.</p>
  59. *<p>ThenewvaluesarestoredintheIntentdataandcanberetrievedby
  60. *calling{@linkandroid.content.Intent#getExtraIntent.getExtra}withthe
  61. *followingkeys:</p>
  62. *<p>"scale"-int,themaximumvalueforthechargelevel</p>
  63. *<p>"level"-int,chargelevel,from0through"scale"inclusive</p>
  64. *<p>"status"-String,thecurrentchargingstatus.<br/>
  65. *<p>"health"-String,thecurrentbatteryhealth.<br/>
  66. *<p>"present"-boolean,trueifthebatteryispresent<br/>
  67. *<p>"icon-small"-int,suggestedsmallicontouseforthisstate</p>
  68. *<p>"plugged"-int,0ifthedeviceisnotpluggedin;1ifplugged
  69. *intoanACpoweradapter;2ifpluggedinviaUSB.</p>
  70. *<p>"voltage"-int,currentbatteryvoltageinmillivolts</p>
  71. *<p>"temperature"-int,currentbatterytemperatureintenthsof
  72. *adegreeCentigrade</p>
  73. *<p>"technology"-String,thetypeofbatteryinstalled,e.g."Li-ion"</p>
  74. *
  75. *<p>
  76. *Thebatteryservicemaybecalledbythepowermanagerwhileholdingitslocksso
  77. *wetakecaretopostalloutcallsintotheactivitymanagertoahandler.
  78. *
  79. *FIXME:Ideallythepowermanagerwouldperformallofitscallsintothebattery
  80. *serviceasynchronouslyitself.
  81. *</p>
  82. */
  83. publicfinalclassBatteryServiceextendsBinder{
  84. privatestaticfinalStringTAG=BatteryService.class.getSimpleName();
  86. privatestaticfinalbooleanDEBUG=false;
  88. privatestaticfinalintBATTERY_SCALE=100;//batterycapacityisapercentage
  90. //Usedlocallyfordeterminingwhentomakealastditchefforttolog
  91. //dischargestatsbeforethedevicedies.
  92. privateintmCriticalBatteryLevel;
  94. privatestaticfinalintDUMP_MAX_LENGTH=24*1024;
  95. privatestaticfinalString[]DUMPSYS_ARGS=newString[]{"--checkin","--unplugged"};
  97. privatestaticfinalStringDUMPSYS_DATA_PATH="/data/system/";
  99. //ThisshouldprobablybeexposedintheAPI,thoughit'snotcritical
  100. privatestaticfinalintBATTERY_PLUGGED_NONE=0;
  102. privatefinalContextmContext;
  103. privatefinalIBatteryStatsmBatteryStats;
  104. privatefinalHandlermHandler;
  106. privatefinalObjectmLock=newObject();
  108. privateBatteryPropertiesmBatteryProps;
  109. privatebooleanmBatteryLevelCritical;
  110. privateintmLastBatteryStatus;
  111. privateintmLastBatteryHealth;
  112. privatebooleanmLastBatteryPresent;
  113. privateintmLastBatteryLevel;
  114. privateintmLastBatteryVoltage;
  115. privateintmLastBatteryTemperature;
  116. privatebooleanmLastBatteryLevelCritical;
  118. privateintmInvalidCharger;
  119. privateintmLastInvalidCharger;
  121. privateintmLowBatteryWarningLevel;
  122. privateintmLowBatteryCloseWarningLevel;
  123. privateintmShutdownBatteryTemperature;
  125. privateintmPlugType;
  126. privateintmLastPlugType=-1;//Extrastatesowecandetectfirstrun
  128. privatelongmDischargeStartTime;
  129. privateintmDischargeStartLevel;
  131. privatebooleanmUpdatesStopped;
  133. privateLedmLed;
  135. privatebooleanmSentLowBatteryBroadcast=false;
  137. privateBatteryListenermBatteryPropertiesListener;
  138. privateIBatteryPropertiesRegistrarmBatteryPropertiesRegistrar;
  139. //构造函数
  140. publicBatteryService(Contextcontext,LightsServicelights){
  141. mContext=context;
  142. mHandler=newHandler(true/*async*/);
  143. mLed=newLed(context,lights);//这个应该是指示灯，没实验
  144. mBatteryStats=BatteryStatsService.getService();
  146. //低电量临界值，这个数我看的源码版本值是4（在这个类里只是用来写日志）
  147. mCriticalBatteryLevel=mContext.getResources().getInteger(
  148. com.android.internal.R.integer.config_criticalBatteryWarningLevel);
  150. //低电量告警值，值15，下面会根据这个变量发送低电量的广播Intent.ACTION_BATTERY_LOW（这个跟系统低电量提醒没关系，只是发出去了）
  151. mLowBatteryWarningLevel=mContext.getResources().getInteger(
  152. com.android.internal.R.integer.config_lowBatteryWarningLevel);
  154. //电量告警取消值，值20，就是手机电量大于等于20的话发送Intent.ACTION_BATTERY_OKAY
  155. mLowBatteryCloseWarningLevel=mContext.getResources().getInteger(
  156. com.android.internal.R.integer.config_lowBatteryCloseWarningLevel);
  158. //值是680，温度过高，超过这个值就发送广播，跳转到将要关机提醒。
  159. mShutdownBatteryTemperature=mContext.getResources().getInteger(
  160. com.android.internal.R.integer.config_shutdownBatteryTemperature);
  162. //watchforinvalidchargermessagesiftheinvalid_chargerswitchexists
  163. if(newFile("/sys/devices/virtual/switch/invalid_charger/state").exists()){
  164. mInvalidChargerObserver.startObserving(
  165. "DEVPATH=/devices/virtual/switch/invalid_charger");
  166. }
  167. //电池监听，这个应该是注册到底层去了。当底层电量改变会调用此监听。然后执行update(BatteryPropertiesprops)；
  168. mBatteryPropertiesListener=newBatteryListener();
  170. IBinderb=ServiceManager.getService("batterypropreg");
  171. mBatteryPropertiesRegistrar=IBatteryPropertiesRegistrar.Stub.asInterface(b);
  173. try{
  174. //这里注册
  175. mBatteryPropertiesRegistrar.registerListener(mBatteryPropertiesListener);
  176. }catch(RemoteExceptione){
  177. //Shouldneverhappen.
  178. }
  179. }
  180. //开机后先去看看是否没电了或者温度太高了。如果是，就关机提示（关机提示我等会介绍）。
  181. voidsystemReady(){
  182. //checkourpowersituationnowthatitissafetodisplaytheshutdowndialog.
  183. synchronized(mLock){
  184. shutdownIfNoPowerLocked();
  185. shutdownIfOverTempLocked();
  186. }
  187. }
  188. //返回是否在充电，这个函数在PowerManagerService.java中调用
  189. /**
  190. *Returnstrueifthedeviceispluggedintoanyofthespecifiedplugtypes.
  191. */
  192. publicbooleanisPowered(intplugTypeSet){
  193. synchronized(mLock){
  194. returnisPoweredLocked(plugTypeSet);
  195. }
  196. }
  197. //就是这里，通过充电器类型判断是否充电
  198. privatebooleanisPoweredLocked(intplugTypeSet){
  199. //我这英语小白猜着翻译下：就是开机后，电池状态不明了，那我们就认为就在充电，以便设备正常工作。
  200. //assumewearepoweredifbatterystateisunknownso
  201. //the"stayonwhilepluggedin"optionwillwork.
  202. if(mBatteryProps.batteryStatus==BatteryManager.BATTERY_STATUS_UNKNOWN){
  203. returntrue;
  204. }
  205. //充电器
  206. if((plugTypeSet&BatteryManager.BATTERY_PLUGGED_AC)!=0&&mBatteryProps.chargerAcOnline){
  207. returntrue;
  208. }
  209. //USB，插电脑上充电
  210. if((plugTypeSet&BatteryManager.BATTERY_PLUGGED_USB)!=0&&mBatteryProps.chargerUsbOnline){
  211. returntrue;
  212. }
  213. //电源是无线的。（我没见过...）
  214. if((plugTypeSet&BatteryManager.BATTERY_PLUGGED_WIRELESS)!=0&&mBatteryProps.chargerWirelessOnline){
  215. returntrue;
  216. }
  217. returnfalse;
  218. }
  220. /**
  221. *Returnsthecurrentplugtype.
  222. */
  223. //充电器类型
  224. publicintgetPlugType(){
  225. synchronized(mLock){
  226. returnmPlugType;
  227. }
  228. }
  230. /**
  231. *Returnsbatterylevelasapercentage.
  232. */
  233. //电池属性：电量等级（0-100）
  234. publicintgetBatteryLevel(){
  235. synchronized(mLock){
  236. returnmBatteryProps.batteryLevel;
  237. }
  238. }
  240. /**
  241. *Returnstrueifbatterylevelisbelowthefirstwarningthreshold.
  242. */
  243. //低电量
  244. publicbooleanisBatteryLow(){
  245. synchronized(mLock){
  246. returnmBatteryProps.batteryPresent&&mBatteryProps.batteryLevel<=mLowBatteryWarningLevel;
  247. }
  248. }
  250. /**
  251. *Returnsanon-zerovalueifanunsupportedchargerisattached.
  252. */
  253. //不支持的充电器类型
  254. publicintgetInvalidCharger(){
  255. synchronized(mLock){
  256. returnmInvalidCharger;
  257. }
  258. }
  260. //这里就是没电了，要关机的提示。
  261. privatevoidshutdownIfNoPowerLocked(){
  262. //shutdowngracefullyifourbatteryiscriticallylowandwearenotpowered.
  263. //waituntilthesystemhasbootedbeforeattemptingtodisplaytheshutdowndialog.
  264. if(mBatteryProps.batteryLevel==0&&(mBatteryProps.batteryStatus==BatteryManager.BATTERY_STATUS_DISCHARGING)){
  265. mHandler.post(newRunnable(){
  266. @Override
  267. publicvoidrun(){
  268. if(ActivityManagerNative.isSystemReady()){
  269. Intentintent=newIntent("android.intent.action.ACTION_REQUEST_SHUTDOWN_LOWBATTERY");//ACTION_REQUEST_SHUTDOWN
  270. intent.putExtra(Intent.EXTRA_KEY_CONFIRM,false);
  271. intent.putExtra("cant_be_cancel_by_button",true);
  272. intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  273. mContext.startActivityAsUser(intent,UserHandle.CURRENT);
  274. }
  275. }
  276. });
  277. }
  278. }
  280. //温度过高，关机提示（个人感觉这里有问题，温度过高为啥子跳转到没电关机提示界面）
  281. privatevoidshutdownIfOverTempLocked(){
  282. //shutdowngracefullyiftemperatureistoohigh(>68.0Cbydefault)
  283. //waituntilthesystemhasbootedbeforeattemptingtodisplaythe
  284. //shutdowndialog.
  285. if(mBatteryProps.batteryTemperature>mShutdownBatteryTemperature){
  286. mHandler.post(newRunnable(){
  287. @Override
  288. publicvoidrun(){
  289. if(ActivityManagerNative.isSystemReady()){
  290. Intentintent=newIntent("android.intent.action.ACTION_REQUEST_SHUTDOWN_LOWBATTERY");//ACTION_REQUEST_SHUTDOWN
  291. intent.putExtra(Intent.EXTRA_KEY_CONFIRM,false);
  292. intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  293. mContext.startActivityAsUser(intent,UserHandle.CURRENT);
  294. }
  295. }
  296. });
  297. }
  298. }
  299. //这个方法就是被JNI回调的。用来更新上层状态的方法。
  300. privatevoidupdate(BatteryPropertiesprops){
  301. synchronized(mLock){
  302. if(!mUpdatesStopped){
  303. mBatteryProps=props;
  304. //Processthenewvalues.
  305. processValuesLocked();
  306. }
  307. }
  308. }
  309. //嗯。这个就是最主要的方法了。
  310. privatevoidprocessValuesLocked(){
  311. booleanlogOutlier=false;
  312. longdischargeDuration=0;
  314. mBatteryLevelCritical=(mBatteryProps.batteryLevel<=mCriticalBatteryLevel);
  315. //充电器类型
  316. if(mBatteryProps.chargerAcOnline){
  317. mPlugType=BatteryManager.BATTERY_PLUGGED_AC;
  318. }elseif(mBatteryProps.chargerUsbOnline){
  319. mPlugType=BatteryManager.BATTERY_PLUGGED_USB;
  320. }elseif(mBatteryProps.chargerWirelessOnline){
  321. mPlugType=BatteryManager.BATTERY_PLUGGED_WIRELESS;
  322. }else{
  323. mPlugType=BATTERY_PLUGGED_NONE;
  324. }
  326. if(DEBUG){//日志，略过
  327. Slog.d(TAG,"Processingnewvalues:"
  328. +"chargerAcOnline="+mBatteryProps.chargerAcOnline
  329. +",chargerUsbOnline="+mBatteryProps.chargerUsbOnline
  330. +",chargerWirelessOnline="+mBatteryProps.chargerWirelessOnline
  331. +",batteryStatus="+mBatteryProps.batteryStatus
  332. +",batteryHealth="+mBatteryProps.batteryHealth
  333. +",batteryPresent="+mBatteryProps.batteryPresent
  334. +",batteryLevel="+mBatteryProps.batteryLevel
  335. +",batteryTechnology="+mBatteryProps.batteryTechnology
  336. +",batteryVoltage="+mBatteryProps.batteryVoltage
  337. +",batteryCurrentNow="+mBatteryProps.batteryCurrentNow
  338. +",batteryChargeCounter="+mBatteryProps.batteryChargeCounter
  339. +",batteryTemperature="+mBatteryProps.batteryTemperature
  340. +",mBatteryLevelCritical="+mBatteryLevelCritical
  341. +",mPlugType="+mPlugType);
  342. }
  344. //Letthebatterystatskeeptrackofthecurrentlevel.
  345. try{
  346. //把电池属性放到状态里面
  347. mBatteryStats.setBatteryState(mBatteryProps.batteryStatus,mBatteryProps.batteryHealth,
  348. mPlugType,mBatteryProps.batteryLevel,mBatteryProps.batteryTemperature,
  349. mBatteryProps.batteryVoltage);
  350. }catch(RemoteExceptione){
  351. //Shouldneverhappen.
  352. }
  353. //没电了
  354. shutdownIfNoPowerLocked();
  355. //温度过高了
  356. shutdownIfOverTempLocked();
  358. if(mBatteryProps.batteryStatus!=mLastBatteryStatus||
  359. mBatteryProps.batteryHealth!=mLastBatteryHealth||
  360. mBatteryProps.batteryPresent!=mLastBatteryPresent||
  361. mBatteryProps.batteryLevel!=mLastBatteryLevel||
  362. mPlugType!=mLastPlugType||
  363. mBatteryProps.batteryVoltage!=mLastBatteryVoltage||
  364. mBatteryProps.batteryTemperature!=mLastBatteryTemperature||
  365. mInvalidCharger!=mLastInvalidCharger){
  367. if(mPlugType!=mLastPlugType){//当前充电器类型与上次的不一样
  368. //并且上次充电器类型是noone，那就可以知道，现在是插上充电器了。
  369. if(mLastPlugType==BATTERY_PLUGGED_NONE){
  370. //discharging->charging
  372. //There'snovalueinthisdataunlesswe'vedischargedatleastonceandthe
  373. //batterylevelhaschanged;sodon'tloguntilitdoes.
  374. if(mDischargeStartTime!=0&&mDischargeStartLevel!=mBatteryProps.batteryLevel){
  375. dischargeDuration=SystemClock.elapsedRealtime()-mDischargeStartTime;
  376. logOutlier=true;
  377. EventLog.writeEvent(EventLogTags.BATTERY_DISCHARGE,dischargeDuration,
  378. mDischargeStartLevel,mBatteryProps.batteryLevel);
  379. //makesureweseeadischargeeventbeforeloggingagain
  380. mDischargeStartTime=0;
  381. }
  382. //并且本次充电器类型是noone，那就可以知道，现在是拔掉充电器了。
  383. }elseif(mPlugType==BATTERY_PLUGGED_NONE){
  384. //charging->dischargingorwejustpoweredup
  385. mDischargeStartTime=SystemClock.elapsedRealtime();
  386. mDischargeStartLevel=mBatteryProps.batteryLevel;
  387. }
  388. }
  389. if(mBatteryProps.batteryStatus!=mLastBatteryStatus||//写日志，略过
  390. mBatteryProps.batteryHealth!=mLastBatteryHealth||
  391. mBatteryProps.batteryPresent!=mLastBatteryPresent||
  392. mPlugType!=mLastPlugType){
  393. EventLog.writeEvent(EventLogTags.BATTERY_STATUS,
  394. mBatteryProps.batteryStatus,mBatteryProps.batteryHealth,mBatteryProps.batteryPresent?1:0,
  395. mPlugType,mBatteryProps.batteryTechnology);
  396. }
  397. if(mBatteryProps.batteryLevel!=mLastBatteryLevel){
  398. //Don'tdothisjustfromvoltageortemperaturechanges,thatis
  399. //toonoisy.
  400. EventLog.writeEvent(EventLogTags.BATTERY_LEVEL,
  401. mBatteryProps.batteryLevel,mBatteryProps.batteryVoltage,mBatteryProps.batteryTemperature);
  402. }
  403. if(mBatteryLevelCritical&&!mLastBatteryLevelCritical&&
  404. mPlugType==BATTERY_PLUGGED_NONE){
  405. //Wewanttomakesurewelogdischargecycleoutliers
  406. //ifthebatteryisabouttodie.
  407. dischargeDuration=SystemClock.elapsedRealtime()-mDischargeStartTime;
  408. logOutlier=true;
  409. }
  410. //本次调用，当前的充电状态
  411. finalbooleanplugged=mPlugType!=BATTERY_PLUGGED_NONE;
  412. //本次调用，上次调用的充电状态
  413. finalbooleanoldPlugged=mLastPlugType!=BATTERY_PLUGGED_NONE;
  415. /*TheACTION_BATTERY_LOWbroadcastissentinthesesituations:
  416. *-isjustun-plugged(previouslywasplugged)andbatterylevelis
  417. *lessthanorequaltoWARNING,or
  418. *-isnotpluggedandbatterylevelfallstoWARNINGboundary
  419. *(becomes<=mLowBatteryWarningLevel).
  420. */
  421. //用于发送低电量广播的判断
  422. finalbooleansendBatteryLow=!plugged//（按sendBatteryLow=true来说）当前没有充电
  423. &&mBatteryProps.batteryStatus!=BatteryManager.BATTERY_STATUS_UNKNOWN//充电状态不是UNKNOWN
  424. &&mBatteryProps.batteryLevel<=mLowBatteryWarningLevel//当前电量小于告警值15
  425. &&(oldPlugged||mLastBatteryLevel>mLowBatteryWarningLevel);//上次状态是充电或者上次电量等级大于告警值15
  427. sendIntentLocked();//发送电池电量改变的广播Intent.ACTION_BATTERY_CHANGED
  429. //Separatebroadcastissentforpowerconnected/notconnected
  430. //sincethestandardintentwillnotwakeanyapplicationsandsome
  431. //applicationsmaywanttohavesmartbehaviorbasedonthis.
  432. if(mPlugType!=0&&mLastPlugType==0){//插上充电器了
  433. mHandler.post(newRunnable(){
  434. @Override
  435. publicvoidrun(){
  436. IntentstatusIntent=newIntent(Intent.ACTION_POWER_CONNECTED);
  437. statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
  438. mContext.sendBroadcastAsUser(statusIntent,UserHandle.ALL);
  439. }
  440. });
  441. }
  442. elseif(mPlugType==0&&mLastPlugType!=0){//断开充电器了
  443. mHandler.post(newRunnable(){
  444. @Override
  445. publicvoidrun(){
  446. IntentstatusIntent=newIntent(Intent.ACTION_POWER_DISCONNECTED);
  447. statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
  448. mContext.sendBroadcastAsUser(statusIntent,UserHandle.ALL);
  449. }
  450. });
  451. }
  452. //发送低电量提醒（这个跟系统低电量提醒没关系，只是发出去了）
  453. if(sendBatteryLow){
  454. mSentLowBatteryBroadcast=true;
  455. mHandler.post(newRunnable(){
  456. @Override
  457. publicvoidrun(){
  458. IntentstatusIntent=newIntent(Intent.ACTION_BATTERY_LOW);
  459. statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
  460. mContext.sendBroadcastAsUser(statusIntent,UserHandle.ALL);
  461. }
  462. });
  463. }elseif(mSentLowBatteryBroadcast&&mLastBatteryLevel>=mLowBatteryCloseWarningLevel){//电量超过20了。电池状态OK了
  464. mSentLowBatteryBroadcast=false;
  465. mHandler.post(newRunnable(){
  466. @Override
  467. publicvoidrun(){
  468. IntentstatusIntent=newIntent(Intent.ACTION_BATTERY_OKAY);
  469. statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
  470. mContext.sendBroadcastAsUser(statusIntent,UserHandle.ALL);
  471. }
  472. });
  473. }
  475. //UpdatethebatteryLED
  476. mLed.updateLightsLocked();
  478. //ThisneedstobedoneaftersendIntent()sothatwegetthelastestbatterystats.
  479. if(logOutlier&&dischargeDuration!=0){
  480. logOutlierLocked(dischargeDuration);
  481. }
  483. mLastBatteryStatus=mBatteryProps.batteryStatus;
  484. mLastBatteryHealth=mBatteryProps.batteryHealth;
  485. mLastBatteryPresent=mBatteryProps.batteryPresent;
  486. mLastBatteryLevel=mBatteryProps.batteryLevel;
  487. mLastPlugType=mPlugType;
  488. mLastBatteryVoltage=mBatteryProps.batteryVoltage;
  489. mLastBatteryTemperature=mBatteryProps.batteryTemperature;
  490. mLastBatteryLevelCritical=mBatteryLevelCritical;
  491. mLastInvalidCharger=mInvalidCharger;
  492. }
  493. }
  494. //电池电量改变，把属性发出去（系统低电量提醒接收的是这个广播）
  495. privatevoidsendIntentLocked(){
  496. //Packupthevaluesandbroadcastthemtoeveryone
  497. finalIntentintent=newIntent(Intent.ACTION_BATTERY_CHANGED);
  498. intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY
  499. |Intent.FLAG_RECEIVER_REPLACE_PENDING);
  501. inticon=getIconLocked(mBatteryProps.batteryLevel);
  503. intent.putExtra(BatteryManager.EXTRA_STATUS,mBatteryProps.batteryStatus);
  504. intent.putExtra(BatteryManager.EXTRA_HEALTH,mBatteryProps.batteryHealth);
  505. intent.putExtra(BatteryManager.EXTRA_PRESENT,mBatteryProps.batteryPresent);
  506. intent.putExtra(BatteryManager.EXTRA_LEVEL,mBatteryProps.batteryLevel);
  507. intent.putExtra(BatteryManager.EXTRA_SCALE,BATTERY_SCALE);
  508. intent.putExtra(BatteryManager.EXTRA_ICON_SMALL,icon);
  509. intent.putExtra(BatteryManager.EXTRA_PLUGGED,mPlugType);
  510. intent.putExtra(BatteryManager.EXTRA_VOLTAGE,mBatteryProps.batteryVoltage);
  511. intent.putExtra(BatteryManager.EXTRA_TEMPERATURE,mBatteryProps.batteryTemperature);
  512. intent.putExtra(BatteryManager.EXTRA_TECHNOLOGY,mBatteryProps.batteryTechnology);
  513. intent.putExtra(BatteryManager.EXTRA_INVALID_CHARGER,mInvalidCharger);
  515. if(DEBUG){
  516. Slog.d(TAG,"SendingACTION_BATTERY_CHANGED.level:"+mBatteryProps.batteryLevel+
  517. ",scale:"+BATTERY_SCALE+",status:"+mBatteryProps.batteryStatus+
  518. ",health:"+mBatteryProps.batteryHealth+",present:"+mBatteryProps.batteryPresent+
  519. ",voltage:"+mBatteryProps.batteryVoltage+
  520. ",temperature:"+mBatteryProps.batteryTemperature+
  521. ",technology:"+mBatteryProps.batteryTechnology+
  522. ",ACpowered:"+mBatteryProps.chargerAcOnline+",USBpowered:"+mBatteryProps.chargerUsbOnline+
  523. ",Wirelesspowered:"+mBatteryProps.chargerWirelessOnline+
  524. ",icon:"+icon+",invalidcharger:"+mInvalidCharger);
  525. }
  527. mHandler.post(newRunnable(){
  528. @Override
  529. publicvoidrun(){
  530. ActivityManagerNative.broadcastStickyIntent(intent,null,UserHandle.USER_ALL);
  531. }
  532. });
  533. }
  535. privatevoidlogBatteryStatsLocked(){
  536. IBinderbatteryInfoService=ServiceManager.getService(BatteryStats.SERVICE_NAME);
  537. if(batteryInfoService==null)return;
  539. DropBoxManagerdb=(DropBoxManager)mContext.getSystemService(Context.DROPBOX_SERVICE);
  540. if(db==null||!db.isTagEnabled("BATTERY_DISCHARGE_INFO"))return;
  542. FiledumpFile=null;
  543. FileOutputStreamdumpStream=null;
  544. try{
  545. //dumptheservicetoafile
  546. dumpFile=newFile(DUMPSYS_DATA_PATH+BatteryStats.SERVICE_NAME+".dump");
  547. dumpStream=newFileOutputStream(dumpFile);
  548. batteryInfoService.dump(dumpStream.getFD(),DUMPSYS_ARGS);
  549. FileUtils.sync(dumpStream);
  551. //adddumpfiletodropbox
  552. db.addFile("BATTERY_DISCHARGE_INFO",dumpFile,DropBoxManager.IS_TEXT);
  553. }catch(RemoteExceptione){
  554. Slog.e(TAG,"failedtodumpbatteryservice",e);
  555. }catch(IOExceptione){
  556. Slog.e(TAG,"failedtowritedumpsysfile",e);
  557. }finally{
  558. //makesurewecleanup
  559. if(dumpStream!=null){
  560. try{
  561. dumpStream.close();
  562. }catch(IOExceptione){
  563. Slog.e(TAG,"failedtoclosedumpsysoutputstream");
  564. }
  565. }
  566. if(dumpFile!=null&&!dumpFile.delete()){
  567. Slog.e(TAG,"failedtodeletetemporarydumpsysfile:"
  568. +dumpFile.getAbsolutePath());
  569. }
  570. }
  571. }
  573. privatevoidlogOutlierLocked(longduration){
  574. ContentResolvercr=mContext.getContentResolver();
  575. StringdischargeThresholdString=Settings.Global.getString(cr,
  576. Settings.Global.BATTERY_DISCHARGE_THRESHOLD);
  577. StringdurationThresholdString=Settings.Global.getString(cr,
  578. Settings.Global.BATTERY_DISCHARGE_DURATION_THRESHOLD);
  580. if(dischargeThresholdString!=null&&durationThresholdString!=null){
  581. try{
  582. longdurationThreshold=Long.parseLong(durationThresholdString);
  583. intdischargeThreshold=Integer.parseInt(dischargeThresholdString);
  584. if(duration<=durationThreshold&&
  585. mDischargeStartLevel-mBatteryProps.batteryLevel>=dischargeThreshold){
  586. //Ifthedischargecycleisbadenoughwewanttoknowaboutit.
  587. logBatteryStatsLocked();
  588. }
  589. if(DEBUG)Slog.v(TAG,"durationthreshold:"+durationThreshold+
  590. "dischargethreshold:"+dischargeThreshold);
  591. if(DEBUG)Slog.v(TAG,"duration:"+duration+"discharge:"+
  592. (mDischargeStartLevel-mBatteryProps.batteryLevel));
  593. }catch(NumberFormatExceptione){
  594. Slog.e(TAG,"InvalidDischargeThresholdsGServicestring:"+
  595. durationThresholdString+"or"+dischargeThresholdString);
  596. return;
  597. }
  598. }
  599. }
  601. privateintgetIconLocked(intlevel){
  602. if(mBatteryProps.batteryStatus==BatteryManager.BATTERY_STATUS_CHARGING){
  603. returncom.android.internal.R.drawable.stat_sys_battery_charge;
  604. }elseif(mBatteryProps.batteryStatus==BatteryManager.BATTERY_STATUS_DISCHARGING){
  605. returncom.android.internal.R.drawable.stat_sys_battery;
  606. }elseif(mBatteryProps.batteryStatus==BatteryManager.BATTERY_STATUS_NOT_CHARGING
  607. ||mBatteryProps.batteryStatus==BatteryManager.BATTERY_STATUS_FULL){
  608. if(isPoweredLocked(BatteryManager.BATTERY_PLUGGED_ANY)
  609. &&mBatteryProps.batteryLevel>=100){
  610. returncom.android.internal.R.drawable.stat_sys_battery_charge;
  611. }else{
  612. returncom.android.internal.R.drawable.stat_sys_battery;
  613. }
  614. }else{
  615. returncom.android.internal.R.drawable.stat_sys_battery_unknown;
  616. }
  617. }
  619. @Override
  620. protectedvoiddump(FileDescriptorfd,PrintWriterpw,String[]args){
  621. if(mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
  622. !=PackageManager.PERMISSION_GRANTED){
  624. pw.println("PermissionDenial:can'tdumpBatteryservicefromfrompid="
  625. +Binder.getCallingPid()
  626. +",uid="+Binder.getCallingUid());
  627. return;
  628. }
  630. synchronized(mLock){
  631. if(args==null||args.length==0||"-a".equals(args[0])){
  632. pw.println("CurrentBatteryServicestate:");
  633. if(mUpdatesStopped){
  634. pw.println("(UPDATESSTOPPED--use'reset'torestart)");
  635. }
  636. pw.println("ACpowered:"+mBatteryProps.chargerAcOnline);
  637. pw.println("USBpowered:"+mBatteryProps.chargerUsbOnline);
  638. pw.println("Wirelesspowered:"+mBatteryProps.chargerWirelessOnline);
  639. pw.println("status:"+mBatteryProps.batteryStatus);
  640. pw.println("health:"+mBatteryProps.batteryHealth);
  641. pw.println("present:"+mBatteryProps.batteryPresent);
  642. pw.println("level:"+mBatteryProps.batteryLevel);
  643. pw.println("scale:"+BATTERY_SCALE);
  644. pw.println("voltage:"+mBatteryProps.batteryVoltage);
  646. if(mBatteryProps.batteryCurrentNow!=Integer.MIN_VALUE){
  647. pw.println("currentnow:"+mBatteryProps.batteryCurrentNow);
  648. }
  650. if(mBatteryProps.batteryChargeCounter!=Integer.MIN_VALUE){
  651. pw.println("chargecounter:"+mBatteryProps.batteryChargeCounter);
  652. }
  654. pw.println("temperature:"+mBatteryProps.batteryTemperature);
  655. pw.println("technology:"+mBatteryProps.batteryTechnology);
  656. }elseif(args.length==3&&"set".equals(args[0])){
  657. Stringkey=args[1];
  658. Stringvalue=args[2];
  659. try{
  660. booleanupdate=true;
  661. if("ac".equals(key)){
  662. mBatteryProps.chargerAcOnline=Integer.parseInt(value)!=0;
  663. }elseif("usb".equals(key)){
  664. mBatteryProps.chargerUsbOnline=Integer.parseInt(value)!=0;
  665. }elseif("wireless".equals(key)){
  666. mBatteryProps.chargerWirelessOnline=Integer.parseInt(value)!=0;
  667. }elseif("status".equals(key)){
  668. mBatteryProps.batteryStatus=Integer.parseInt(value);
  669. }elseif("level".equals(key)){
  670. mBatteryProps.batteryLevel=Integer.parseInt(value);
  671. }elseif("invalid".equals(key)){
  672. mInvalidCharger=Integer.parseInt(value);
  673. }else{
  674. pw.println("Unknownsetoption:"+key);
  675. update=false;
  676. }
  677. if(update){
  678. longident=Binder.clearCallingIdentity();
  679. try{
  680. mUpdatesStopped=true;
  681. processValuesLocked();
  682. }finally{
  683. Binder.restoreCallingIdentity(ident);
  684. }
  685. }
  686. }catch(NumberFormatExceptionex){
  687. pw.println("Badvalue:"+value);
  688. }
  689. }elseif(args.length==1&&"reset".equals(args[0])){
  690. longident=Binder.clearCallingIdentity();
  691. try{
  692. mUpdatesStopped=false;
  693. }finally{
  694. Binder.restoreCallingIdentity(ident);
  695. }
  696. }else{
  697. pw.println("Dumpcurrentbatterystate,or:");
  698. pw.println("setac|usb|wireless|status|level|invalid<value>");
  699. pw.println("reset");
  700. }
  701. }
  702. }
  704. privatefinalUEventObservermInvalidChargerObserver=newUEventObserver(){
  705. @Override
  706. publicvoidonUEvent(UEventObserver.UEventevent){
  707. finalintinvalidCharger="1".equals(event.get("SWITCH_STATE"))?1:0;
  708. synchronized(mLock){
  709. if(mInvalidCharger!=invalidCharger){
  710. mInvalidCharger=invalidCharger;
  711. }
  712. }
  713. }
  714. };
  716. privatefinalclassLed{
  717. privatefinalLightsService.LightmBatteryLight;
  719. privatefinalintmBatteryLowARGB;
  720. privatefinalintmBatteryMediumARGB;
  721. privatefinalintmBatteryFullARGB;
  722. privatefinalintmBatteryLedOn;
  723. privatefinalintmBatteryLedOff;
  725. publicLed(Contextcontext,LightsServicelights){
  726. mBatteryLight=lights.getLight(LightsService.LIGHT_ID_BATTERY);
  728. mBatteryLowARGB=context.getResources().getInteger(
  729. com.android.internal.R.integer.config_notificationsBatteryLowARGB);
  730. mBatteryMediumARGB=context.getResources().getInteger(
  731. com.android.internal.R.integer.config_notificationsBatteryMediumARGB);
  732. mBatteryFullARGB=context.getResources().getInteger(
  733. com.android.internal.R.integer.config_notificationsBatteryFullARGB);
  734. mBatteryLedOn=context.getResources().getInteger(
  735. com.android.internal.R.integer.config_notificationsBatteryLedOn);
  736. mBatteryLedOff=context.getResources().getInteger(
  737. com.android.internal.R.integer.config_notificationsBatteryLedOff);
  738. }
  740. /**
  741. *SynchronizeonBatteryService.
  742. */
  743. publicvoidupdateLightsLocked(){
  744. finalintlevel=mBatteryProps.batteryLevel;
  745. finalintstatus=mBatteryProps.batteryStatus;
  746. if(level<mLowBatteryWarningLevel){
  747. if(status==BatteryManager.BATTERY_STATUS_CHARGING){
  748. //Solidredwhenbatteryischarging
  749. mBatteryLight.setColor(mBatteryLowARGB);
  750. }else{
  751. //Flashredwhenbatteryislowandnotcharging
  752. mBatteryLight.setFlashing(mBatteryLowARGB,LightsService.LIGHT_FLASH_TIMED,
  753. mBatteryLedOn,mBatteryLedOff);
  754. }
  755. }elseif(status==BatteryManager.BATTERY_STATUS_CHARGING
  756. ||status==BatteryManager.BATTERY_STATUS_FULL){
  757. if(status==BatteryManager.BATTERY_STATUS_FULL||level>=90){
  758. //Solidgreenwhenfullorchargingandnearlyfull
  759. mBatteryLight.setColor(mBatteryFullARGB);
  760. }else{
  761. //Solidorangewhenchargingandhalfwayfull
  762. mBatteryLight.setColor(mBatteryMediumARGB);
  763. }
  764. }else{
  765. //Nolightsifnotchargingandnotlow
  766. mBatteryLight.turnOff();
  767. }
  768. }
  769. }
  771. privatefinalclassBatteryListenerextendsIBatteryPropertiesListener.Stub{
  772. publicvoidbatteryPropertiesChanged(BatteryPropertiesprops){
  773. BatteryService.this.update(props);
  774. }
  775. }
  776. }



  总结如下：  此服务构造时会注册监听到系统JNI层。 当电池电量改变的时候会调用update(BatteryProperties props) -----》processValuesLocked() 。 而processValuesLocked() 函数会把电池状态把广播发送出去。其他类再接收广播进行处理    
 
  
 
  
 下一个类就是低电量提醒了，文件目录：\frameworks\base\packages\SystemUI\src\com\android\systemui\power\PowerUI.java
  
 
              [java] view plain     copy                         
        
  1.  /*
    2.     
  2.  *Copyright(C)2008TheAndroidOpenSourceProject
    3.     
  3.  *
    4.     
  4.  *LicensedundertheApacheLicense,Version2.0(the"License");
    5.     
  5.  *youmaynotusethisfileexceptincompliancewiththeLicense.
    6.     
  6.  *YoumayobtainacopyoftheLicenseat
    7.     
  7.  *
    8.     
  8.  *http://www.apache.org/licenses/LICENSE-2.0
    9.     
  9.  *
    10.     
  10.  *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
    11.     
  11.  *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
    12.     
  12.  *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
    13.     
  13.  *SeetheLicenseforthespecificlanguagegoverningpermissionsand
    14.     
  14.  *limitationsundertheLicense.
    15.     
  15.  */
    16.     
  16.  
    17.     
  17.  packagecom.android.systemui.power;
    18.     
  18.  
    19.     
  19.  importandroid.app.AlertDialog;
    20.     
  20.  importandroid.content.BroadcastReceiver;
    21.     
  21.  importandroid.content.ContentResolver;
    22.     
  22.  importandroid.content.Context;
    23.     
  23.  importandroid.content.DialogInterface;
    24.     
  24.  importandroid.content.Intent;
    25.     
  25.  importandroid.content.IntentFilter;
    26.     
  26.  importandroid.media.AudioManager;
    27.     
  27.  importandroid.media.Ringtone;
    28.     
  28.  importandroid.media.RingtoneManager;
    29.     
  29.  importandroid.net.Uri;
    30.     
  30.  importandroid.os.BatteryManager;
    31.     
  31.  importandroid.os.Handler;
    32.     
  32.  importandroid.os.PowerManager;
    33.     
  33.  importandroid.os.SystemClock;
    34.     
  34.  importandroid.os.UserHandle;
    35.     
  35.  importandroid.provider.Settings;
    36.     
  36.  importandroid.util.Slog;
    37.     
  37.  importandroid.view.View;
    38.     
  38.  importandroid.view.WindowManager;
    39.     
  39.  importandroid.widget.TextView;
    40.     
  40.  
    41.     
  41.  importcom.android.systemui.R;
    42.     
  42.  importcom.android.systemui.SystemUI;
    43.     
  43.  
    44.     
  44.  importjava.io.FileDescriptor;
    45.     
  45.  importjava.io.PrintWriter;
    46.     
  46.  importjava.util.Arrays;
    47.     
  47.  
    48.     
  48.  publicclassPowerUIextendsSystemUI{//总体说一下，这里才是处理低电量提醒的地方，他接收的广播是Intent.ACTION_BATTERY_CHANGED
    49.     
  49.  staticfinalStringTAG="PowerUI";
    50.     
  50.  
    51.     
  51.  staticfinalbooleanDEBUG=false;
    52.     
  52.  
    53.     
  53.  HandlermHandler=newHandler();
    54.     
  54.  
    55.     
  55.  intmBatteryLevel=100;
    56.     
  56.  intmBatteryStatus=BatteryManager.BATTERY_STATUS_UNKNOWN;
    57.     
  57.  intmPlugType=0;
    58.     
  58.  intmInvalidCharger=0;
    59.     
  59.  
    60.     
  60.  intmLowBatteryAlertCloseLevel;
    61.     
  61.  int[]mLowBatteryReminderLevels=newint[2];
    62.     
  62.  
    63.     
  63.  AlertDialogmInvalidChargerDialog;
    64.     
  64.  AlertDialogmLowBatteryDialog;
    65.     
  65.  TextViewmBatteryLevelTextView;
    66.     
  66.  
    67.     
  67.  privatelongmScreenOffTime=-1;
    68.     
  68.  
    69.     
  69.  publicvoidstart(){//这个类会在手机启动后，在SystemUI里启动(就是系统界面)。
    70.     
  70.  
    71.     
  71.  mLowBatteryAlertCloseLevel=mContext.getResources().getInteger(//电量告警取消值，值20
    72.     
  72.  com.android.internal.R.integer.config_lowBatteryCloseWarningLevel);
    73.     
  73.  mLowBatteryReminderLevels[0]=mContext.getResources().getInteger(//低电量提醒15
    74.     
  74.  com.android.internal.R.integer.config_lowBatteryWarningLevel);
    75.     
  75.  mLowBatteryReminderLevels[1]=mContext.getResources().getInteger(//低电量临界值4
    76.     
  76.  com.android.internal.R.integer.config_criticalBatteryWarningLevel);
    77.     
  77.  
    78.     
  78.  finalPowerManagerpm=(PowerManager)mContext.getSystemService(Context.POWER_SERVICE);
    79.     
  79.  mScreenOffTime=pm.isScreenOn()?-1:SystemClock.elapsedRealtime();
    80.     
  80.  
    81.     
  81.  //RegisterforIntentbroadcastsfor...
    82.     
  82.  IntentFilterfilter=newIntentFilter();
    83.     
  83.  filter.addAction(Intent.ACTION_BATTERY_CHANGED);
    84.     
  84.  filter.addAction(Intent.ACTION_SCREEN_OFF);
    85.     
  85.  filter.addAction(Intent.ACTION_SCREEN_ON);
    86.     
  86.  mContext.registerReceiver(mIntentReceiver,filter,null,mHandler);
    87.     
  87.  }
    88.     
  88.  
    89.     
  89.  /**
    90.     
  90.  *Bucketsthebatterylevel.
    91.     
  91.  *
    92.     
  92.  *ThecodeinthisfunctionisalittleweirdbecauseIcouldn'tcomprehend
    93.     
  93.  *thebucketgoingupwhenthebatterylevelwasgoingdown.--joeo
    94.     
  94.  *
    95.     
  95.  *1meansthatthebatteryis"ok"
    96.     
  96.  *0meansthatthebatteryisbetween"ok"andwhatweshouldwarnabout.
    97.     
  97.  *lessthan0meansthatthebatteryislow
    98.     
  98.  */
    99.     
  99.  privateintfindBatteryLevelBucket(intlevel){//这个方法是用来警告判断用的。
    100.     
  100.  if(level>=mLowBatteryAlertCloseLevel){
    101.     
  101.  return1;
    102.     
  102.  }
    103.     
  103.  if(level>=mLowBatteryReminderLevels[0]){
    104.     
  104.  return0;
    105.     
  105.  }
    106.     
  106.  finalintN=mLowBatteryReminderLevels.length;
    107.     
  107.  for(inti=N-1;i>=0;i--){
    108.     
  108.  if(level<=mLowBatteryReminderLevels[i]){
    109.     
  109.  return-1-i;
    110.     
  110.  }
    111.     
  111.  }
    112.     
  112.  thrownewRuntimeException("notpossible!");
    113.     
  113.  }
    114.     
  114.  
    115.     
  115.  privateBroadcastReceivermIntentReceiver=newBroadcastReceiver(){//重点，广播接收处理
    116.     
  116.  @Override
    117.     
  117.  publicvoidonReceive(Contextcontext,Intentintent){
    118.     
  118.  Stringaction=intent.getAction();
    119.     
  119.  if(action.equals(Intent.ACTION_BATTERY_CHANGED)){//电池电量改变
    120.     
  120.  finalintoldBatteryLevel=mBatteryLevel;//下边就是根据Intent获取BatteryService传过来的电池属性
    121.     
  121.  mBatteryLevel=intent.getIntExtra(BatteryManager.EXTRA_LEVEL,100);/
    122.     
  122.  finalintoldBatteryStatus=mBatteryStatus;
    123.     
  123.  mBatteryStatus=intent.getIntExtra(BatteryManager.EXTRA_STATUS,
    124.     
  124.  BatteryManager.BATTERY_STATUS_UNKNOWN);
    125.     
  125.  finalintoldPlugType=mPlugType;
    126.     
  126.  mPlugType=intent.getIntExtra(BatteryManager.EXTRA_PLUGGED,1);
    127.     
  127.  finalintoldInvalidCharger=mInvalidCharger;
    128.     
  128.  mInvalidCharger=intent.getIntExtra(BatteryManager.EXTRA_INVALID_CHARGER,0);
    129.     
  129.  
    130.     
  130.  finalbooleanplugged=mPlugType!=0;
    131.     
  131.  finalbooleanoldPlugged=oldPlugType!=0;
    132.     
  132.  
    133.     
  133.  intoldBucket=findBatteryLevelBucket(oldBatteryLevel);//这两个值特别有意思，就是说记录下老的电量，记录一下新的电量，比较电量是增加了，还是减小了
    134.     
  134.  intbucket=findBatteryLevelBucket(mBatteryLevel);
    135.     
  135.  
    136.     
  136.  if(DEBUG){
    137.     
  137.  Slog.d(TAG,"buckets....."+mLowBatteryAlertCloseLevel
    138.     
  138.  +".."+mLowBatteryReminderLevels[0]
    139.     
  139.  +".."+mLowBatteryReminderLevels[1]);
    140.     
  140.  Slog.d(TAG,"level"+oldBatteryLevel+"-->"+mBatteryLevel);
    141.     
  141.  Slog.d(TAG,"status"+oldBatteryStatus+"-->"+mBatteryStatus);
    142.     
  142.  Slog.d(TAG,"plugType"+oldPlugType+"-->"+mPlugType);
    143.     
  143.  Slog.d(TAG,"invalidCharger"+oldInvalidCharger+"-->"+mInvalidCharger);
    144.     
  144.  Slog.d(TAG,"bucket"+oldBucket+"-->"+bucket);
    145.     
  145.  Slog.d(TAG,"plugged"+oldPlugged+"-->"+plugged);
    146.     
  146.  }
    147.     
  147.  
    148.     
  148.  if(oldInvalidCharger==0&&mInvalidCharger!=0){
    149.     
  149.  Slog.d(TAG,"showinginvalidchargerwarning");
    150.     
  150.  showInvalidChargerDialog();//就是充电器不识别的弹窗
    151.     
  151.  return;
    152.     
  152.  }elseif(oldInvalidCharger!=0&&mInvalidCharger==0){
    153.     
  153.  dismissInvalidChargerDialog();
    154.     
  154.  }elseif(mInvalidChargerDialog!=null){
    155.     
  155.  //ifinvalidchargerisshowing,don'tshowlowbattery
    156.     
  156.  return;
    157.     
  157.  }
    158.     
  158.  
    159.     
  159.  if(!plugged
    160.     
  160.  &&(bucket<oldBucket||oldPlugged)
    161.     
  161.  &&mBatteryStatus!=BatteryManager.BATTERY_STATUS_UNKNOWN
    162.     
  162.  &&bucket<0){
    163.     
  163.  showLowBatteryWarning();<spanstyle="color:#FF0000;">//这里哈，低电量提醒的弹窗</span>
    164.     
  164.  
    165.     
  165.  //onlyplaySFXwhenthedialogcomesuporthebucketchanges
    166.     
  166.  if(bucket!=oldBucket||oldPlugged){
    167.     
  167.  playLowBatterySound();
    168.     
  168.  }
    169.     
  169.  }elseif(plugged||(bucket>oldBucket&&bucket>0)){//插上充电器或者充电电池电量超过20取消弹窗
    170.     
  170.  dismissLowBatteryWarning();
    171.     
  171.  }elseif(mBatteryLevelTextView!=null){
    172.     
  172.  showLowBatteryWarning();
    173.     
  173.  }
    174.     
  174.  }elseif(Intent.ACTION_SCREEN_OFF.equals(action)){
    175.     
  175.  mScreenOffTime=SystemClock.elapsedRealtime();
    176.     
  176.  }elseif(Intent.ACTION_SCREEN_ON.equals(action)){
    177.     
  177.  mScreenOffTime=-1;
    178.     
  178.  }else{
    179.     
  179.  Slog.w(TAG,"unknownintent:"+intent);
    180.     
  180.  }
    181.     
  181.  }
    182.     
  182.  };
    183.     
  183.  
    184.     
  184.  voiddismissLowBatteryWarning(){
    185.     
  185.  if(mLowBatteryDialog!=null){
    186.     
  186.  Slog.i(TAG,"closinglowbatterywarning:level="+mBatteryLevel);
    187.     
  187.  mLowBatteryDialog.dismiss();
    188.     
  188.  }
    189.     
  189.  }
    190.     
  190.  
    191.     
  191.  voidshowLowBatteryWarning(){
    192.     
  192.  Slog.i(TAG,
    193.     
  193.  ((mBatteryLevelTextView==null)?"showing":"updating")
    194.     
  194.  +"lowbatterywarning:level="+mBatteryLevel
    195.     
  195.  +"["+findBatteryLevelBucket(mBatteryLevel)+"]");
    196.     
  196.  
    197.     
  197.  CharSequencelevelText=mContext.getString(
    198.     
  198.  R.string.battery_low_percent_format,mBatteryLevel);
    199.     
  199.  
    200.     
  200.  if(mBatteryLevelTextView!=null){
    201.     
  201.  mBatteryLevelTextView.setText(levelText);
    202.     
  202.  }else{
    203.     
  203.  Viewv=View.inflate(mContext,R.layout.battery_low,null);
    204.     
  204.  mBatteryLevelTextView=(TextView)v.findViewById(R.id.level_percent);
    205.     
  205.  
    206.     
  206.  mBatteryLevelTextView.setText(levelText);
    207.     
  207.  
    208.     
  208.  AlertDialog.Builderb=newAlertDialog.Builder(mContext);
    209.     
  209.  b.setCancelable(true);
    210.     
  210.  b.setTitle(R.string.battery_low_title);
    211.     
  211.  b.setView(v);
    212.     
  212.  b.setIconAttribute(android.R.attr.alertDialogIcon);
    213.     
  213.  b.setPositiveButton(android.R.string.ok,null);
    214.     
  214.  
    215.     
  215.  finalIntentintent=newIntent(Intent.ACTION_POWER_USAGE_SUMMARY);
    216.     
  216.  intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
    217.     
  217.  |Intent.FLAG_ACTIVITY_MULTIPLE_TASK
    218.     
  218.  |Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS
    219.     
  219.  |Intent.FLAG_ACTIVITY_NO_HISTORY);
    220.     
  220.  if(intent.resolveActivity(mContext.getPackageManager())!=null){
    221.     
  221.  b.setNegativeButton(R.string.battery_low_why,
    222.     
  222.  newDialogInterface.OnClickListener(){
    223.     
  223.  @Override
    224.     
  224.  publicvoidonClick(DialogInterfacedialog,intwhich){
    225.     
  225.  mContext.startActivityAsUser(intent,UserHandle.CURRENT);
    226.     
  226.  dismissLowBatteryWarning();
    227.     
  227.  }
    228.     
  228.  });
    229.     
  229.  }
    230.     
  230.  
    231.     
  231.  AlertDialogd=b.create();
    232.     
  232.  d.setOnDismissListener(newDialogInterface.OnDismissListener(){
    233.     
  233.  @Override
    234.     
  234.  publicvoidonDismiss(DialogInterfacedialog){
    235.     
  235.  mLowBatteryDialog=null;
    236.     
  236.  mBatteryLevelTextView=null;
    237.     
  237.  }
    238.     
  238.  });
    239.     
  239.  d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
    240.     
  240.  d.getWindow().getAttributes().privateFlags|=
    241.     
  241.  WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS;
    242.     
  242.  d.show();
    243.     
  243.  mLowBatteryDialog=d;
    244.     
  244.  }
    245.     
  245.  }
    246.     
  246.  
    247.     
  247.  voidplayLowBatterySound(){
    248.     
  248.  finalContentResolvercr=mContext.getContentResolver();
    249.     
  249.  
    250.     
  250.  finalintsilenceAfter=Settings.Global.getInt(cr,
    251.     
  251.  Settings.Global.LOW_BATTERY_SOUND_TIMEOUT,0);
    252.     
  252.  finallongoffTime=SystemClock.elapsedRealtime()-mScreenOffTime;
    253.     
  253.  if(silenceAfter>0
    254.     
  254.  &&mScreenOffTime>0
    255.     
  255.  &&offTime>silenceAfter){
    256.     
  256.  Slog.i(TAG,"screenofftoolong("+offTime+"ms,limit"+silenceAfter
    257.     
  257.  +"ms):notwakinguptheuserwithlowbatterysound");
    258.     
  258.  return;
    259.     
  259.  }
    260.     
  260.  
    261.     
  261.  if(DEBUG){
    262.     
  262.  Slog.d(TAG,"playinglowbatterysound.pick-a-doop!");//WOMP-WOMPisdeprecated
    263.     
  263.  }
    264.     
  264.  
    265.     
  265.  if(Settings.Global.getInt(cr,Settings.Global.POWER_SOUNDS_ENABLED,1)==1){
    266.     
  266.  finalStringsoundPath=Settings.Global.getString(cr,
    267.     
  267.  Settings.Global.LOW_BATTERY_SOUND);
    268.     
  268.  if(soundPath!=null){
    269.     
  269.  finalUrisoundUri=Uri.parse("file://"+soundPath);
    270.     
  270.  if(soundUri!=null){
    271.     
  271.  finalRingtonesfx=RingtoneManager.getRingtone(mContext,soundUri);
    272.     
  272.  if(sfx!=null){
    273.     
  273.  sfx.setStreamType(AudioManager.STREAM_SYSTEM);
    274.     
  274.  sfx.play();
    275.     
  275.  }
    276.     
  276.  }
    277.     
  277.  }
    278.     
  278.  }
    279.     
  279.  }
    280.     
  280.  
    281.     
  281.  voiddismissInvalidChargerDialog(){
    282.     
  282.  if(mInvalidChargerDialog!=null){
    283.     
  283.  mInvalidChargerDialog.dismiss();
    284.     
  284.  }
    285.     
  285.  }
    286.     
  286.  
    287.     
  287.  voidshowInvalidChargerDialog(){
    288.     
  288.  Slog.d(TAG,"showinginvalidchargerdialog");
    289.     
  289.  
    290.     
  290.  dismissLowBatteryWarning();
    291.     
  291.  
    292.     
  292.  AlertDialog.Builderb=newAlertDialog.Builder(mContext);
    293.     
  293.  b.setCancelable(true);
    294.     
  294.  b.setMessage(R.string.invalid_charger);
    295.     
  295.  b.setIconAttribute(android.R.attr.alertDialogIcon);
    296.     
  296.  b.setPositiveButton(android.R.string.ok,null);
    297.     
  297.  
    298.     
  298.  AlertDialogd=b.create();
    299.     
  299.  d.setOnDismissListener(newDialogInterface.OnDismissListener(){
    300.     
  300.  publicvoidonDismiss(DialogInterfacedialog){
    301.     
  301.  mInvalidChargerDialog=null;
    302.     
  302.  mBatteryLevelTextView=null;
    303.     
  303.  }
    304.     
  304.  });
    305.     
  305.  
    306.     
  306.  d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
    307.     
  307.  d.show();
    308.     
  308.  mInvalidChargerDialog=d;
    309.     
  309.  }
    310.     
  310.  
    311.     
  311.  publicvoiddump(FileDescriptorfd,PrintWriterpw,String[]args){
    312.     
  312.  pw.print("mLowBatteryAlertCloseLevel=");
    313.     
  313.  pw.println(mLowBatteryAlertCloseLevel);
    314.     
  314.  pw.print("mLowBatteryReminderLevels=");
    315.     
  315.  pw.println(Arrays.toString(mLowBatteryReminderLevels));
    316.     
  316.  pw.print("mInvalidChargerDialog=");
    317.     
  317.  pw.println(mInvalidChargerDialog==null?"null":mInvalidChargerDialog.toString());
    318.     
  318.  pw.print("mLowBatteryDialog=");
    319.     
  319.  pw.println(mLowBatteryDialog==null?"null":mLowBatteryDialog.toString());
    320.     
  320.  pw.print("mBatteryLevel=");
    321.     
  321.  pw.println(Integer.toString(mBatteryLevel));
    322.     
  322.  pw.print("mBatteryStatus=");
    323.     
  323.  pw.println(Integer.toString(mBatteryStatus));
    324.     
  324.  pw.print("mPlugType=");
    325.     
  325.  pw.println(Integer.toString(mPlugType));
    326.     
  326.  pw.print("mInvalidCharger=");
    327.     
  327.  pw.println(Integer.toString(mInvalidCharger));
    328.     
  328.  pw.print("mScreenOffTime=");
    329.     
  329.  pw.print(mScreenOffTime);
    330.     
  330.  if(mScreenOffTime>=0){
    331.     
  331.  pw.print("(");
    332.     
  332.  pw.print(SystemClock.elapsedRealtime()-mScreenOffTime);
    333.     
  333.  pw.print("ago)");
    334.     
  334.  }
    335.     
  335.  pw.println();
    336.     
  336.  pw.print("soundTimeout=");
    337.     
  337.  pw.println(Settings.Global.getInt(mContext.getContentResolver(),
    338.     
  338.  Settings.Global.LOW_BATTERY_SOUND_TIMEOUT,0));
    339.     
  339.  pw.print("bucket:");
    340.     
  340.  pw.println(Integer.toString(findBatteryLevelBucket(mBatteryLevel)));
    341.     
  341.  }
    342.     
  342.  }
    343.    
    
 总结一下：这个类就是接收电池电量改变的广播，然后弹窗提醒。
  
 
  
 
  
 下一个类就是没电关机界面了，文件目录：\frameworks\base\services\java\com\android\server\ShutdownLowBatteryActivity.java
  
 这个Activity的配置文件是这样的（\frameworks\base\core\res\AndroidManifest.xml）：
  
 
              [html] view plain     copy                         
        
  1.  <activityandroid:name="com.android.server.ShutdownLowBatteryActivity"
    2.     
  2.  android:theme="@android:style/Theme.Translucent.NoTitleBar"
    3.     
  3.  android:configChanges="orientation|keyboardHidden|screenSize"
    4.     
  4.  android:windowSoftInputMode="stateHidden"
    5.     
  5.  android:permission="android.permission.SHUTDOWN"
    6.     
  6.  android:excludeFromRecents="true">
    7.     
  7.  <intent-filter>
    8.     
  8.  <actionandroid:name="android.intent.action.ACTION_REQUEST_SHUTDOWN_LOWBATTERY"/>
    9.     
  9.  <categoryandroid:name="android.intent.category.DEFAULT"/>
    10.     
  10.  </intent-filter>
    11.     
  11.  </activity>
    12.    
    
  
 android:theme="@android:style/Theme.Translucent.NoTitleBar"是API小于11的透明主题。这样弹出的dialog会是老版本的主题。（这个Activity是透明的）
  
 对于Theme，因为是4.4，我更倾向于：android:theme="@android:style/Theme.Holo.Panel"
  
  
 ShutdownLowBatteryActivity.java：
  
 
              [java] view plain     copy                         
        
  1.  /*
    2.     
  2.  *Copyright(C)2009TheAndroidOpenSourceProject
    3.     
  3.  *
    4.     
  4.  *LicensedundertheApacheLicense,Version2.0(the"License");
    5.     
  5.  *youmaynotusethisfileexceptincompliancewiththeLicense.
    6.     
  6.  *YoumayobtainacopyoftheLicenseat
    7.     
  7.  *
    8.     
  8.  *http://www.apache.org/licenses/LICENSE-2.0
    9.     
  9.  *
    10.     
  10.  *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
    11.     
  11.  *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
    12.     
  12.  *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
    13.     
  13.  *SeetheLicenseforthespecificlanguagegoverningpermissionsand
    14.     
  14.  *limitationsundertheLicense.
    15.     
  15.  */
    16.     
  16.  
    17.     
  17.  packagecom.android.server;
    18.     
  18.  
    19.     
  19.  importandroid.app.Activity;
    20.     
  20.  importandroid.app.AlertDialog;
    21.     
  21.  importandroid.app.KeyguardManager;
    22.     
  22.  importandroid.content.BroadcastReceiver;
    23.     
  23.  importandroid.content.Context;
    24.     
  24.  importandroid.content.DialogInterface;
    25.     
  25.  importandroid.content.Intent;
    26.     
  26.  importandroid.content.IntentFilter;
    27.     
  27.  importandroid.os.Bundle;
    28.     
  28.  importandroid.os.Handler;
    29.     
  29.  importandroid.util.Slog;
    30.     
  30.  importandroid.view.Window;
    31.     
  31.  importandroid.view.WindowManager;
    32.     
  32.  importandroid.view.View;
    33.     
  33.  
    34.     
  34.  
    35.     
  35.  //importcom.android.internal.app.ShutdownThread;
    36.     
  36.  importcom.android.server.power.ShutdownThread;
    37.     
  37.  
    38.     
  38.  importandroid.telephony.TelephonyManager;
    39.     
  39.  importandroid.telephony.PhoneStateListener;
    40.     
  40.  importandroid.media.MediaPlayer;
    41.     
  41.  importandroid.media.MediaPlayer.OnCompletionListener;
    42.     
  42.  importandroid.content.ContentResolver;
    43.     
  43.  importandroid.provider.Settings;
    44.     
  44.  
    45.     
  45.  importjava.io.IOException;
    46.     
  46.  
    47.     
  47.  publicclassShutdownLowBatteryActivityextendsActivity{
    48.     
  48.  
    49.     
  49.  privatestaticfinalStringTAG="ShutdownLowBatteryActivity";
    50.     
  50.  privatebooleanmConfirm;
    51.     
  51.  privateintmSeconds=15;//电池电量等于015秒内不插充电器就自动关机
    52.     
  52.  privateAlertDialogmDialog;
    53.     
  53.  privateHandlermyHandler=newHandler();
    54.     
  54.  privateRunnablemyRunnable=newRunnable(){//这里数秒关机
    55.     
  55.  @Override
    56.     
  56.  publicvoidrun(){
    57.     
  57.  mSeconds--;
    58.     
  58.  if(mSeconds<1)
    59.     
  59.  mSeconds=0;
    60.     
  60.  mDialog.setMessage(getString(com.android.internal.R.string.low_battery_shutdown_after_seconds,mSeconds));
    61.     
  61.  
    62.     
  62.  if(mSeconds<=1){
    63.     
  63.  myHandler.removeCallbacks(myRunnable);
    64.     
  64.  Handlerh=newHandler();
    65.     
  65.  h.post(newRunnable(){
    66.     
  66.  publicvoidrun(){
    67.     
  67.  ShutdownThread.shutdown(ShutdownLowBatteryActivity.this,mConfirm);
    68.     
  68.  }
    69.     
  69.  });
    70.     
  70.  }
    71.     
  71.  myHandler.postDelayed(myRunnable,1000);
    72.     
  72.  }
    73.     
  73.  };
    74.     
  74.  
    75.     
  75.  privateBroadcastReceivermReceiver;
    76.     
  76.  privateMediaPlayermplayer;
    77.     
  77.  
    78.     
  78.  @Override
    79.     
  79.  protectedvoidonCreate(BundlesavedInstanceState){
    80.     
  80.  super.onCreate(savedInstanceState);
    81.     
  81.  
    82.     
  82.  mConfirm=getIntent().getBooleanExtra(Intent.EXTRA_KEY_CONFIRM,false);
    83.     
  83.  Slog.i(TAG,"onCreate():confirm="+mConfirm);
    84.     
  84.  
    85.     
  85.  //if(getIntent().getBooleanExtra("can_be_cancel",false)){//这行注释掉了：然后当连上充电器后或者电量涨到20的时候，就取消倒计时关机
    86.     
  86.  mReceiver=newBroadcastReceiver(){
    87.     
  87.  @Override
    88.     
  88.  publicvoidonReceive(Contextcontext,Intentintent){
    89.     
  89.  if(Intent.ACTION_BATTERY_OKAY.equals(intent.getAction())|
    90.     
  90.  Intent.ACTION_POWER_CONNECTED.equals(intent.getAction())){
    91.     
  91.  ShutDownWakeLock.releaseCpuLock();
    92.     
  92.  myHandler.removeCallbacks(myRunnable);
    93.     
  93.  if(mReceiver!=null)
    94.     
  94.  unregisterReceiver(mReceiver);
    95.     
  95.  finish();
    96.     
  96.  }
    97.     
  97.  }
    98.     
  98.  };
    99.     
  99.  
    100.     
  100.  IntentFilterfilter=newIntentFilter(Intent.ACTION_POWER_CONNECTED);
    101.     
  101.  filter.addAction(Intent.ACTION_BATTERY_OKAY);
    102.     
  102.  registerReceiver(mReceiver,filter);
    103.     
  103.  //}
    104.     
  104.  
    105.     
  105.  
    106.     
  106.  PhoneStateListenermPhoneStateListener=newPhoneStateListener(){//如果正数秒呢，电话呼入了。取消自动关机
    107.     
  107.  @Override
    108.     
  108.  publicvoidonCallStateChanged(intstate,Stringignored){
    109.     
  109.  if(state==TelephonyManager.CALL_STATE_RINGING){
    110.     
  110.  ShutDownWakeLock.releaseCpuLock();
    111.     
  111.  myHandler.removeCallbacks(myRunnable);
    112.     
  112.  finish();
    113.     
  113.  }
    114.     
  114.  }
    115.     
  115.  };
    116.     
  116.  
    117.     
  117.  TelephonyManagermTelephonyManager=(TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
    118.     
  118.  mTelephonyManager.listen(mPhoneStateListener,
    119.     
  119.  PhoneStateListener.LISTEN_CALL_STATE);
    120.     
  120.  requestWindowFeature(android.view.Window.FEATURE_NO_TITLE);
    121.     
  121.  Windowwin=getWindow();
    122.     
  122.  win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
    123.     
  123.  |WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD);
    124.     
  124.  win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
    125.     
  125.  |WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON);
    126.     
  126.  
    127.     
  127.  setContentView(newView(this));
    128.     
  128.  mDialog=newAlertDialog.Builder(this).create();
    129.     
  129.  mDialog.setTitle(com.android.internal.R.string.low_battery_shutdown_title);
    130.     
  130.  mDialog.setMessage(getString(com.android.internal.R.string.low_battery_shutdown_after_seconds,mSeconds));
    131.     
  131.  if(!getIntent().getBooleanExtra("cant_be_cancel_by_button",false)){//读取配置文件，是否运行取消，然后根据这个显示取消自动关机按钮
    132.     
  132.  mDialog.setButton(DialogInterface.BUTTON_NEUTRAL,getText(com.android.internal.R.string.cancel),newDialogInterface.OnClickListener(){
    133.     
  133.  @Override
    134.     
  134.  publicvoidonClick(DialogInterfacedialog,intwhich){
    135.     
  135.  myHandler.removeCallbacks(myRunnable);
    136.     
  136.  dialog.cancel();
    137.     
  137.  if(mReceiver!=null)
    138.     
  138.  unregisterReceiver(mReceiver);
    139.     
  139.  finish();
    140.     
  140.  }});
    141.     
  141.  }
    142.     
  142.  mDialog.setCancelable(false);
    143.     
  143.  //mDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
    144.     
  144.  mDialog.show();
    145.     
  145.  if(mConfirm==false){
    146.     
  146.  myHandler.postDelayed(myRunnable,1000);
    147.     
  147.  }
    148.     
  148.  myHandler.post(newRunnable(){
    149.     
  149.  publicvoidrun(){
    150.     
  150.  finalContentResolvercr=getContentResolver();
    151.     
  151.  Stringpath=Settings.System.getString(cr,Settings.System.NOTIFICATION_SOUND);
    152.     
  152.  
    153.     
  153.  mplayer=newMediaPlayer();
    154.     
  154.  try{
    155.     
  155.  mplayer.reset();
    156.     
  156.  mplayer.setDataSource("system/media/audio/ui/LowBattery.ogg");
    157.     
  157.  mplayer.prepare();
    158.     
  158.  mplayer.start();
    159.     
  159.  mplayer.setOnCompletionListener(newOnCompletionListener(){
    160.     
  160.  @Override
    161.     
  161.  publicvoidonCompletion(MediaPlayermp){
    162.     
  162.  if(null!=mplayer){
    163.     
  163.  mplayer.stop();
    164.     
  164.  mplayer.release();
    165.     
  165.  mplayer=null;
    166.     
  166.  }
    167.     
  167.  }
    168.     
  168.  });
    169.     
  169.  }
    170.     
  170.  catch(IOExceptione){
    171.     
  171.  
    172.     
  172.  }
    173.     
  173.  }
    174.     
  174.  });
    175.     
  175.  }
    176.     
  176.  }
    177.    
    总结如下：这个类就是弹窗计时，提醒不连充电器就要关机了。  
  
  
 
  
 最后一个相关的类，文件路径：\frameworks\base\packages\SystemUI\src\com\android\systemui\BatteryMeterView.java
  
 这个类是自定义控件，定义在手机状态栏里：
  
 
  
 
              [java] view plain     copy                         
        
  1.  /*
    2.     
  2.  *Copyright(C)2013TheAndroidOpenSourceProject
    3.     
  3.  *
    4.     
  4.  *LicensedundertheApacheLicense,Version2.0(the"License");
    5.     
  5.  *youmaynotusethisfileexceptincompliancewiththeLicense.
    6.     
  6.  *YoumayobtainacopyoftheLicenseat
    7.     
  7.  *
    8.     
  8.  *http://www.apache.org/licenses/LICENSE-2.0
    9.     
  9.  *
    10.     
  10.  *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
    11.     
  11.  *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
    12.     
  12.  *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
    13.     
  13.  *SeetheLicenseforthespecificlanguagegoverningpermissionsand
    14.     
  14.  *limitationsundertheLicense.
    15.     
  15.  */
    16.     
  16.  
    17.     
  17.  packagecom.android.systemui;
    18.     
  18.  
    19.     
  19.  importandroid.content.BroadcastReceiver;
    20.     
  20.  importandroid.content.Context;
    21.     
  21.  importandroid.content.Intent;
    22.     
  22.  importandroid.content.IntentFilter;
    23.     
  23.  importandroid.content.res.Resources;
    24.     
  24.  importandroid.content.res.TypedArray;
    25.     
  25.  importandroid.graphics.Canvas;
    26.     
  26.  importandroid.graphics.Paint;
    27.     
  27.  importandroid.graphics.Path;
    28.     
  28.  importandroid.graphics.PorterDuff;
    29.     
  29.  importandroid.graphics.PorterDuffXfermode;
    30.     
  30.  importandroid.graphics.Rect;
    31.     
  31.  importandroid.graphics.RectF;
    32.     
  32.  importandroid.graphics.Typeface;
    33.     
  33.  importandroid.os.BatteryManager;
    34.     
  34.  importandroid.os.Bundle;
    35.     
  35.  importandroid.provider.Settings;
    36.     
  36.  importandroid.util.AttributeSet;
    37.     
  37.  importandroid.view.View;
    38.     
  38.  
    39.     
  39.  publicclassBatteryMeterViewextendsViewimplementsDemoMode{
    40.     
  40.  publicstaticfinalStringTAG=BatteryMeterView.class.getSimpleName();
    41.     
  41.  publicstaticfinalStringACTION_LEVEL_TEST="com.android.systemui.BATTERY_LEVEL_TEST";
    42.     
  42.  
    43.     
  43.  publicstaticfinalbooleanENABLE_PERCENT=true;
    44.     
  44.  publicstaticfinalbooleanSINGLE_DIGIT_PERCENT=false;
    45.     
  45.  publicstaticfinalbooleanSHOW_100_PERCENT=false;
    46.     
  46.  
    47.     
  47.  publicstaticfinalintFULL=96;
    48.     
  48.  publicstaticfinalintEMPTY=4;
    49.     
  49.  
    50.     
  50.  publicstaticfinalfloatSUBPIXEL=0.4f;//insetrectsforsofteredges
    51.     
  51.  
    52.     
  52.  int[]mColors;
    53.     
  53.  
    54.     
  54.  booleanmShowPercent=true;
    55.     
  55.  PaintmFramePaint,mBatteryPaint,mWarningTextPaint,mTextPaint,mBoltPaint;
    56.     
  56.  intmButtonHeight;
    57.     
  57.  privatefloatmTextHeight,mWarningTextHeight;
    58.     
  58.  
    59.     
  59.  privateintmHeight;
    60.     
  60.  privateintmWidth;
    61.     
  61.  privateStringmWarningString;
    62.     
  62.  privatefinalintmChargeColor;
    63.     
  63.  privatefinalfloat[]mBoltPoints;
    64.     
  64.  privatefinalPathmBoltPath=newPath();
    65.     
  65.  
    66.     
  66.  privatefinalRectFmFrame=newRectF();
    67.     
  67.  privatefinalRectFmButtonFrame=newRectF();
    68.     
  68.  privatefinalRectFmClipFrame=newRectF();
    69.     
  69.  privatefinalRectFmBoltFrame=newRectF();
    70.     
  70.  
    71.     
  71.  privateclassBatteryTrackerextendsBroadcastReceiver{
    72.     
  72.  publicstaticfinalintUNKNOWN_LEVEL=-1;
    73.     
  73.  
    74.     
  74.  //currentbatterystatus
    75.     
  75.  intlevel=UNKNOWN_LEVEL;
    76.     
  76.  StringpercentStr;
    77.     
  77.  intplugType;
    78.     
  78.  booleanplugged;
    79.     
  79.  inthealth;
    80.     
  80.  intstatus;
    81.     
  81.  Stringtechnology;
    82.     
  82.  intvoltage;
    83.     
  83.  inttemperature;
    84.     
  84.  booleantestmode=false;
    85.     
  85.  
    86.     
  86.  @Override
    87.     
  87.  publicvoidonReceive(Contextcontext,Intentintent){
    88.     
  88.  finalStringaction=intent.getAction();
    89.     
  89.  if(action.equals(Intent.ACTION_BATTERY_CHANGED)){//接收电量改变的广播，取电池状态的属性
    90.     
  90.  if(testmode&&!intent.getBooleanExtra("testmode",false))return;
    91.     
  91.  
    92.     
  92.  level=(int)(100f
    93.     
  93.  *intent.getIntExtra(BatteryManager.EXTRA_LEVEL,0)
    94.     
  94.  /intent.getIntExtra(BatteryManager.EXTRA_SCALE,100));
    95.     
  95.  
    96.     
  96.  plugType=intent.getIntExtra(BatteryManager.EXTRA_PLUGGED,0);
    97.     
  97.  plugged=plugType!=0;
    98.     
  98.  health=intent.getIntExtra(BatteryManager.EXTRA_HEALTH,
    99.     
  99.  BatteryManager.BATTERY_HEALTH_UNKNOWN);
    100.     
  100.  status=intent.getIntExtra(BatteryManager.EXTRA_STATUS,
    101.     
  101.  BatteryManager.BATTERY_STATUS_UNKNOWN);
    102.     
  102.  technology=intent.getStringExtra(BatteryManager.EXTRA_TECHNOLOGY);
    103.     
  103.  voltage=intent.getIntExtra(BatteryManager.EXTRA_VOLTAGE,0);
    104.     
  104.  temperature=intent.getIntExtra(BatteryManager.EXTRA_TEMPERATURE,0);
    105.     
  105.  
    106.     
  106.  setContentDescription(
    107.     
  107.  context.getString(R.string.accessibility_battery_level,level));
    108.     
  108.  postInvalidate();
    109.     
  109.  }elseif(action.equals(ACTION_LEVEL_TEST)){
    110.     
  110.  testmode=true;
    111.     
  111.  post(newRunnable(){
    112.     
  112.  intcurLevel=0;
    113.     
  113.  intincr=1;
    114.     
  114.  intsaveLevel=level;
    115.     
  115.  intsavePlugged=plugType;
    116.     
  116.  Intentdummy=newIntent(Intent.ACTION_BATTERY_CHANGED);
    117.     
  117.  @Override
    118.     
  118.  publicvoidrun(){
    119.     
  119.  if(curLevel<0){
    120.     
  120.  testmode=false;
    121.     
  121.  dummy.putExtra("level",saveLevel);
    122.     
  122.  dummy.putExtra("plugged",savePlugged);
    123.     
  123.  dummy.putExtra("testmode",false);
    124.     
  124.  }else{
    125.     
  125.  dummy.putExtra("level",curLevel);
    126.     
  126.  dummy.putExtra("plugged",incr>0?BatteryManager.BATTERY_PLUGGED_AC:0);
    127.     
  127.  dummy.putExtra("testmode",true);
    128.     
  128.  }
    129.     
  129.  getContext().sendBroadcast(dummy);
    130.     
  130.  
    131.     
  131.  if(!testmode)return;
    132.     
  132.  
    133.     
  133.  curLevel+=incr;
    134.     
  134.  if(curLevel==100){
    135.     
  135.  incr*=-1;
    136.     
  136.  }
    137.     
  137.  postDelayed(this,200);
    138.     
  138.  }
    139.     
  139.  });
    140.     
  140.  }
    141.     
  141.  }
    142.     
  142.  }
    143.     
  143.  
    144.     
  144.  BatteryTrackermTracker=newBatteryTracker();
    145.     
  145.  
    146.     
  146.  @Override
    147.     
  147.  publicvoidonAttachedToWindow(){
    148.     
  148.  super.onAttachedToWindow();
    149.     
  149.  
    150.     
  150.  IntentFilterfilter=newIntentFilter();
    151.     
  151.  filter.addAction(Intent.ACTION_BATTERY_CHANGED);
    152.     
  152.  filter.addAction(ACTION_LEVEL_TEST);
    153.     
  153.  finalIntentsticky=getContext().registerReceiver(mTracker,filter);
    154.     
  154.  if(sticky!=null){
    155.     
  155.  //preloadthebatterylevel
    156.     
  156.  mTracker.onReceive(getContext(),sticky);
    157.     
  157.  }
    158.     
  158.  }
    159.     
  159.  
    160.     
  160.  @Override
    161.     
  161.  publicvoidonDetachedFromWindow(){
    162.     
  162.  super.onDetachedFromWindow();
    163.     
  163.  
    164.     
  164.  getContext().unregisterReceiver(mTracker);
    165.     
  165.  
    166.    








更多相关文章
	

    

  1. Android(安卓)实现定时开关机另类实现--BSP级
  2. unity android获取电量和wifi信号强度
  3. 蓝牙遥控器获取电量GATT
  4. Android(安卓)优化电池使用时间 ——监控电池电量和充电状态
  5. Android实现电量控制降低耗电
  6. 展讯android LEDS模块分析----一个bug
  7. [置顶] Android(安卓)显示手机电池的当前电量
  8. 降低android应用程序耗电量的解决方案
  9. Android功耗测试小工具集锦



随机推荐
	

    

  1. 
在腾讯云上创建您的 SQL Cluster (2)
    2. 

  2. 
双栏模型Hurdle远超Tobit, 对于归并数据
    3. 

  3. 
向量自回归VAR模型操作指南针,为微观面板
    4. 

  4. 
有限混合模型FMM,异质性分组分析的新筹码
    5. 

  5. 
条件Logit绝对不输多项Logit,而混合模型
    6. 

  6. 
广义PSM,连续政策变量因果识别的不二利器
    7. 

  7. 
政策评估中"中介效应"因果分析, 有趣的前
    8. 

  8. 
腾讯云 TDSQL 审计原理揭秘
    9. 

  9. 
JavaScript基础之 变量与常量的声明、函
    10. 

  10. 
Jupyter Notebook主题设置
    11.