android 4.4 batteryservice 电池电量显示分析

转载地址:http://blog.csdn.net/daweibalang717/article/details/40615453

最近工作接触到这么的东西,这是我对整个电池管理方面Java 层的分析。如果想了解底层的话,请看我的博客:

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 print ?
  1. /* 
  2.  * Copyright (C) 2006 The Android Open Source Project 
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License"); 
  5.  * you may not use this file except in compliance with the License. 
  6.  * You may obtain a copy of the License at 
  7.  * 
  8.  *      http://www.apache.org/licenses/LICENSE-2.0 
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software 
  11.  * distributed under the License is distributed on an "AS IS" BASIS, 
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  13.  * See the License for the specific language governing permissions and 
  14.  * limitations under the License. 
  15.  */  
  16.   
  17. package com.android.server;  
  18.   
  19. import android.os.BatteryStats;  
  20. import com.android.internal.app.IBatteryStats;  
  21. import com.android.server.am.BatteryStatsService;  
  22.   
  23. import android.app.ActivityManagerNative;  
  24. import android.content.ContentResolver;  
  25. import android.content.Context;  
  26. import android.content.Intent;  
  27. import android.content.pm.PackageManager;  
  28. import android.os.BatteryManager;  
  29. import android.os.BatteryProperties;  
  30. import android.os.Binder;  
  31. import android.os.FileUtils;  
  32. import android.os.Handler;  
  33. import android.os.IBatteryPropertiesListener;  
  34. import android.os.IBatteryPropertiesRegistrar;  
  35. import android.os.IBinder;  
  36. import android.os.DropBoxManager;  
  37. import android.os.RemoteException;  
  38. import android.os.ServiceManager;  
  39. import android.os.SystemClock;  
  40. import android.os.UEventObserver;  
  41. import android.os.UserHandle;  
  42. import android.provider.Settings;  
  43. import android.util.EventLog;  
  44. import android.util.Slog;  
  45.   
  46. import java.io.File;  
  47. import java.io.FileDescriptor;  
  48. import java.io.FileOutputStream;  
  49. import java.io.IOException;  
  50. import java.io.PrintWriter;  
  51.   
  52.   
  53. /** 
  54.  * <p>BatteryService monitors the charging status, and charge level of the device 
  55.  * battery.  When these values change this service broadcasts the new values 
  56.  * to all {@link android.content.BroadcastReceiver IntentReceivers} that are 
  57.  * watching the {@link android.content.Intent#ACTION_BATTERY_CHANGED 
  58.  * BATTERY_CHANGED} action.</p> 
  59.  * <p>The new values are stored in the Intent data and can be retrieved by 
  60.  * calling {@link android.content.Intent#getExtra Intent.getExtra} with the 
  61.  * following keys:</p> 
  62.  * <p>"scale" - int, the maximum value for the charge level</p> 
  63.  * <p>"level" - int, charge level, from 0 through "scale" inclusive</p> 
  64.  * <p>"status" - String, the current charging status.<br /> 
  65.  * <p>"health" - String, the current battery health.<br /> 
  66.  * <p>"present" - boolean, true if the battery is present<br /> 
  67.  * <p>"icon-small" - int, suggested small icon to use for this state</p> 
  68.  * <p>"plugged" - int, 0 if the device is not plugged in; 1 if plugged 
  69.  * into an AC power adapter; 2 if plugged in via USB.</p> 
  70.  * <p>"voltage" - int, current battery voltage in millivolts</p> 
  71.  * <p>"temperature" - int, current battery temperature in tenths of 
  72.  * a degree Centigrade</p> 
  73.  * <p>"technology" - String, the type of battery installed, e.g. "Li-ion"</p> 
  74.  * 
  75.  * <p> 
  76.  * The battery service may be called by the power manager while holding its locks so 
  77.  * we take care to post all outcalls into the activity manager to a handler. 
  78.  * 
  79.  * FIXME: Ideally the power manager would perform all of its calls into the battery 
  80.  * service asynchronously itself. 
  81.  * </p> 
  82.  */  
  83. public final class BatteryService extends Binder {  
  84.     private static final String TAG = BatteryService.class.getSimpleName();  
  85.   
  86.     private static final boolean DEBUG = false;  
  87.   
  88.     private static final int BATTERY_SCALE = 100;    // battery capacity is a percentage  
  89.   
  90.     // Used locally for determining when to make a last ditch effort to log  
  91.     // discharge stats before the device dies.  
  92.     private int mCriticalBatteryLevel;  
  93.   
  94.     private static final int DUMP_MAX_LENGTH = 24 * 1024;  
  95.     private static final String[] DUMPSYS_ARGS = new String[] { "--checkin""--unplugged" };  
  96.   
  97.     private static final String DUMPSYS_DATA_PATH = "/data/system/";  
  98.   
  99.     // This should probably be exposed in the API, though it's not critical  
  100.     private static final int BATTERY_PLUGGED_NONE = 0;  
  101.   
  102.     private final Context mContext;  
  103.     private final IBatteryStats mBatteryStats;  
  104.     private final Handler mHandler;  
  105.   
  106.     private final Object mLock = new Object();  
  107.   
  108.     private BatteryProperties mBatteryProps;  
  109.     private boolean mBatteryLevelCritical;  
  110.     private int mLastBatteryStatus;  
  111.     private int mLastBatteryHealth;  
  112.     private boolean mLastBatteryPresent;  
  113.     private int mLastBatteryLevel;  
  114.     private int mLastBatteryVoltage;  
  115.     private int mLastBatteryTemperature;  
  116.     private boolean mLastBatteryLevelCritical;  
  117.   
  118.     private int mInvalidCharger;  
  119.     private int mLastInvalidCharger;  
  120.   
  121.     private int mLowBatteryWarningLevel;  
  122.     private int mLowBatteryCloseWarningLevel;  
  123.     private int mShutdownBatteryTemperature;  
  124.   
  125.     private int mPlugType;  
  126.     private int mLastPlugType = -1// Extra state so we can detect first run  
  127.   
  128.     private long mDischargeStartTime;  
  129.     private int mDischargeStartLevel;  
  130.   
  131.     private boolean mUpdatesStopped;  
  132.   
  133.     private Led mLed;  
  134.   
  135.     private boolean mSentLowBatteryBroadcast = false;  
  136.   
  137.     private BatteryListener mBatteryPropertiesListener;  
  138.     private IBatteryPropertiesRegistrar mBatteryPropertiesRegistrar;  
  139. //构造函数  
  140.     public BatteryService(Context context, LightsService lights) {  
  141.         mContext = context;  
  142.         mHandler = new Handler(true /*async*/);  
  143.         mLed = new Led(context, lights);//这个应该是指示灯,没实验  
  144.         mBatteryStats = BatteryStatsService.getService();  
  145.   
  146.  //低电量临界值,这个数我看的源码版本值是4(在这个类里只是用来写日志)  
  147.         mCriticalBatteryLevel = mContext.getResources().getInteger(  
  148.                 com.android.internal.R.integer.config_criticalBatteryWarningLevel);  
  149.   
  150. //低电量告警值,值15,下面会根据这个变量发送低电量的广播Intent.ACTION_BATTERY_LOW(这个跟系统低电量提醒没关系,只是发出去了)  
  151.         mLowBatteryWarningLevel = mContext.getResources().getInteger(  
  152.                 com.android.internal.R.integer.config_lowBatteryWarningLevel);  
  153.   
  154. //电量告警取消值,值20 , 就是手机电量大于等于20的话发送Intent.ACTION_BATTERY_OKAY  
  155.         mLowBatteryCloseWarningLevel = mContext.getResources().getInteger(  
  156.                 com.android.internal.R.integer.config_lowBatteryCloseWarningLevel);  
  157.   
  158. //值是680 ,温度过高,超过这个值就发送广播,跳转到将要关机提醒。  
  159.        mShutdownBatteryTemperature = mContext.getResources().getInteger(  
  160.                 com.android.internal.R.integer.config_shutdownBatteryTemperature);  
  161.   
  162.         // watch for invalid charger messages if the invalid_charger switch exists  
  163.         if (new File("/sys/devices/virtual/switch/invalid_charger/state").exists()) {  
  164.             mInvalidChargerObserver.startObserving(  
  165.                     "DEVPATH=/devices/virtual/switch/invalid_charger");  
  166.         }  
  167. //电池监听,这个应该是注册到底层去了。当底层电量改变会调用此监听。然后执行update(BatteryProperties props);  
  168.         mBatteryPropertiesListener = new BatteryListener();  
  169.   
  170.         IBinder b = ServiceManager.getService("batterypropreg");  
  171.         mBatteryPropertiesRegistrar = IBatteryPropertiesRegistrar.Stub.asInterface(b);  
  172.   
  173.         try {  
  174. //这里注册  
  175.           mBatteryPropertiesRegistrar.registerListener(mBatteryPropertiesListener);  
  176.         } catch (RemoteException e) {  
  177.             // Should never happen.  
  178.         }  
  179.     }  
  180. //开机后先去看看是否没电了或者温度太高了。如果是,就关机提示(关机提示我等会介绍)。  
  181.     void systemReady() {  
  182.         // check our power situation now that it is safe to display the shutdown dialog.  
  183.         synchronized (mLock) {  
  184.             shutdownIfNoPowerLocked();  
  185.             shutdownIfOverTempLocked();  
  186.         }  
  187.     }  
  188. //返回是否在充电,这个函数在PowerManagerService.java 中调用  
  189.     /** 
  190.      * Returns true if the device is plugged into any of the specified plug types. 
  191.      */  
  192.     public boolean isPowered(int plugTypeSet) {  
  193.         synchronized (mLock) {  
  194.             return isPoweredLocked(plugTypeSet);  
  195.         }  
  196.     }  
  197. //就是这里,通过充电器类型判断是否充电  
  198.     private boolean isPoweredLocked(int plugTypeSet) {  
  199. //我这英语小白猜着翻译下:就是开机后,电池状态不明了,那我们就认为就在充电,以便设备正常工作。  
  200.         // assume we are powered if battery state is unknown so  
  201.         // the "stay on while plugged in" option will work.  
  202.         if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_UNKNOWN) {  
  203.             return true;  
  204.         }  
  205. //充电器  
  206.         if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_AC) != 0 && mBatteryProps.chargerAcOnline) {  
  207.             return true;  
  208.         }  
  209. //USB,插电脑上充电  
  210.       if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_USB) != 0 && mBatteryProps.chargerUsbOnline) {  
  211.             return true;  
  212.         }  
  213. //电源是无线的。 (我没见过...)  
  214.         if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_WIRELESS) != 0 && mBatteryProps.chargerWirelessOnline) {  
  215.             return true;  
  216.         }  
  217.         return false;  
  218.     }  
  219.   
  220.     /** 
  221.      * Returns the current plug type. 
  222.      */  
  223. //充电器类型  
  224.    public int getPlugType() {  
  225.         synchronized (mLock) {  
  226.             return mPlugType;  
  227.         }  
  228.     }  
  229.   
  230.     /** 
  231.      * Returns battery level as a percentage. 
  232.      */  
  233. //电池属性:电量等级(0-100)  
  234.     public int getBatteryLevel() {  
  235.         synchronized (mLock) {  
  236.             return mBatteryProps.batteryLevel;  
  237.         }  
  238.     }  
  239.   
  240.     /** 
  241.      * Returns true if battery level is below the first warning threshold. 
  242.      */  
  243. //低电量  
  244.      public boolean isBatteryLow() {  
  245.         synchronized (mLock) {  
  246.             return mBatteryProps.batteryPresent && mBatteryProps.batteryLevel <= mLowBatteryWarningLevel;  
  247.         }  
  248.     }  
  249.   
  250.     /** 
  251.      * Returns a non-zero value if an  unsupported charger is attached. 
  252.      */  
  253. //不支持的充电器类型    
  254.     public int getInvalidCharger() {  
  255.         synchronized (mLock) {  
  256.             return mInvalidCharger;  
  257.         }  
  258.     }  
  259.   
  260. //这里就是没电了,要关机的提示。  
  261.     private void shutdownIfNoPowerLocked() {  
  262.         // shut down gracefully if our battery is critically low and we are not powered.  
  263.         // wait until the system has booted before attempting to display the shutdown dialog.  
  264.         if (mBatteryProps.batteryLevel == 0 && (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_DISCHARGING)) {  
  265.             mHandler.post(new Runnable() {  
  266.                 @Override  
  267.                 public void run() {  
  268.                     if (ActivityManagerNative.isSystemReady()) {  
  269.                         Intent intent = new Intent("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.     }  
  279.   
  280. //温度过高,关机提示(个人感觉这里有问题,温度过高为啥子跳转到没电关机提示界面)   
  281.     private void shutdownIfOverTempLocked() {  
  282.         // shut down gracefully if temperature is too high (> 68.0C by default)  
  283.         // wait until the system has booted before attempting to display the  
  284.         // shutdown dialog.  
  285.         if (mBatteryProps.batteryTemperature > mShutdownBatteryTemperature) {  
  286.             mHandler.post(new Runnable() {  
  287.                 @Override  
  288.                 public void run() {  
  289.                     if (ActivityManagerNative.isSystemReady()) {  
  290.                         Intent intent = new Intent("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.     private void update(BatteryProperties props) {  
  301.         synchronized (mLock) {  
  302.             if (!mUpdatesStopped) {  
  303.                 mBatteryProps = props;  
  304.                 // Process the new values.  
  305.                 processValuesLocked();  
  306.             }  
  307.         }  
  308.     }  
  309. //嗯。这个就是最主要的方法了。  
  310.     private void processValuesLocked() {  
  311.         boolean logOutlier = false;  
  312.         long dischargeDuration = 0;  
  313.   
  314.         mBatteryLevelCritical = (mBatteryProps.batteryLevel <= mCriticalBatteryLevel);  
  315. //充电器类型   
  316.        if (mBatteryProps.chargerAcOnline) {  
  317.             mPlugType = BatteryManager.BATTERY_PLUGGED_AC;  
  318.         } else if (mBatteryProps.chargerUsbOnline) {  
  319.             mPlugType = BatteryManager.BATTERY_PLUGGED_USB;  
  320.         } else if (mBatteryProps.chargerWirelessOnline) {  
  321.             mPlugType = BatteryManager.BATTERY_PLUGGED_WIRELESS;  
  322.         } else {  
  323.             mPlugType = BATTERY_PLUGGED_NONE;  
  324.         }  
  325.   
  326.         if (DEBUG) {//日志,略过  
  327.             Slog.d(TAG, "Processing new values: "  
  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.         }  
  343.   
  344.         // Let the battery stats keep track of the current level.  
  345.         try {  
  346. //把电池属性放到状态里面  
  347.            mBatteryStats.setBatteryState(mBatteryProps.batteryStatus, mBatteryProps.batteryHealth,  
  348.                     mPlugType, mBatteryProps.batteryLevel, mBatteryProps.batteryTemperature,  
  349.                     mBatteryProps.batteryVoltage);  
  350.         } catch (RemoteException e) {  
  351.             // Should never happen.  
  352.         }  
  353. //没电了  
  354.         shutdownIfNoPowerLocked();  
  355. //温度过高了  
  356.        shutdownIfOverTempLocked();  
  357.   
  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) {  
  366.   
  367.             if (mPlugType != mLastPlugType) {//当前充电器类型与上次的不一样  
  368. //并且上次充电器类型是no one ,那就可以知道,现在是插上充电器了。  
  369.                if (mLastPlugType == BATTERY_PLUGGED_NONE) {  
  370.                     // discharging -> charging  
  371.   
  372.                     // There's no value in this data unless we've discharged at least once and the  
  373.                     // battery level has changed; so don't log until it does.  
  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.                         // make sure we see a discharge event before logging again  
  380.                         mDischargeStartTime = 0;  
  381.                     }  
  382. //并且本次充电器类型是no one ,那就可以知道,现在是拔掉充电器了。  
  383.                 } else if (mPlugType == BATTERY_PLUGGED_NONE) {  
  384.                     // charging -> discharging or we just powered up  
  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't do this just from voltage or temperature changes, that is  
  399.                 // too noisy.  
  400.                 EventLog.writeEvent(EventLogTags.BATTERY_LEVEL,  
  401.                         mBatteryProps.batteryLevel, mBatteryProps.batteryVoltage, mBatteryProps.batteryTemperature);  
  402.             }  
  403.             if (mBatteryLevelCritical && !mLastBatteryLevelCritical &&  
  404.                     mPlugType == BATTERY_PLUGGED_NONE) {  
  405.                 // We want to make sure we log discharge cycle outliers  
  406.                 // if the battery is about to die.  
  407.                 dischargeDuration = SystemClock.elapsedRealtime() - mDischargeStartTime;  
  408.                 logOutlier = true;  
  409.             }  
  410. //本次调用,当前的充电状态  
  411.             final boolean plugged = mPlugType != BATTERY_PLUGGED_NONE;  
  412. //本次调用,上次调用的充电状态    
  413.             final boolean oldPlugged = mLastPlugType != BATTERY_PLUGGED_NONE;  
  414.   
  415.             /* The ACTION_BATTERY_LOW broadcast is sent in these situations: 
  416.              * - is just un-plugged (previously was plugged) and battery level is 
  417.              *   less than or equal to WARNING, or 
  418.              * - is not plugged and battery level falls to WARNING boundary 
  419.              *   (becomes <= mLowBatteryWarningLevel). 
  420.              */  
  421. //用于发送低电量广播的判断  
  422.             final boolean sendBatteryLow = !plugged//(按sendBatteryLow = true 来说) 当前没有充电  
  423.                     && mBatteryProps.batteryStatus != BatteryManager.BATTERY_STATUS_UNKNOWN//充电状态不是UNKNOWN  
  424.                     && mBatteryProps.batteryLevel <= mLowBatteryWarningLevel//当前电量小于告警值 15  
  425.                     && (oldPlugged || mLastBatteryLevel > mLowBatteryWarningLevel);//上次状态是充电或者上次电量等级大于告警值 15  
  426.   
  427.             sendIntentLocked();//发送电池电量改变的广播Intent.ACTION_BATTERY_CHANGED  
  428.   
  429.             // Separate broadcast is sent for power connected / not connected  
  430.             // since the standard intent will not wake any applications and some  
  431.             // applications may want to have smart behavior based on this.  
  432.             if (mPlugType != 0 && mLastPlugType == 0) {//插上充电器了  
  433.                 mHandler.post(new Runnable() {  
  434.                     @Override  
  435.                     public void run() {  
  436.                         Intent statusIntent = new Intent(Intent.ACTION_POWER_CONNECTED);  
  437.                         statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);  
  438.                         mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);  
  439.                     }  
  440.                 });  
  441.             }  
  442.             else if (mPlugType == 0 && mLastPlugType != 0) {//断开充电器了  
  443.                 mHandler.post(new Runnable() {  
  444.                     @Override  
  445.                     public void run() {  
  446.                         Intent statusIntent = new Intent(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(new Runnable() {  
  456.                     @Override  
  457.                     public void run() {  
  458.                         Intent statusIntent = new Intent(Intent.ACTION_BATTERY_LOW);  
  459.                         statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);  
  460.                         mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);  
  461.                     }  
  462.                 });  
  463.             } else if (mSentLowBatteryBroadcast && mLastBatteryLevel >= mLowBatteryCloseWarningLevel) {//电量超过20了。电池状态OK了  
  464.                 mSentLowBatteryBroadcast = false;  
  465.                 mHandler.post(new Runnable() {  
  466.                     @Override  
  467.                     public void run() {  
  468.                         Intent statusIntent = new Intent(Intent.ACTION_BATTERY_OKAY);  
  469.                         statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);  
  470.                         mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);  
  471.                     }  
  472.                 });  
  473.             }  
  474.   
  475.             // Update the battery LED  
  476.             mLed.updateLightsLocked();  
  477.   
  478.             // This needs to be done after sendIntent() so that we get the lastest battery stats.  
  479.             if (logOutlier && dischargeDuration != 0) {  
  480.                 logOutlierLocked(dischargeDuration);  
  481.             }  
  482.   
  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.     private void sendIntentLocked() {  
  496.         //  Pack up the values and broadcast them to everyone  
  497.         final Intent intent = new Intent(Intent.ACTION_BATTERY_CHANGED);  
  498.         intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY  
  499.                 | Intent.FLAG_RECEIVER_REPLACE_PENDING);  
  500.   
  501.         int icon = getIconLocked(mBatteryProps.batteryLevel);  
  502.   
  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);  
  514.   
  515.         if (DEBUG) {  
  516.             Slog.d(TAG, "Sending ACTION_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.                     ", AC powered:" + mBatteryProps.chargerAcOnline + ", USB powered:" + mBatteryProps.chargerUsbOnline +  
  523.                     ", Wireless powered:" + mBatteryProps.chargerWirelessOnline +  
  524.                     ", icon:" + icon  + ", invalid charger:" + mInvalidCharger);  
  525.         }  
  526.   
  527.         mHandler.post(new Runnable() {  
  528.             @Override  
  529.             public void run() {  
  530.                 ActivityManagerNative.broadcastStickyIntent(intent, null, UserHandle.USER_ALL);  
  531.             }  
  532.         });  
  533.     }  
  534.   
  535.     private void logBatteryStatsLocked() {  
  536.         IBinder batteryInfoService = ServiceManager.getService(BatteryStats.SERVICE_NAME);  
  537.         if (batteryInfoService == nullreturn;  
  538.   
  539.         DropBoxManager db = (DropBoxManager) mContext.getSystemService(Context.DROPBOX_SERVICE);  
  540.         if (db == null || !db.isTagEnabled("BATTERY_DISCHARGE_INFO")) return;  
  541.   
  542.         File dumpFile = null;  
  543.         FileOutputStream dumpStream = null;  
  544.         try {  
  545.             // dump the service to a file  
  546.             dumpFile = new File(DUMPSYS_DATA_PATH + BatteryStats.SERVICE_NAME + ".dump");  
  547.             dumpStream = new FileOutputStream(dumpFile);  
  548.             batteryInfoService.dump(dumpStream.getFD(), DUMPSYS_ARGS);  
  549.             FileUtils.sync(dumpStream);  
  550.   
  551.             // add dump file to drop box  
  552.             db.addFile("BATTERY_DISCHARGE_INFO", dumpFile, DropBoxManager.IS_TEXT);  
  553.         } catch (RemoteException e) {  
  554.             Slog.e(TAG, "failed to dump battery service", e);  
  555.         } catch (IOException e) {  
  556.             Slog.e(TAG, "failed to write dumpsys file", e);  
  557.         } finally {  
  558.             // make sure we clean up  
  559.             if (dumpStream != null) {  
  560.                 try {  
  561.                     dumpStream.close();  
  562.                 } catch (IOException e) {  
  563.                     Slog.e(TAG, "failed to close dumpsys output stream");  
  564.                 }  
  565.             }  
  566.             if (dumpFile != null && !dumpFile.delete()) {  
  567.                 Slog.e(TAG, "failed to delete temporary dumpsys file: "  
  568.                         + dumpFile.getAbsolutePath());  
  569.             }  
  570.         }  
  571.     }  
  572.   
  573.     private void logOutlierLocked(long duration) {  
  574.         ContentResolver cr = mContext.getContentResolver();  
  575.         String dischargeThresholdString = Settings.Global.getString(cr,  
  576.                 Settings.Global.BATTERY_DISCHARGE_THRESHOLD);  
  577.         String durationThresholdString = Settings.Global.getString(cr,  
  578.                 Settings.Global.BATTERY_DISCHARGE_DURATION_THRESHOLD);  
  579.   
  580.         if (dischargeThresholdString != null && durationThresholdString != null) {  
  581.             try {  
  582.                 long durationThreshold = Long.parseLong(durationThresholdString);  
  583.                 int dischargeThreshold = Integer.parseInt(dischargeThresholdString);  
  584.                 if (duration <= durationThreshold &&  
  585.                         mDischargeStartLevel - mBatteryProps.batteryLevel >= dischargeThreshold) {  
  586.                     // If the discharge cycle is bad enough we want to know about it.  
  587.                     logBatteryStatsLocked();  
  588.                 }  
  589.                 if (DEBUG) Slog.v(TAG, "duration threshold: " + durationThreshold +  
  590.                         " discharge threshold: " + dischargeThreshold);  
  591.                 if (DEBUG) Slog.v(TAG, "duration: " + duration + " discharge: " +  
  592.                         (mDischargeStartLevel - mBatteryProps.batteryLevel));  
  593.             } catch (NumberFormatException e) {  
  594.                 Slog.e(TAG, "Invalid DischargeThresholds GService string: " +  
  595.                         durationThresholdString + " or " + dischargeThresholdString);  
  596.                 return;  
  597.             }  
  598.         }  
  599.     }  
  600.   
  601.     private int getIconLocked(int level) {  
  602.         if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_CHARGING) {  
  603.             return com.android.internal.R.drawable.stat_sys_battery_charge;  
  604.         } else if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_DISCHARGING) {  
  605.             return com.android.internal.R.drawable.stat_sys_battery;  
  606.         } else if (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.                 return com.android.internal.R.drawable.stat_sys_battery_charge;  
  611.             } else {  
  612.                 return com.android.internal.R.drawable.stat_sys_battery;  
  613.             }  
  614.         } else {  
  615.             return com.android.internal.R.drawable.stat_sys_battery_unknown;  
  616.         }  
  617.     }  
  618.   
  619.     @Override  
  620.     protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {  
  621.         if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)  
  622.                 != PackageManager.PERMISSION_GRANTED) {  
  623.   
  624.             pw.println("Permission Denial: can't dump Battery service from from pid="  
  625.                     + Binder.getCallingPid()  
  626.                     + ", uid=" + Binder.getCallingUid());  
  627.             return;  
  628.         }  
  629.   
  630.         synchronized (mLock) {  
  631.             if (args == null || args.length == 0 || "-a".equals(args[0])) {  
  632.                 pw.println("Current Battery Service state:");  
  633.                 if (mUpdatesStopped) {  
  634.                     pw.println("  (UPDATES STOPPED -- use 'reset' to restart)");  
  635.                 }  
  636.                 pw.println("  AC powered: " + mBatteryProps.chargerAcOnline);  
  637.                 pw.println("  USB powered: " + mBatteryProps.chargerUsbOnline);  
  638.                 pw.println("  Wireless powered: " + 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);  
  645.   
  646.                 if (mBatteryProps.batteryCurrentNow != Integer.MIN_VALUE) {  
  647.                     pw.println("  current now: " + mBatteryProps.batteryCurrentNow);  
  648.                 }  
  649.   
  650.                 if (mBatteryProps.batteryChargeCounter != Integer.MIN_VALUE) {  
  651.                     pw.println("  charge counter: " + mBatteryProps.batteryChargeCounter);  
  652.                 }  
  653.   
  654.                 pw.println("  temperature: " + mBatteryProps.batteryTemperature);  
  655.                 pw.println("  technology: " + mBatteryProps.batteryTechnology);  
  656.             } else if (args.length == 3 && "set".equals(args[0])) {  
  657.                 String key = args[1];  
  658.                 String value = args[2];  
  659.                 try {  
  660.                     boolean update = true;  
  661.                     if ("ac".equals(key)) {  
  662.                         mBatteryProps.chargerAcOnline = Integer.parseInt(value) != 0;  
  663.                     } else if ("usb".equals(key)) {  
  664.                         mBatteryProps.chargerUsbOnline = Integer.parseInt(value) != 0;  
  665.                     } else if ("wireless".equals(key)) {  
  666.                         mBatteryProps.chargerWirelessOnline = Integer.parseInt(value) != 0;  
  667.                     } else if ("status".equals(key)) {  
  668.                         mBatteryProps.batteryStatus = Integer.parseInt(value);  
  669.                     } else if ("level".equals(key)) {  
  670.                         mBatteryProps.batteryLevel = Integer.parseInt(value);  
  671.                     } else if ("invalid".equals(key)) {  
  672.                         mInvalidCharger = Integer.parseInt(value);  
  673.                     } else {  
  674.                         pw.println("Unknown set option: " + key);  
  675.                         update = false;  
  676.                     }  
  677.                     if (update) {  
  678.                         long ident = Binder.clearCallingIdentity();  
  679.                         try {  
  680.                             mUpdatesStopped = true;  
  681.                             processValuesLocked();  
  682.                         } finally {  
  683.                             Binder.restoreCallingIdentity(ident);  
  684.                         }  
  685.                     }  
  686.                 } catch (NumberFormatException ex) {  
  687.                     pw.println("Bad value: " + value);  
  688.                 }  
  689.             } else if (args.length == 1 && "reset".equals(args[0])) {  
  690.                 long ident = Binder.clearCallingIdentity();  
  691.                 try {  
  692.                     mUpdatesStopped = false;  
  693.                 } finally {  
  694.                     Binder.restoreCallingIdentity(ident);  
  695.                 }  
  696.             } else {  
  697.                 pw.println("Dump current battery state, or:");  
  698.                 pw.println("  set ac|usb|wireless|status|level|invalid <value>");  
  699.                 pw.println("  reset");  
  700.             }  
  701.         }  
  702.     }  
  703.   
  704.     private final UEventObserver mInvalidChargerObserver = new UEventObserver() {  
  705.         @Override  
  706.         public void onUEvent(UEventObserver.UEvent event) {  
  707.             final int invalidCharger = "1".equals(event.get("SWITCH_STATE")) ? 1 : 0;  
  708.             synchronized (mLock) {  
  709.                 if (mInvalidCharger != invalidCharger) {  
  710.                     mInvalidCharger = invalidCharger;  
  711.                 }  
  712.             }  
  713.         }  
  714.     };  
  715.   
  716.     private final class Led {  
  717.         private final LightsService.Light mBatteryLight;  
  718.   
  719.         private final int mBatteryLowARGB;  
  720.         private final int mBatteryMediumARGB;  
  721.         private final int mBatteryFullARGB;  
  722.         private final int mBatteryLedOn;  
  723.         private final int mBatteryLedOff;  
  724.   
  725.         public Led(Context context, LightsService lights) {  
  726.             mBatteryLight = lights.getLight(LightsService.LIGHT_ID_BATTERY);  
  727.   
  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.         }  
  739.   
  740.         /** 
  741.          * Synchronize on BatteryService. 
  742.          */  
  743.         public void updateLightsLocked() {  
  744.             final int level = mBatteryProps.batteryLevel;  
  745.             final int status = mBatteryProps.batteryStatus;  
  746.             if (level < mLowBatteryWarningLevel) {  
  747.                 if (status == BatteryManager.BATTERY_STATUS_CHARGING) {  
  748.                     // Solid red when battery is charging  
  749.                     mBatteryLight.setColor(mBatteryLowARGB);  
  750.                 } else {  
  751.                     // Flash red when battery is low and not charging  
  752.                     mBatteryLight.setFlashing(mBatteryLowARGB, LightsService.LIGHT_FLASH_TIMED,  
  753.                             mBatteryLedOn, mBatteryLedOff);  
  754.                 }  
  755.             } else if (status == BatteryManager.BATTERY_STATUS_CHARGING  
  756.                     || status == BatteryManager.BATTERY_STATUS_FULL) {  
  757.                 if (status == BatteryManager.BATTERY_STATUS_FULL || level >= 90) {  
  758.                     // Solid green when full or charging and nearly full  
  759.                     mBatteryLight.setColor(mBatteryFullARGB);  
  760.                 } else {  
  761.                     // Solid orange when charging and halfway full  
  762.                     mBatteryLight.setColor(mBatteryMediumARGB);  
  763.                 }  
  764.             } else {  
  765.                 // No lights if not charging and not low  
  766.                 mBatteryLight.turnOff();  
  767.             }  
  768.         }  
  769.     }  
  770.   
  771.     private final class BatteryListener extends IBatteryPropertiesListener.Stub {  
  772.         public void batteryPropertiesChanged(BatteryProperties props) {  
  773.             BatteryService.this.update(props);  
  774.        }  
  775.     }  
  776. }  
/** Copyright (C) 2006 The Android Open Source Project** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at**      http://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package com.android.server;import android.os.BatteryStats;
import com.android.internal.app.IBatteryStats;
import com.android.server.am.BatteryStatsService;import android.app.ActivityManagerNative;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.BatteryManager;
import android.os.BatteryProperties;
import android.os.Binder;
import android.os.FileUtils;
import android.os.Handler;
import android.os.IBatteryPropertiesListener;
import android.os.IBatteryPropertiesRegistrar;
import android.os.IBinder;
import android.os.DropBoxManager;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.SystemClock;
import android.os.UEventObserver;
import android.os.UserHandle;
import android.provider.Settings;
import android.util.EventLog;
import android.util.Slog;import java.io.File;
import java.io.FileDescriptor;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;/*** <p>BatteryService monitors the charging status, and charge level of the device* battery.  When these values change this service broadcasts the new values* to all {@link android.content.BroadcastReceiver IntentReceivers} that are* watching the {@link android.content.Intent#ACTION_BATTERY_CHANGED* BATTERY_CHANGED} action.</p>* <p>The new values are stored in the Intent data and can be retrieved by* calling {@link android.content.Intent#getExtra Intent.getExtra} with the* following keys:</p>* <p>"scale" - int, the maximum value for the charge level</p>* <p>"level" - int, charge level, from 0 through "scale" inclusive</p>* <p>"status" - String, the current charging status.<br />* <p>"health" - String, the current battery health.<br />* <p>"present" - boolean, true if the battery is present<br />* <p>"icon-small" - int, suggested small icon to use for this state</p>* <p>"plugged" - int, 0 if the device is not plugged in; 1 if plugged* into an AC power adapter; 2 if plugged in via USB.</p>* <p>"voltage" - int, current battery voltage in millivolts</p>* <p>"temperature" - int, current battery temperature in tenths of* a degree Centigrade</p>* <p>"technology" - String, the type of battery installed, e.g. "Li-ion"</p>** <p>* The battery service may be called by the power manager while holding its locks so* we take care to post all outcalls into the activity manager to a handler.** FIXME: Ideally the power manager would perform all of its calls into the battery* service asynchronously itself.* </p>*/
public final class BatteryService extends Binder {private static final String TAG = BatteryService.class.getSimpleName();private static final boolean DEBUG = false;private static final int BATTERY_SCALE = 100;    // battery capacity is a percentage// Used locally for determining when to make a last ditch effort to log// discharge stats before the device dies.private int mCriticalBatteryLevel;private static final int DUMP_MAX_LENGTH = 24 * 1024;private static final String[] DUMPSYS_ARGS = new String[] { "--checkin", "--unplugged" };private static final String DUMPSYS_DATA_PATH = "/data/system/";// This should probably be exposed in the API, though it's not criticalprivate static final int BATTERY_PLUGGED_NONE = 0;private final Context mContext;private final IBatteryStats mBatteryStats;private final Handler mHandler;private final Object mLock = new Object();private BatteryProperties mBatteryProps;private boolean mBatteryLevelCritical;private int mLastBatteryStatus;private int mLastBatteryHealth;private boolean mLastBatteryPresent;private int mLastBatteryLevel;private int mLastBatteryVoltage;private int mLastBatteryTemperature;private boolean mLastBatteryLevelCritical;private int mInvalidCharger;private int mLastInvalidCharger;private int mLowBatteryWarningLevel;private int mLowBatteryCloseWarningLevel;private int mShutdownBatteryTemperature;private int mPlugType;private int mLastPlugType = -1; // Extra state so we can detect first runprivate long mDischargeStartTime;private int mDischargeStartLevel;private boolean mUpdatesStopped;private Led mLed;private boolean mSentLowBatteryBroadcast = false;private BatteryListener mBatteryPropertiesListener;private IBatteryPropertiesRegistrar mBatteryPropertiesRegistrar;
//构造函数public BatteryService(Context context, LightsService lights) {mContext = context;mHandler = new Handler(true /*async*/);mLed = new Led(context, lights);//这个应该是指示灯,没实验mBatteryStats = BatteryStatsService.getService();//低电量临界值,这个数我看的源码版本值是4(在这个类里只是用来写日志)mCriticalBatteryLevel = mContext.getResources().getInteger(com.android.internal.R.integer.config_criticalBatteryWarningLevel);//低电量告警值,值15,下面会根据这个变量发送低电量的广播Intent.ACTION_BATTERY_LOW(这个跟系统低电量提醒没关系,只是发出去了)mLowBatteryWarningLevel = mContext.getResources().getInteger(com.android.internal.R.integer.config_lowBatteryWarningLevel);//电量告警取消值,值20 , 就是手机电量大于等于20的话发送Intent.ACTION_BATTERY_OKAYmLowBatteryCloseWarningLevel = mContext.getResources().getInteger(com.android.internal.R.integer.config_lowBatteryCloseWarningLevel);//值是680 ,温度过高,超过这个值就发送广播,跳转到将要关机提醒。mShutdownBatteryTemperature = mContext.getResources().getInteger(com.android.internal.R.integer.config_shutdownBatteryTemperature);// watch for invalid charger messages if the invalid_charger switch existsif (new File("/sys/devices/virtual/switch/invalid_charger/state").exists()) {mInvalidChargerObserver.startObserving("DEVPATH=/devices/virtual/switch/invalid_charger");}
//电池监听,这个应该是注册到底层去了。当底层电量改变会调用此监听。然后执行update(BatteryProperties props);mBatteryPropertiesListener = new BatteryListener();IBinder b = ServiceManager.getService("batterypropreg");mBatteryPropertiesRegistrar = IBatteryPropertiesRegistrar.Stub.asInterface(b);try {
//这里注册mBatteryPropertiesRegistrar.registerListener(mBatteryPropertiesListener);} catch (RemoteException e) {// Should never happen.}}
//开机后先去看看是否没电了或者温度太高了。如果是,就关机提示(关机提示我等会介绍)。void systemReady() {// check our power situation now that it is safe to display the shutdown dialog.synchronized (mLock) {shutdownIfNoPowerLocked();shutdownIfOverTempLocked();}}
//返回是否在充电,这个函数在PowerManagerService.java 中调用/*** Returns true if the device is plugged into any of the specified plug types.*/public boolean isPowered(int plugTypeSet) {synchronized (mLock) {return isPoweredLocked(plugTypeSet);}}
//就是这里,通过充电器类型判断是否充电private boolean isPoweredLocked(int plugTypeSet) {
//我这英语小白猜着翻译下:就是开机后,电池状态不明了,那我们就认为就在充电,以便设备正常工作。// assume we are powered if battery state is unknown so// the "stay on while plugged in" option will work.if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_UNKNOWN) {return true;}
//充电器if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_AC) != 0 && mBatteryProps.chargerAcOnline) {return true;}
//USB,插电脑上充电if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_USB) != 0 && mBatteryProps.chargerUsbOnline) {return true;}
//电源是无线的。 (我没见过...)if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_WIRELESS) != 0 && mBatteryProps.chargerWirelessOnline) {return true;}return false;}/*** Returns the current plug type.*/
//充电器类型public int getPlugType() {synchronized (mLock) {return mPlugType;}}/*** Returns battery level as a percentage.*/
//电池属性:电量等级(0-100)public int getBatteryLevel() {synchronized (mLock) {return mBatteryProps.batteryLevel;}}/*** Returns true if battery level is below the first warning threshold.*/
//低电量public boolean isBatteryLow() {synchronized (mLock) {return mBatteryProps.batteryPresent && mBatteryProps.batteryLevel <= mLowBatteryWarningLevel;}}/*** Returns a non-zero value if an  unsupported charger is attached.*/
//不支持的充电器类型  public int getInvalidCharger() {synchronized (mLock) {return mInvalidCharger;}}//这里就是没电了,要关机的提示。private void shutdownIfNoPowerLocked() {// shut down gracefully if our battery is critically low and we are not powered.// wait until the system has booted before attempting to display the shutdown dialog.if (mBatteryProps.batteryLevel == 0 && (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_DISCHARGING)) {mHandler.post(new Runnable() {@Overridepublic void run() {if (ActivityManagerNative.isSystemReady()) {Intent intent = new Intent("android.intent.action.ACTION_REQUEST_SHUTDOWN_LOWBATTERY");//ACTION_REQUEST_SHUTDOWNintent.putExtra(Intent.EXTRA_KEY_CONFIRM, false);intent.putExtra("cant_be_cancel_by_button", true);intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);mContext.startActivityAsUser(intent, UserHandle.CURRENT);}}});}}//温度过高,关机提示(个人感觉这里有问题,温度过高为啥子跳转到没电关机提示界面) private void shutdownIfOverTempLocked() {// shut down gracefully if temperature is too high (> 68.0C by default)// wait until the system has booted before attempting to display the// shutdown dialog.if (mBatteryProps.batteryTemperature > mShutdownBatteryTemperature) {mHandler.post(new Runnable() {@Overridepublic void run() {if (ActivityManagerNative.isSystemReady()) {Intent intent = new Intent("android.intent.action.ACTION_REQUEST_SHUTDOWN_LOWBATTERY");//ACTION_REQUEST_SHUTDOWNintent.putExtra(Intent.EXTRA_KEY_CONFIRM, false);intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);mContext.startActivityAsUser(intent, UserHandle.CURRENT);}}});}}
//这个方法就是被JNI回调的。用来更新上层状态的方法。private void update(BatteryProperties props) {synchronized (mLock) {if (!mUpdatesStopped) {mBatteryProps = props;// Process the new values.processValuesLocked();}}}
//嗯。这个就是最主要的方法了。private void processValuesLocked() {boolean logOutlier = false;long dischargeDuration = 0;mBatteryLevelCritical = (mBatteryProps.batteryLevel <= mCriticalBatteryLevel);
//充电器类型 if (mBatteryProps.chargerAcOnline) {mPlugType = BatteryManager.BATTERY_PLUGGED_AC;} else if (mBatteryProps.chargerUsbOnline) {mPlugType = BatteryManager.BATTERY_PLUGGED_USB;} else if (mBatteryProps.chargerWirelessOnline) {mPlugType = BatteryManager.BATTERY_PLUGGED_WIRELESS;} else {mPlugType = BATTERY_PLUGGED_NONE;}if (DEBUG) {//日志,略过Slog.d(TAG, "Processing new values: "+ "chargerAcOnline=" + mBatteryProps.chargerAcOnline+ ", chargerUsbOnline=" + mBatteryProps.chargerUsbOnline+ ", chargerWirelessOnline=" + mBatteryProps.chargerWirelessOnline+ ", batteryStatus=" + mBatteryProps.batteryStatus+ ", batteryHealth=" + mBatteryProps.batteryHealth+ ", batteryPresent=" + mBatteryProps.batteryPresent+ ", batteryLevel=" + mBatteryProps.batteryLevel+ ", batteryTechnology=" + mBatteryProps.batteryTechnology+ ", batteryVoltage=" + mBatteryProps.batteryVoltage+ ", batteryCurrentNow=" + mBatteryProps.batteryCurrentNow+ ", batteryChargeCounter=" + mBatteryProps.batteryChargeCounter+ ", batteryTemperature=" + mBatteryProps.batteryTemperature+ ", mBatteryLevelCritical=" + mBatteryLevelCritical+ ", mPlugType=" + mPlugType);}// Let the battery stats keep track of the current level.try {
//把电池属性放到状态里面mBatteryStats.setBatteryState(mBatteryProps.batteryStatus, mBatteryProps.batteryHealth,mPlugType, mBatteryProps.batteryLevel, mBatteryProps.batteryTemperature,mBatteryProps.batteryVoltage);} catch (RemoteException e) {// Should never happen.}
//没电了shutdownIfNoPowerLocked();
//温度过高了shutdownIfOverTempLocked();if (mBatteryProps.batteryStatus != mLastBatteryStatus ||mBatteryProps.batteryHealth != mLastBatteryHealth ||mBatteryProps.batteryPresent != mLastBatteryPresent ||mBatteryProps.batteryLevel != mLastBatteryLevel ||mPlugType != mLastPlugType ||mBatteryProps.batteryVoltage != mLastBatteryVoltage ||mBatteryProps.batteryTemperature != mLastBatteryTemperature ||mInvalidCharger != mLastInvalidCharger) {if (mPlugType != mLastPlugType) {//当前充电器类型与上次的不一样
//并且上次充电器类型是no one ,那就可以知道,现在是插上充电器了。if (mLastPlugType == BATTERY_PLUGGED_NONE) {// discharging -> charging// There's no value in this data unless we've discharged at least once and the// battery level has changed; so don't log until it does.if (mDischargeStartTime != 0 && mDischargeStartLevel != mBatteryProps.batteryLevel) {dischargeDuration = SystemClock.elapsedRealtime() - mDischargeStartTime;logOutlier = true;EventLog.writeEvent(EventLogTags.BATTERY_DISCHARGE, dischargeDuration,mDischargeStartLevel, mBatteryProps.batteryLevel);// make sure we see a discharge event before logging againmDischargeStartTime = 0;}
//并且本次充电器类型是no one ,那就可以知道,现在是拔掉充电器了。} else if (mPlugType == BATTERY_PLUGGED_NONE) {// charging -> discharging or we just powered upmDischargeStartTime = SystemClock.elapsedRealtime();mDischargeStartLevel = mBatteryProps.batteryLevel;}}if (mBatteryProps.batteryStatus != mLastBatteryStatus ||//写日志,略过mBatteryProps.batteryHealth != mLastBatteryHealth ||mBatteryProps.batteryPresent != mLastBatteryPresent ||mPlugType != mLastPlugType) {EventLog.writeEvent(EventLogTags.BATTERY_STATUS,mBatteryProps.batteryStatus, mBatteryProps.batteryHealth, mBatteryProps.batteryPresent ? 1 : 0,mPlugType, mBatteryProps.batteryTechnology);}if (mBatteryProps.batteryLevel != mLastBatteryLevel) {// Don't do this just from voltage or temperature changes, that is// too noisy.EventLog.writeEvent(EventLogTags.BATTERY_LEVEL,mBatteryProps.batteryLevel, mBatteryProps.batteryVoltage, mBatteryProps.batteryTemperature);}if (mBatteryLevelCritical && !mLastBatteryLevelCritical &&mPlugType == BATTERY_PLUGGED_NONE) {// We want to make sure we log discharge cycle outliers// if the battery is about to die.dischargeDuration = SystemClock.elapsedRealtime() - mDischargeStartTime;logOutlier = true;}
//本次调用,当前的充电状态final boolean plugged = mPlugType != BATTERY_PLUGGED_NONE;
//本次调用,上次调用的充电状态  final boolean oldPlugged = mLastPlugType != BATTERY_PLUGGED_NONE;/* The ACTION_BATTERY_LOW broadcast is sent in these situations:* - is just un-plugged (previously was plugged) and battery level is*   less than or equal to WARNING, or* - is not plugged and battery level falls to WARNING boundary*   (becomes <= mLowBatteryWarningLevel).*/
//用于发送低电量广播的判断final boolean sendBatteryLow = !plugged//(按sendBatteryLow = true 来说) 当前没有充电&& mBatteryProps.batteryStatus != BatteryManager.BATTERY_STATUS_UNKNOWN//充电状态不是UNKNOWN&& mBatteryProps.batteryLevel <= mLowBatteryWarningLevel//当前电量小于告警值 15&& (oldPlugged || mLastBatteryLevel > mLowBatteryWarningLevel);//上次状态是充电或者上次电量等级大于告警值 15sendIntentLocked();//发送电池电量改变的广播Intent.ACTION_BATTERY_CHANGED// Separate broadcast is sent for power connected / not connected// since the standard intent will not wake any applications and some// applications may want to have smart behavior based on this.if (mPlugType != 0 && mLastPlugType == 0) {//插上充电器了mHandler.post(new Runnable() {@Overridepublic void run() {Intent statusIntent = new Intent(Intent.ACTION_POWER_CONNECTED);statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);}});}else if (mPlugType == 0 && mLastPlugType != 0) {//断开充电器了mHandler.post(new Runnable() {@Overridepublic void run() {Intent statusIntent = new Intent(Intent.ACTION_POWER_DISCONNECTED);statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);}});}
//发送低电量提醒(这个跟系统低电量提醒没关系,只是发出去了)if (sendBatteryLow) {mSentLowBatteryBroadcast = true;mHandler.post(new Runnable() {@Overridepublic void run() {Intent statusIntent = new Intent(Intent.ACTION_BATTERY_LOW);statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);}});} else if (mSentLowBatteryBroadcast && mLastBatteryLevel >= mLowBatteryCloseWarningLevel) {//电量超过20了。电池状态OK了mSentLowBatteryBroadcast = false;mHandler.post(new Runnable() {@Overridepublic void run() {Intent statusIntent = new Intent(Intent.ACTION_BATTERY_OKAY);statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);}});}// Update the battery LEDmLed.updateLightsLocked();// This needs to be done after sendIntent() so that we get the lastest battery stats.if (logOutlier && dischargeDuration != 0) {logOutlierLocked(dischargeDuration);}mLastBatteryStatus = mBatteryProps.batteryStatus;mLastBatteryHealth = mBatteryProps.batteryHealth;mLastBatteryPresent = mBatteryProps.batteryPresent;mLastBatteryLevel = mBatteryProps.batteryLevel;mLastPlugType = mPlugType;mLastBatteryVoltage = mBatteryProps.batteryVoltage;mLastBatteryTemperature = mBatteryProps.batteryTemperature;mLastBatteryLevelCritical = mBatteryLevelCritical;mLastInvalidCharger = mInvalidCharger;}}
//电池电量改变,把属性发出去(系统低电量提醒接收的是这个广播)private void sendIntentLocked() {//  Pack up the values and broadcast them to everyonefinal Intent intent = new Intent(Intent.ACTION_BATTERY_CHANGED);intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY| Intent.FLAG_RECEIVER_REPLACE_PENDING);int icon = getIconLocked(mBatteryProps.batteryLevel);intent.putExtra(BatteryManager.EXTRA_STATUS, mBatteryProps.batteryStatus);intent.putExtra(BatteryManager.EXTRA_HEALTH, mBatteryProps.batteryHealth);intent.putExtra(BatteryManager.EXTRA_PRESENT, mBatteryProps.batteryPresent);intent.putExtra(BatteryManager.EXTRA_LEVEL, mBatteryProps.batteryLevel);intent.putExtra(BatteryManager.EXTRA_SCALE, BATTERY_SCALE);intent.putExtra(BatteryManager.EXTRA_ICON_SMALL, icon);intent.putExtra(BatteryManager.EXTRA_PLUGGED, mPlugType);intent.putExtra(BatteryManager.EXTRA_VOLTAGE, mBatteryProps.batteryVoltage);intent.putExtra(BatteryManager.EXTRA_TEMPERATURE, mBatteryProps.batteryTemperature);intent.putExtra(BatteryManager.EXTRA_TECHNOLOGY, mBatteryProps.batteryTechnology);intent.putExtra(BatteryManager.EXTRA_INVALID_CHARGER, mInvalidCharger);if (DEBUG) {Slog.d(TAG, "Sending ACTION_BATTERY_CHANGED.  level:" + mBatteryProps.batteryLevel +", scale:" + BATTERY_SCALE + ", status:" + mBatteryProps.batteryStatus +", health:" + mBatteryProps.batteryHealth +  ", present:" + mBatteryProps.batteryPresent +", voltage: " + mBatteryProps.batteryVoltage +", temperature: " + mBatteryProps.batteryTemperature +", technology: " + mBatteryProps.batteryTechnology +", AC powered:" + mBatteryProps.chargerAcOnline + ", USB powered:" + mBatteryProps.chargerUsbOnline +", Wireless powered:" + mBatteryProps.chargerWirelessOnline +", icon:" + icon  + ", invalid charger:" + mInvalidCharger);}mHandler.post(new Runnable() {@Overridepublic void run() {ActivityManagerNative.broadcastStickyIntent(intent, null, UserHandle.USER_ALL);}});}private void logBatteryStatsLocked() {IBinder batteryInfoService = ServiceManager.getService(BatteryStats.SERVICE_NAME);if (batteryInfoService == null) return;DropBoxManager db = (DropBoxManager) mContext.getSystemService(Context.DROPBOX_SERVICE);if (db == null || !db.isTagEnabled("BATTERY_DISCHARGE_INFO")) return;File dumpFile = null;FileOutputStream dumpStream = null;try {// dump the service to a filedumpFile = new File(DUMPSYS_DATA_PATH + BatteryStats.SERVICE_NAME + ".dump");dumpStream = new FileOutputStream(dumpFile);batteryInfoService.dump(dumpStream.getFD(), DUMPSYS_ARGS);FileUtils.sync(dumpStream);// add dump file to drop boxdb.addFile("BATTERY_DISCHARGE_INFO", dumpFile, DropBoxManager.IS_TEXT);} catch (RemoteException e) {Slog.e(TAG, "failed to dump battery service", e);} catch (IOException e) {Slog.e(TAG, "failed to write dumpsys file", e);} finally {// make sure we clean upif (dumpStream != null) {try {dumpStream.close();} catch (IOException e) {Slog.e(TAG, "failed to close dumpsys output stream");}}if (dumpFile != null && !dumpFile.delete()) {Slog.e(TAG, "failed to delete temporary dumpsys file: "+ dumpFile.getAbsolutePath());}}}private void logOutlierLocked(long duration) {ContentResolver cr = mContext.getContentResolver();String dischargeThresholdString = Settings.Global.getString(cr,Settings.Global.BATTERY_DISCHARGE_THRESHOLD);String durationThresholdString = Settings.Global.getString(cr,Settings.Global.BATTERY_DISCHARGE_DURATION_THRESHOLD);if (dischargeThresholdString != null && durationThresholdString != null) {try {long durationThreshold = Long.parseLong(durationThresholdString);int dischargeThreshold = Integer.parseInt(dischargeThresholdString);if (duration <= durationThreshold &&mDischargeStartLevel - mBatteryProps.batteryLevel >= dischargeThreshold) {// If the discharge cycle is bad enough we want to know about it.logBatteryStatsLocked();}if (DEBUG) Slog.v(TAG, "duration threshold: " + durationThreshold +" discharge threshold: " + dischargeThreshold);if (DEBUG) Slog.v(TAG, "duration: " + duration + " discharge: " +(mDischargeStartLevel - mBatteryProps.batteryLevel));} catch (NumberFormatException e) {Slog.e(TAG, "Invalid DischargeThresholds GService string: " +durationThresholdString + " or " + dischargeThresholdString);return;}}}private int getIconLocked(int level) {if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_CHARGING) {return com.android.internal.R.drawable.stat_sys_battery_charge;} else if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_DISCHARGING) {return com.android.internal.R.drawable.stat_sys_battery;} else if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_NOT_CHARGING|| mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_FULL) {if (isPoweredLocked(BatteryManager.BATTERY_PLUGGED_ANY)&& mBatteryProps.batteryLevel >= 100) {return com.android.internal.R.drawable.stat_sys_battery_charge;} else {return com.android.internal.R.drawable.stat_sys_battery;}} else {return com.android.internal.R.drawable.stat_sys_battery_unknown;}}@Overrideprotected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)!= PackageManager.PERMISSION_GRANTED) {pw.println("Permission Denial: can't dump Battery service from from pid="+ Binder.getCallingPid()+ ", uid=" + Binder.getCallingUid());return;}synchronized (mLock) {if (args == null || args.length == 0 || "-a".equals(args[0])) {pw.println("Current Battery Service state:");if (mUpdatesStopped) {pw.println("  (UPDATES STOPPED -- use 'reset' to restart)");}pw.println("  AC powered: " + mBatteryProps.chargerAcOnline);pw.println("  USB powered: " + mBatteryProps.chargerUsbOnline);pw.println("  Wireless powered: " + mBatteryProps.chargerWirelessOnline);pw.println("  status: " + mBatteryProps.batteryStatus);pw.println("  health: " + mBatteryProps.batteryHealth);pw.println("  present: " + mBatteryProps.batteryPresent);pw.println("  level: " + mBatteryProps.batteryLevel);pw.println("  scale: " + BATTERY_SCALE);pw.println("  voltage: " + mBatteryProps.batteryVoltage);if (mBatteryProps.batteryCurrentNow != Integer.MIN_VALUE) {pw.println("  current now: " + mBatteryProps.batteryCurrentNow);}if (mBatteryProps.batteryChargeCounter != Integer.MIN_VALUE) {pw.println("  charge counter: " + mBatteryProps.batteryChargeCounter);}pw.println("  temperature: " + mBatteryProps.batteryTemperature);pw.println("  technology: " + mBatteryProps.batteryTechnology);} else if (args.length == 3 && "set".equals(args[0])) {String key = args[1];String value = args[2];try {boolean update = true;if ("ac".equals(key)) {mBatteryProps.chargerAcOnline = Integer.parseInt(value) != 0;} else if ("usb".equals(key)) {mBatteryProps.chargerUsbOnline = Integer.parseInt(value) != 0;} else if ("wireless".equals(key)) {mBatteryProps.chargerWirelessOnline = Integer.parseInt(value) != 0;} else if ("status".equals(key)) {mBatteryProps.batteryStatus = Integer.parseInt(value);} else if ("level".equals(key)) {mBatteryProps.batteryLevel = Integer.parseInt(value);} else if ("invalid".equals(key)) {mInvalidCharger = Integer.parseInt(value);} else {pw.println("Unknown set option: " + key);update = false;}if (update) {long ident = Binder.clearCallingIdentity();try {mUpdatesStopped = true;processValuesLocked();} finally {Binder.restoreCallingIdentity(ident);}}} catch (NumberFormatException ex) {pw.println("Bad value: " + value);}} else if (args.length == 1 && "reset".equals(args[0])) {long ident = Binder.clearCallingIdentity();try {mUpdatesStopped = false;} finally {Binder.restoreCallingIdentity(ident);}} else {pw.println("Dump current battery state, or:");pw.println("  set ac|usb|wireless|status|level|invalid <value>");pw.println("  reset");}}}private final UEventObserver mInvalidChargerObserver = new UEventObserver() {@Overridepublic void onUEvent(UEventObserver.UEvent event) {final int invalidCharger = "1".equals(event.get("SWITCH_STATE")) ? 1 : 0;synchronized (mLock) {if (mInvalidCharger != invalidCharger) {mInvalidCharger = invalidCharger;}}}};private final class Led {private final LightsService.Light mBatteryLight;private final int mBatteryLowARGB;private final int mBatteryMediumARGB;private final int mBatteryFullARGB;private final int mBatteryLedOn;private final int mBatteryLedOff;public Led(Context context, LightsService lights) {mBatteryLight = lights.getLight(LightsService.LIGHT_ID_BATTERY);mBatteryLowARGB = context.getResources().getInteger(com.android.internal.R.integer.config_notificationsBatteryLowARGB);mBatteryMediumARGB = context.getResources().getInteger(com.android.internal.R.integer.config_notificationsBatteryMediumARGB);mBatteryFullARGB = context.getResources().getInteger(com.android.internal.R.integer.config_notificationsBatteryFullARGB);mBatteryLedOn = context.getResources().getInteger(com.android.internal.R.integer.config_notificationsBatteryLedOn);mBatteryLedOff = context.getResources().getInteger(com.android.internal.R.integer.config_notificationsBatteryLedOff);}/*** Synchronize on BatteryService.*/public void updateLightsLocked() {final int level = mBatteryProps.batteryLevel;final int status = mBatteryProps.batteryStatus;if (level < mLowBatteryWarningLevel) {if (status == BatteryManager.BATTERY_STATUS_CHARGING) {// Solid red when battery is chargingmBatteryLight.setColor(mBatteryLowARGB);} else {// Flash red when battery is low and not chargingmBatteryLight.setFlashing(mBatteryLowARGB, LightsService.LIGHT_FLASH_TIMED,mBatteryLedOn, mBatteryLedOff);}} else if (status == BatteryManager.BATTERY_STATUS_CHARGING|| status == BatteryManager.BATTERY_STATUS_FULL) {if (status == BatteryManager.BATTERY_STATUS_FULL || level >= 90) {// Solid green when full or charging and nearly fullmBatteryLight.setColor(mBatteryFullARGB);} else {// Solid orange when charging and halfway fullmBatteryLight.setColor(mBatteryMediumARGB);}} else {// No lights if not charging and not lowmBatteryLight.turnOff();}}}private final class BatteryListener extends IBatteryPropertiesListener.Stub {public void batteryPropertiesChanged(BatteryProperties props) {BatteryService.this.update(props);}}
}




 

总结如下:此服务构造时会注册监听到系统JNI层。 当电池电量改变的时候会调用update(BatteryProperties props) -----》processValuesLocked() 。 而processValuesLocked() 函数会把电池状态把广播发送出去。其他类再接收广播进行处理

下一个类就是低电量提醒了,文件目录:\frameworks\base\packages\SystemUI\src\com\android\systemui\power\PowerUI.java

[java] view plain copy print ?
  1. /* 
  2.  * Copyright (C) 2008 The Android Open Source Project 
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License"); 
  5.  * you may not use this file except in compliance with the License. 
  6.  * You may obtain a copy of the License at 
  7.  * 
  8.  *      http://www.apache.org/licenses/LICENSE-2.0 
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software 
  11.  * distributed under the License is distributed on an "AS IS" BASIS, 
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  13.  * See the License for the specific language governing permissions and 
  14.  * limitations under the License. 
  15.  */  
  16.   
  17. package com.android.systemui.power;  
  18.   
  19. import android.app.AlertDialog;  
  20. import android.content.BroadcastReceiver;  
  21. import android.content.ContentResolver;  
  22. import android.content.Context;  
  23. import android.content.DialogInterface;  
  24. import android.content.Intent;  
  25. import android.content.IntentFilter;  
  26. import android.media.AudioManager;  
  27. import android.media.Ringtone;  
  28. import android.media.RingtoneManager;  
  29. import android.net.Uri;  
  30. import android.os.BatteryManager;  
  31. import android.os.Handler;  
  32. import android.os.PowerManager;  
  33. import android.os.SystemClock;  
  34. import android.os.UserHandle;  
  35. import android.provider.Settings;  
  36. import android.util.Slog;  
  37. import android.view.View;  
  38. import android.view.WindowManager;  
  39. import android.widget.TextView;  
  40.   
  41. import com.android.systemui.R;  
  42. import com.android.systemui.SystemUI;  
  43.   
  44. import java.io.FileDescriptor;  
  45. import java.io.PrintWriter;  
  46. import java.util.Arrays;  
  47.   
  48. public class PowerUI extends SystemUI { //总体说一下,这里才是处理低电量提醒的地方,他接收的广播是Intent.ACTION_BATTERY_CHANGED  
  49.     static final String TAG = "PowerUI";  
  50.   
  51.     static final boolean DEBUG = false;  
  52.   
  53.     Handler mHandler = new Handler();  
  54.   
  55.     int mBatteryLevel = 100;  
  56.     int mBatteryStatus = BatteryManager.BATTERY_STATUS_UNKNOWN;  
  57.     int mPlugType = 0;  
  58.     int mInvalidCharger = 0;  
  59.   
  60.     int mLowBatteryAlertCloseLevel;  
  61.     int[] mLowBatteryReminderLevels = new int[2];  
  62.   
  63.     AlertDialog mInvalidChargerDialog;  
  64.     AlertDialog mLowBatteryDialog;  
  65.     TextView mBatteryLevelTextView;  
  66.   
  67.     private long mScreenOffTime = -1;  
  68.   
  69.     public void start() {  //这个类会在手机启动后,在SystemUI 里启动(就是系统界面)。  
  70.   
  71.         mLowBatteryAlertCloseLevel = mContext.getResources().getInteger( //电量告警取消值,值20   
  72.                 com.android.internal.R.integer.config_lowBatteryCloseWarningLevel);  
  73.         mLowBatteryReminderLevels[0] = mContext.getResources().getInteger( //低电量提醒 15  
  74.                 com.android.internal.R.integer.config_lowBatteryWarningLevel);  
  75.         mLowBatteryReminderLevels[1] = mContext.getResources().getInteger( //低电量临界值 4  
  76.                 com.android.internal.R.integer.config_criticalBatteryWarningLevel);  
  77.   
  78.         final PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);  
  79.         mScreenOffTime = pm.isScreenOn() ? -1 : SystemClock.elapsedRealtime();  
  80.   
  81.         // Register for Intent broadcasts for...  
  82.         IntentFilter filter = new IntentFilter();  
  83.         filter.addAction(Intent.ACTION_BATTERY_CHANGED);  
  84.         filter.addAction(Intent.ACTION_SCREEN_OFF);  
  85.         filter.addAction(Intent.ACTION_SCREEN_ON);  
  86.         mContext.registerReceiver(mIntentReceiver, filter, null, mHandler);  
  87.     }  
  88.   
  89.     /** 
  90.      * Buckets the battery level. 
  91.      * 
  92.      * The code in this function is a little weird because I couldn't comprehend 
  93.      * the bucket going up when the battery level was going down. --joeo 
  94.      * 
  95.      * 1 means that the battery is "ok" 
  96.      * 0 means that the battery is between "ok" and what we should warn about. 
  97.      * less than 0 means that the battery is low 
  98.      */  
  99.     private int findBatteryLevelBucket(int level) {   //这个方法是用来警告判断用的。  
  100.         if (level >= mLowBatteryAlertCloseLevel) {  
  101.             return 1;  
  102.         }  
  103.         if (level >= mLowBatteryReminderLevels[0]) {  
  104.             return 0;  
  105.         }  
  106.         final int N = mLowBatteryReminderLevels.length;  
  107.         for (int i=N-1; i>=0; i--) {  
  108.             if (level <= mLowBatteryReminderLevels[i]) {  
  109.                 return -1-i;  
  110.             }  
  111.         }  
  112.         throw new RuntimeException("not possible!");  
  113.     }  
  114.   
  115.     private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() { //重点,广播接收处理  
  116.         @Override  
  117.         public void onReceive(Context context, Intent intent) {  
  118.             String action = intent.getAction();  
  119.             if (action.equals(Intent.ACTION_BATTERY_CHANGED)) {  //电池电量改变  
  120.                 final int oldBatteryLevel = mBatteryLevel; //下边就是根据Intent获取BatteryService传过来的电池属性  
  121.                 mBatteryLevel = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, 100); /  
  122.                 final int oldBatteryStatus = mBatteryStatus;  
  123.                 mBatteryStatus = intent.getIntExtra(BatteryManager.EXTRA_STATUS,  
  124.                         BatteryManager.BATTERY_STATUS_UNKNOWN);  
  125.                 final int oldPlugType = mPlugType;  
  126.                 mPlugType = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 1);  
  127.                 final int oldInvalidCharger = mInvalidCharger;  
  128.                 mInvalidCharger = intent.getIntExtra(BatteryManager.EXTRA_INVALID_CHARGER, 0);  
  129.   
  130.                 final boolean plugged = mPlugType != 0;  
  131.                 final boolean oldPlugged = oldPlugType != 0;  
  132.   
  133.                 int oldBucket = findBatteryLevelBucket(oldBatteryLevel); //这两个值特别有意思,就是说记录下老的电量,记录一下新的电量,比较电量是增加了,还是减小了  
  134.                 int bucket = findBatteryLevelBucket(mBatteryLevel);  
  135.   
  136.                 if (DEBUG) {  
  137.                     Slog.d(TAG, "buckets   ....." + mLowBatteryAlertCloseLevel  
  138.                             + " .. " + mLowBatteryReminderLevels[0]  
  139.                             + " .. " + mLowBatteryReminderLevels[1]);  
  140.                     Slog.d(TAG, "level          " + oldBatteryLevel + " --> " + mBatteryLevel);  
  141.                     Slog.d(TAG, "status         " + oldBatteryStatus + " --> " + mBatteryStatus);  
  142.                     Slog.d(TAG, "plugType       " + oldPlugType + " --> " + mPlugType);  
  143.                     Slog.d(TAG, "invalidCharger " + oldInvalidCharger + " --> " + mInvalidCharger);  
  144.                     Slog.d(TAG, "bucket         " + oldBucket + " --> " + bucket);  
  145.                     Slog.d(TAG, "plugged        " + oldPlugged + " --> " + plugged);  
  146.                 }  
  147.   
  148.                 if (oldInvalidCharger == 0 && mInvalidCharger != 0) {  
  149.                     Slog.d(TAG, "showing invalid charger warning");  
  150.                     showInvalidChargerDialog(); //就是充电器不识别的弹窗  
  151.                     return;  
  152.                 } else if (oldInvalidCharger != 0 && mInvalidCharger == 0) {  
  153.                     dismissInvalidChargerDialog();  
  154.                 } else if (mInvalidChargerDialog != null) {  
  155.                     // if invalid charger is showing, don't show low battery  
  156.                     return;  
  157.                 }  
  158.   
  159.                 if (!plugged  
  160.                         && (bucket < oldBucket || oldPlugged)  
  161.                         && mBatteryStatus != BatteryManager.BATTERY_STATUS_UNKNOWN  
  162.                         && bucket < 0) {  
  163.                     showLowBatteryWarning(); <span style="color:#FF0000;">//这里哈,低电量提醒的弹窗</span>  
  164.   
  165.                     // only play SFX when the dialog comes up or the bucket changes  
  166.                     if (bucket != oldBucket || oldPlugged) {  
  167.                         playLowBatterySound();  
  168.                     }  
  169.                 } else if (plugged || (bucket > oldBucket && bucket > 0)) { //插上充电器或者充电电池电量超过20取消弹窗  
  170.                     dismissLowBatteryWarning();  
  171.                 } else if (mBatteryLevelTextView != null) {  
  172.                     showLowBatteryWarning();  
  173.                 }  
  174.             } else if (Intent.ACTION_SCREEN_OFF.equals(action)) {  
  175.                 mScreenOffTime = SystemClock.elapsedRealtime();  
  176.             } else if (Intent.ACTION_SCREEN_ON.equals(action)) {  
  177.                 mScreenOffTime = -1;  
  178.             } else {  
  179.                 Slog.w(TAG, "unknown intent: " + intent);  
  180.             }  
  181.         }  
  182.     };  
  183.   
  184.     void dismissLowBatteryWarning() {  
  185.         if (mLowBatteryDialog != null) {  
  186.             Slog.i(TAG, "closing low battery warning: level=" + mBatteryLevel);  
  187.             mLowBatteryDialog.dismiss();  
  188.         }  
  189.     }  
  190.   
  191.     void showLowBatteryWarning() {  
  192.         Slog.i(TAG,  
  193.                 ((mBatteryLevelTextView == null) ? "showing" : "updating")  
  194.                 + " low battery warning: level=" + mBatteryLevel  
  195.                 + " [" + findBatteryLevelBucket(mBatteryLevel) + "]");  
  196.   
  197.         CharSequence levelText = mContext.getString(  
  198.                 R.string.battery_low_percent_format, mBatteryLevel);  
  199.   
  200.         if (mBatteryLevelTextView != null) {  
  201.             mBatteryLevelTextView.setText(levelText);  
  202.         } else {  
  203.             View v = View.inflate(mContext, R.layout.battery_low, null);  
  204.             mBatteryLevelTextView = (TextView)v.findViewById(R.id.level_percent);  
  205.   
  206.             mBatteryLevelTextView.setText(levelText);  
  207.   
  208.             AlertDialog.Builder b = new AlertDialog.Builder(mContext);  
  209.                 b.setCancelable(true);  
  210.                 b.setTitle(R.string.battery_low_title);  
  211.                 b.setView(v);  
  212.                 b.setIconAttribute(android.R.attr.alertDialogIcon);  
  213.                 b.setPositiveButton(android.R.string.ok, null);  
  214.   
  215.             final Intent intent = new Intent(Intent.ACTION_POWER_USAGE_SUMMARY);  
  216.             intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK  
  217.                     | Intent.FLAG_ACTIVITY_MULTIPLE_TASK  
  218.                     | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS  
  219.                     | Intent.FLAG_ACTIVITY_NO_HISTORY);  
  220.             if (intent.resolveActivity(mContext.getPackageManager()) != null) {  
  221.                 b.setNegativeButton(R.string.battery_low_why,  
  222.                         new DialogInterface.OnClickListener() {  
  223.                     @Override  
  224.                     public void onClick(DialogInterface dialog, int which) {  
  225.                         mContext.startActivityAsUser(intent, UserHandle.CURRENT);  
  226.                         dismissLowBatteryWarning();  
  227.                     }  
  228.                 });  
  229.             }  
  230.   
  231.             AlertDialog d = b.create();  
  232.             d.setOnDismissListener(new DialogInterface.OnDismissListener() {  
  233.                     @Override  
  234.                     public void onDismiss(DialogInterface dialog) {  
  235.                         mLowBatteryDialog = null;  
  236.                         mBatteryLevelTextView = null;  
  237.                     }  
  238.                 });  
  239.             d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);  
  240.             d.getWindow().getAttributes().privateFlags |=  
  241.                     WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS;  
  242.             d.show();  
  243.             mLowBatteryDialog = d;  
  244.         }  
  245.     }  
  246.   
  247.     void playLowBatterySound() {  
  248.         final ContentResolver cr = mContext.getContentResolver();  
  249.   
  250.         final int silenceAfter = Settings.Global.getInt(cr,  
  251.                 Settings.Global.LOW_BATTERY_SOUND_TIMEOUT, 0);  
  252.         final long offTime = SystemClock.elapsedRealtime() - mScreenOffTime;  
  253.         if (silenceAfter > 0  
  254.                 && mScreenOffTime > 0  
  255.                 && offTime > silenceAfter) {  
  256.             Slog.i(TAG, "screen off too long (" + offTime + "ms, limit " + silenceAfter  
  257.                     + "ms): not waking up the user with low battery sound");  
  258.             return;  
  259.         }  
  260.   
  261.         if (DEBUG) {  
  262.             Slog.d(TAG, "playing low battery sound. pick-a-doop!"); // WOMP-WOMP is deprecated  
  263.         }  
  264.   
  265.         if (Settings.Global.getInt(cr, Settings.Global.POWER_SOUNDS_ENABLED, 1) == 1) {  
  266.             final String soundPath = Settings.Global.getString(cr,  
  267.                     Settings.Global.LOW_BATTERY_SOUND);  
  268.             if (soundPath != null) {  
  269.                 final Uri soundUri = Uri.parse("file://" + soundPath);  
  270.                 if (soundUri != null) {  
  271.                     final Ringtone sfx = RingtoneManager.getRingtone(mContext, soundUri);  
  272.                     if (sfx != null) {  
  273.                         sfx.setStreamType(AudioManager.STREAM_SYSTEM);  
  274.                         sfx.play();  
  275.                     }  
  276.                 }  
  277.             }  
  278.         }  
  279.     }  
  280.   
  281.     void dismissInvalidChargerDialog() {  
  282.         if (mInvalidChargerDialog != null) {  
  283.             mInvalidChargerDialog.dismiss();  
  284.         }  
  285.     }  
  286.   
  287.     void showInvalidChargerDialog() {  
  288.         Slog.d(TAG, "showing invalid charger dialog");  
  289.   
  290.         dismissLowBatteryWarning();  
  291.   
  292.         AlertDialog.Builder b = new AlertDialog.Builder(mContext);  
  293.             b.setCancelable(true);  
  294.             b.setMessage(R.string.invalid_charger);  
  295.             b.setIconAttribute(android.R.attr.alertDialogIcon);  
  296.             b.setPositiveButton(android.R.string.ok, null);  
  297.   
  298.         AlertDialog d = b.create();  
  299.             d.setOnDismissListener(new DialogInterface.OnDismissListener() {  
  300.                     public void onDismiss(DialogInterface dialog) {  
  301.                         mInvalidChargerDialog = null;  
  302.                         mBatteryLevelTextView = null;  
  303.                     }  
  304.                 });  
  305.   
  306.         d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);  
  307.         d.show();  
  308.         mInvalidChargerDialog = d;  
  309.     }  
  310.   
  311.     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {  
  312.         pw.print("mLowBatteryAlertCloseLevel=");  
  313.         pw.println(mLowBatteryAlertCloseLevel);  
  314.         pw.print("mLowBatteryReminderLevels=");  
  315.         pw.println(Arrays.toString(mLowBatteryReminderLevels));  
  316.         pw.print("mInvalidChargerDialog=");  
  317.         pw.println(mInvalidChargerDialog == null ? "null" : mInvalidChargerDialog.toString());  
  318.         pw.print("mLowBatteryDialog=");  
  319.         pw.println(mLowBatteryDialog == null ? "null" : mLowBatteryDialog.toString());  
  320.         pw.print("mBatteryLevel=");  
  321.         pw.println(Integer.toString(mBatteryLevel));  
  322.         pw.print("mBatteryStatus=");  
  323.         pw.println(Integer.toString(mBatteryStatus));  
  324.         pw.print("mPlugType=");  
  325.         pw.println(Integer.toString(mPlugType));  
  326.         pw.print("mInvalidCharger=");  
  327.         pw.println(Integer.toString(mInvalidCharger));  
  328.         pw.print("mScreenOffTime=");  
  329.         pw.print(mScreenOffTime);  
  330.         if (mScreenOffTime >= 0) {  
  331.             pw.print(" (");  
  332.             pw.print(SystemClock.elapsedRealtime() - mScreenOffTime);  
  333.             pw.print(" ago)");  
  334.         }  
  335.         pw.println();  
  336.         pw.print("soundTimeout=");  
  337.         pw.println(Settings.Global.getInt(mContext.getContentResolver(),  
  338.                 Settings.Global.LOW_BATTERY_SOUND_TIMEOUT, 0));  
  339.         pw.print("bucket: ");  
  340.         pw.println(Integer.toString(findBatteryLevelBucket(mBatteryLevel)));  
  341.     }  
  342. }  
/** Copyright (C) 2008 The Android Open Source Project** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at**      http://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package com.android.systemui.power;import android.app.AlertDialog;
import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.media.AudioManager;
import android.media.Ringtone;
import android.media.RingtoneManager;
import android.net.Uri;
import android.os.BatteryManager;
import android.os.Handler;
import android.os.PowerManager;
import android.os.SystemClock;
import android.os.UserHandle;
import android.provider.Settings;
import android.util.Slog;
import android.view.View;
import android.view.WindowManager;
import android.widget.TextView;import com.android.systemui.R;
import com.android.systemui.SystemUI;import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.Arrays;public class PowerUI extends SystemUI { //总体说一下,这里才是处理低电量提醒的地方,他接收的广播是Intent.ACTION_BATTERY_CHANGEDstatic final String TAG = "PowerUI";static final boolean DEBUG = false;Handler mHandler = new Handler();int mBatteryLevel = 100;int mBatteryStatus = BatteryManager.BATTERY_STATUS_UNKNOWN;int mPlugType = 0;int mInvalidCharger = 0;int mLowBatteryAlertCloseLevel;int[] mLowBatteryReminderLevels = new int[2];AlertDialog mInvalidChargerDialog;AlertDialog mLowBatteryDialog;TextView mBatteryLevelTextView;private long mScreenOffTime = -1;public void start() {  //这个类会在手机启动后,在SystemUI 里启动(就是系统界面)。mLowBatteryAlertCloseLevel = mContext.getResources().getInteger( //电量告警取消值,值20 com.android.internal.R.integer.config_lowBatteryCloseWarningLevel);mLowBatteryReminderLevels[0] = mContext.getResources().getInteger( //低电量提醒 15com.android.internal.R.integer.config_lowBatteryWarningLevel);mLowBatteryReminderLevels[1] = mContext.getResources().getInteger( //低电量临界值 4com.android.internal.R.integer.config_criticalBatteryWarningLevel);final PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);mScreenOffTime = pm.isScreenOn() ? -1 : SystemClock.elapsedRealtime();// Register for Intent broadcasts for...IntentFilter filter = new IntentFilter();filter.addAction(Intent.ACTION_BATTERY_CHANGED);filter.addAction(Intent.ACTION_SCREEN_OFF);filter.addAction(Intent.ACTION_SCREEN_ON);mContext.registerReceiver(mIntentReceiver, filter, null, mHandler);}/*** Buckets the battery level.** The code in this function is a little weird because I couldn't comprehend* the bucket going up when the battery level was going down. --joeo** 1 means that the battery is "ok"* 0 means that the battery is between "ok" and what we should warn about.* less than 0 means that the battery is low*/private int findBatteryLevelBucket(int level) {   //这个方法是用来警告判断用的。if (level >= mLowBatteryAlertCloseLevel) {return 1;}if (level >= mLowBatteryReminderLevels[0]) {return 0;}final int N = mLowBatteryReminderLevels.length;for (int i=N-1; i>=0; i--) {if (level <= mLowBatteryReminderLevels[i]) {return -1-i;}}throw new RuntimeException("not possible!");}private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() { //重点,广播接收处理@Overridepublic void onReceive(Context context, Intent intent) {String action = intent.getAction();if (action.equals(Intent.ACTION_BATTERY_CHANGED)) {  //电池电量改变final int oldBatteryLevel = mBatteryLevel; //下边就是根据Intent获取BatteryService传过来的电池属性mBatteryLevel = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, 100); /final int oldBatteryStatus = mBatteryStatus;mBatteryStatus = intent.getIntExtra(BatteryManager.EXTRA_STATUS,BatteryManager.BATTERY_STATUS_UNKNOWN);final int oldPlugType = mPlugType;mPlugType = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 1);final int oldInvalidCharger = mInvalidCharger;mInvalidCharger = intent.getIntExtra(BatteryManager.EXTRA_INVALID_CHARGER, 0);final boolean plugged = mPlugType != 0;final boolean oldPlugged = oldPlugType != 0;int oldBucket = findBatteryLevelBucket(oldBatteryLevel); //这两个值特别有意思,就是说记录下老的电量,记录一下新的电量,比较电量是增加了,还是减小了int bucket = findBatteryLevelBucket(mBatteryLevel);if (DEBUG) {Slog.d(TAG, "buckets   ....." + mLowBatteryAlertCloseLevel+ " .. " + mLowBatteryReminderLevels[0]+ " .. " + mLowBatteryReminderLevels[1]);Slog.d(TAG, "level          " + oldBatteryLevel + " --> " + mBatteryLevel);Slog.d(TAG, "status         " + oldBatteryStatus + " --> " + mBatteryStatus);Slog.d(TAG, "plugType       " + oldPlugType + " --> " + mPlugType);Slog.d(TAG, "invalidCharger " + oldInvalidCharger + " --> " + mInvalidCharger);Slog.d(TAG, "bucket         " + oldBucket + " --> " + bucket);Slog.d(TAG, "plugged        " + oldPlugged + " --> " + plugged);}if (oldInvalidCharger == 0 && mInvalidCharger != 0) {Slog.d(TAG, "showing invalid charger warning");showInvalidChargerDialog(); //就是充电器不识别的弹窗return;} else if (oldInvalidCharger != 0 && mInvalidCharger == 0) {dismissInvalidChargerDialog();} else if (mInvalidChargerDialog != null) {// if invalid charger is showing, don't show low batteryreturn;}if (!plugged&& (bucket < oldBucket || oldPlugged)&& mBatteryStatus != BatteryManager.BATTERY_STATUS_UNKNOWN&& bucket < 0) {showLowBatteryWarning(); <span style="color:#FF0000;">//这里哈,低电量提醒的弹窗</span>// only play SFX when the dialog comes up or the bucket changesif (bucket != oldBucket || oldPlugged) {playLowBatterySound();}} else if (plugged || (bucket > oldBucket && bucket > 0)) { //插上充电器或者充电电池电量超过20取消弹窗dismissLowBatteryWarning();} else if (mBatteryLevelTextView != null) {showLowBatteryWarning();}} else if (Intent.ACTION_SCREEN_OFF.equals(action)) {mScreenOffTime = SystemClock.elapsedRealtime();} else if (Intent.ACTION_SCREEN_ON.equals(action)) {mScreenOffTime = -1;} else {Slog.w(TAG, "unknown intent: " + intent);}}};void dismissLowBatteryWarning() {if (mLowBatteryDialog != null) {Slog.i(TAG, "closing low battery warning: level=" + mBatteryLevel);mLowBatteryDialog.dismiss();}}void showLowBatteryWarning() {Slog.i(TAG,((mBatteryLevelTextView == null) ? "showing" : "updating")+ " low battery warning: level=" + mBatteryLevel+ " [" + findBatteryLevelBucket(mBatteryLevel) + "]");CharSequence levelText = mContext.getString(R.string.battery_low_percent_format, mBatteryLevel);if (mBatteryLevelTextView != null) {mBatteryLevelTextView.setText(levelText);} else {View v = View.inflate(mContext, R.layout.battery_low, null);mBatteryLevelTextView = (TextView)v.findViewById(R.id.level_percent);mBatteryLevelTextView.setText(levelText);AlertDialog.Builder b = new AlertDialog.Builder(mContext);b.setCancelable(true);b.setTitle(R.string.battery_low_title);b.setView(v);b.setIconAttribute(android.R.attr.alertDialogIcon);b.setPositiveButton(android.R.string.ok, null);final Intent intent = new Intent(Intent.ACTION_POWER_USAGE_SUMMARY);intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK| Intent.FLAG_ACTIVITY_MULTIPLE_TASK| Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS| Intent.FLAG_ACTIVITY_NO_HISTORY);if (intent.resolveActivity(mContext.getPackageManager()) != null) {b.setNegativeButton(R.string.battery_low_why,new DialogInterface.OnClickListener() {@Overridepublic void onClick(DialogInterface dialog, int which) {mContext.startActivityAsUser(intent, UserHandle.CURRENT);dismissLowBatteryWarning();}});}AlertDialog d = b.create();d.setOnDismissListener(new DialogInterface.OnDismissListener() {@Overridepublic void onDismiss(DialogInterface dialog) {mLowBatteryDialog = null;mBatteryLevelTextView = null;}});d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);d.getWindow().getAttributes().privateFlags |=WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS;d.show();mLowBatteryDialog = d;}}void playLowBatterySound() {final ContentResolver cr = mContext.getContentResolver();final int silenceAfter = Settings.Global.getInt(cr,Settings.Global.LOW_BATTERY_SOUND_TIMEOUT, 0);final long offTime = SystemClock.elapsedRealtime() - mScreenOffTime;if (silenceAfter > 0&& mScreenOffTime > 0&& offTime > silenceAfter) {Slog.i(TAG, "screen off too long (" + offTime + "ms, limit " + silenceAfter+ "ms): not waking up the user with low battery sound");return;}if (DEBUG) {Slog.d(TAG, "playing low battery sound. pick-a-doop!"); // WOMP-WOMP is deprecated}if (Settings.Global.getInt(cr, Settings.Global.POWER_SOUNDS_ENABLED, 1) == 1) {final String soundPath = Settings.Global.getString(cr,Settings.Global.LOW_BATTERY_SOUND);if (soundPath != null) {final Uri soundUri = Uri.parse("file://" + soundPath);if (soundUri != null) {final Ringtone sfx = RingtoneManager.getRingtone(mContext, soundUri);if (sfx != null) {sfx.setStreamType(AudioManager.STREAM_SYSTEM);sfx.play();}}}}}void dismissInvalidChargerDialog() {if (mInvalidChargerDialog != null) {mInvalidChargerDialog.dismiss();}}void showInvalidChargerDialog() {Slog.d(TAG, "showing invalid charger dialog");dismissLowBatteryWarning();AlertDialog.Builder b = new AlertDialog.Builder(mContext);b.setCancelable(true);b.setMessage(R.string.invalid_charger);b.setIconAttribute(android.R.attr.alertDialogIcon);b.setPositiveButton(android.R.string.ok, null);AlertDialog d = b.create();d.setOnDismissListener(new DialogInterface.OnDismissListener() {public void onDismiss(DialogInterface dialog) {mInvalidChargerDialog = null;mBatteryLevelTextView = null;}});d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);d.show();mInvalidChargerDialog = d;}public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {pw.print("mLowBatteryAlertCloseLevel=");pw.println(mLowBatteryAlertCloseLevel);pw.print("mLowBatteryReminderLevels=");pw.println(Arrays.toString(mLowBatteryReminderLevels));pw.print("mInvalidChargerDialog=");pw.println(mInvalidChargerDialog == null ? "null" : mInvalidChargerDialog.toString());pw.print("mLowBatteryDialog=");pw.println(mLowBatteryDialog == null ? "null" : mLowBatteryDialog.toString());pw.print("mBatteryLevel=");pw.println(Integer.toString(mBatteryLevel));pw.print("mBatteryStatus=");pw.println(Integer.toString(mBatteryStatus));pw.print("mPlugType=");pw.println(Integer.toString(mPlugType));pw.print("mInvalidCharger=");pw.println(Integer.toString(mInvalidCharger));pw.print("mScreenOffTime=");pw.print(mScreenOffTime);if (mScreenOffTime >= 0) {pw.print(" (");pw.print(SystemClock.elapsedRealtime() - mScreenOffTime);pw.print(" ago)");}pw.println();pw.print("soundTimeout=");pw.println(Settings.Global.getInt(mContext.getContentResolver(),Settings.Global.LOW_BATTERY_SOUND_TIMEOUT, 0));pw.print("bucket: ");pw.println(Integer.toString(findBatteryLevelBucket(mBatteryLevel)));}
}

总结一下:这个类就是接收电池电量改变的广播,然后弹窗提醒。

下一个类就是没电关机界面了,文件目录:\frameworks\base\services\java\com\android\server\ShutdownLowBatteryActivity.java

这个Activity的配置文件是这样的(\frameworks\base\core\res\AndroidManifest.xml):

[html] view plain copy print ?
  1.  <activity android:name="com.android.server.ShutdownLowBatteryActivity"  
  2.     android:theme="@android:style/Theme.Translucent.NoTitleBar"  
  3.     android:configChanges="orientation|keyboardHidden|screenSize"  
  4.     android:windowSoftInputMode="stateHidden"  
  5.     android:permission="android.permission.SHUTDOWN"  
  6.     android:excludeFromRecents="true">  
  7.     <intent-filter>  
  8.         <action android:name="android.intent.action.ACTION_REQUEST_SHUTDOWN_LOWBATTERY" />  
  9.         <category android:name="android.intent.category.DEFAULT" />  
  10.     </intent-filter>  
  11. </activity>  
         <activity android:name="com.android.server.ShutdownLowBatteryActivity"android:theme="@android:style/Theme.Translucent.NoTitleBar"android:configChanges="orientation|keyboardHidden|screenSize"android:windowSoftInputMode="stateHidden"android:permission="android.permission.SHUTDOWN"android:excludeFromRecents="true"><intent-filter><action android:name="android.intent.action.ACTION_REQUEST_SHUTDOWN_LOWBATTERY" /><category android:name="android.intent.category.DEFAULT" /></intent-filter></activity>


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 print ?
  1. /* 
  2.  * Copyright (C) 2009 The Android Open Source Project 
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License"); 
  5.  * you may not use this file except in compliance with the License. 
  6.  * You may obtain a copy of the License at 
  7.  * 
  8.  *      http://www.apache.org/licenses/LICENSE-2.0 
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software 
  11.  * distributed under the License is distributed on an "AS IS" BASIS, 
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  13.  * See the License for the specific language governing permissions and 
  14.  * limitations under the License. 
  15.  */  
  16.   
  17. package com.android.server;  
  18.   
  19. import android.app.Activity;  
  20. import android.app.AlertDialog;  
  21. import android.app.KeyguardManager;  
  22. import android.content.BroadcastReceiver;  
  23. import android.content.Context;  
  24. import android.content.DialogInterface;  
  25. import android.content.Intent;  
  26. import android.content.IntentFilter;  
  27. import android.os.Bundle;  
  28. import android.os.Handler;  
  29. import android.util.Slog;  
  30. import android.view.Window;  
  31. import android.view.WindowManager;  
  32. import android.view.View;  
  33.   
  34.   
  35. //import com.android.internal.app.ShutdownThread;  
  36. import com.android.server.power.ShutdownThread;  
  37.   
  38. import android.telephony.TelephonyManager;  
  39. import android.telephony.PhoneStateListener;  
  40. import android.media.MediaPlayer;  
  41. import android.media.MediaPlayer.OnCompletionListener;  
  42. import android.content.ContentResolver;  
  43. import android.provider.Settings;  
  44.   
  45. import java.io.IOException;  
  46.   
  47. public class ShutdownLowBatteryActivity extends Activity {  
  48.   
  49.     private static final String TAG = "ShutdownLowBatteryActivity";  
  50.     private boolean mConfirm;  
  51.     private int mSeconds = 15;//电池电量等于0 15秒内不插充电器就自动关机  
  52.     private AlertDialog mDialog;  
  53.     private Handler myHandler = new Handler();  
  54.     private Runnable myRunnable = new Runnable() { //这里数秒关机  
  55.         @Override  
  56.         public void run() {  
  57.             mSeconds --;  
  58.             if(mSeconds <1)  
  59.                 mSeconds=0;  
  60.             mDialog.setMessage(getString(com.android.internal.R.string.low_battery_shutdown_after_seconds,mSeconds));  
  61.   
  62.             if(mSeconds <= 1){  
  63.                 myHandler.removeCallbacks(myRunnable);  
  64.                 Handler h = new Handler();  
  65.                 h.post(new Runnable() {  
  66.                     public void run() {  
  67.                         ShutdownThread.shutdown(ShutdownLowBatteryActivity.this, mConfirm);  
  68.                     }  
  69.                 });  
  70.             }  
  71.             myHandler.postDelayed(myRunnable,1000);  
  72.         }  
  73.     };  
  74.   
  75.     private BroadcastReceiver mReceiver;  
  76.     private MediaPlayer mplayer;  
  77.   
  78.     @Override  
  79.     protected void onCreate(Bundle savedInstanceState) {  
  80.         super.onCreate(savedInstanceState);  
  81.   
  82.         mConfirm = getIntent().getBooleanExtra(Intent.EXTRA_KEY_CONFIRM, false);  
  83.         Slog.i(TAG, "onCreate(): confirm=" + mConfirm);  
  84.    
  85.         //if(getIntent().getBooleanExtra("can_be_cancel", false)) { //这行注释掉了: 然后当连上充电器后或者电量涨到20的时候,就取消倒计时关机  
  86.                 mReceiver = new BroadcastReceiver() {  
  87.                 @Override  
  88.                 public void onReceive(Context context, Intent intent) {  
  89.                     if(Intent.ACTION_BATTERY_OKAY.equals(intent.getAction())|  
  90.                         Intent.ACTION_POWER_CONNECTED.equals(intent.getAction())){  
  91.                         ShutDownWakeLock.releaseCpuLock();  
  92.                         myHandler.removeCallbacks(myRunnable);  
  93.                         if(mReceiver != null)  
  94.                             unregisterReceiver(mReceiver);  
  95.                         finish();  
  96.                     }  
  97.                 }  
  98.             };  
  99.   
  100.          IntentFilter filter=new IntentFilter(Intent.ACTION_POWER_CONNECTED);  
  101.          filter.addAction(Intent.ACTION_BATTERY_OKAY);  
  102.          registerReceiver(mReceiver, filter);  
  103.          //}  
  104.    
  105.   
  106.         PhoneStateListener mPhoneStateListener = new PhoneStateListener() { //如果正数秒呢,电话呼入了。取消自动关机  
  107.             @Override  
  108.             public void onCallStateChanged(int state, String ignored) {  
  109.                 if (state == TelephonyManager.CALL_STATE_RINGING) {  
  110.                     ShutDownWakeLock.releaseCpuLock();  
  111.                     myHandler.removeCallbacks(myRunnable);  
  112.                     finish();  
  113.                 }  
  114.             }  
  115.         };  
  116.   
  117.         TelephonyManager mTelephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);  
  118.         mTelephonyManager.listen(mPhoneStateListener,  
  119.                 PhoneStateListener.LISTEN_CALL_STATE);  
  120.         requestWindowFeature(android.view.Window.FEATURE_NO_TITLE);  
  121.         Window win = getWindow();  
  122.         win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED  
  123.                 | WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD);  
  124.         win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON  
  125.                     | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON);  
  126.   
  127.         setContentView(new View(this));  
  128.         mDialog=new AlertDialog.Builder(this).create();  
  129.         mDialog.setTitle(com.android.internal.R.string.low_battery_shutdown_title);  
  130.         mDialog.setMessage(getString(com.android.internal.R.string.low_battery_shutdown_after_seconds,mSeconds));  
  131.         if(!getIntent().getBooleanExtra("cant_be_cancel_by_button"false)) {//读取配置文件,是否运行取消,然后根据这个显示取消自动关机按钮  
  132.             mDialog.setButton(DialogInterface.BUTTON_NEUTRAL,getText(com.android.internal.R.string.cancel), new DialogInterface.OnClickListener() {  
  133.                     @Override  
  134.                     public void onClick(DialogInterface dialog, int which) {  
  135.                         myHandler.removeCallbacks(myRunnable);  
  136.                         dialog.cancel();  
  137.                         if(mReceiver != null)  
  138.                             unregisterReceiver(mReceiver);  
  139.                         finish();  
  140.                     }});  
  141.         }  
  142.         mDialog.setCancelable(false);  
  143.         //mDialog.getWindow().setType( WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);  
  144.         mDialog.show();  
  145.         if(mConfirm == false){  
  146.             myHandler.postDelayed(myRunnable, 1000);  
  147.         }  
  148.         myHandler.post(new Runnable(){  
  149.             public void run(){  
  150.                 final ContentResolver cr = getContentResolver();  
  151.                 String path=Settings.System.getString(cr,Settings.System.NOTIFICATION_SOUND);  
  152.   
  153.                mplayer=new MediaPlayer();  
  154.                 try{  
  155.                     mplayer.reset();  
  156.                     mplayer.setDataSource("system/media/audio/ui/LowBattery.ogg");                    
  157.                     mplayer.prepare();  
  158.                     mplayer.start();  
  159.                     mplayer.setOnCompletionListener(new OnCompletionListener() {  
  160.                         @Override  
  161.                         public void onCompletion(MediaPlayer mp) {  
  162.                             if(null != mplayer){  
  163.                                 mplayer.stop();  
  164.                                 mplayer.release();  
  165.                                 mplayer = null;  
  166.                             }  
  167.                         }  
  168.                     });  
  169.                 }  
  170.                 catch(IOException e){  
  171.                       
  172.                 }  
  173.             }  
  174.         });  
  175.     }  
  176. }  
/** Copyright (C) 2009 The Android Open Source Project** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at**      http://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package com.android.server;import android.app.Activity;
import android.app.AlertDialog;
import android.app.KeyguardManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.os.Handler;
import android.util.Slog;
import android.view.Window;
import android.view.WindowManager;
import android.view.View;//import com.android.internal.app.ShutdownThread;
import com.android.server.power.ShutdownThread;import android.telephony.TelephonyManager;
import android.telephony.PhoneStateListener;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnCompletionListener;
import android.content.ContentResolver;
import android.provider.Settings;import java.io.IOException;public class ShutdownLowBatteryActivity extends Activity {private static final String TAG = "ShutdownLowBatteryActivity";private boolean mConfirm;private int mSeconds = 15;//电池电量等于0 15秒内不插充电器就自动关机private AlertDialog mDialog;private Handler myHandler = new Handler();private Runnable myRunnable = new Runnable() { //这里数秒关机@Overridepublic void run() {mSeconds --;if(mSeconds <1)mSeconds=0;mDialog.setMessage(getString(com.android.internal.R.string.low_battery_shutdown_after_seconds,mSeconds));if(mSeconds <= 1){myHandler.removeCallbacks(myRunnable);Handler h = new Handler();h.post(new Runnable() {public void run() {ShutdownThread.shutdown(ShutdownLowBatteryActivity.this, mConfirm);}});}myHandler.postDelayed(myRunnable,1000);}};private BroadcastReceiver mReceiver;private MediaPlayer mplayer;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);mConfirm = getIntent().getBooleanExtra(Intent.EXTRA_KEY_CONFIRM, false);Slog.i(TAG, "onCreate(): confirm=" + mConfirm);//if(getIntent().getBooleanExtra("can_be_cancel", false)) { //这行注释掉了: 然后当连上充电器后或者电量涨到20的时候,就取消倒计时关机mReceiver = new BroadcastReceiver() {@Overridepublic void onReceive(Context context, Intent intent) {if(Intent.ACTION_BATTERY_OKAY.equals(intent.getAction())|Intent.ACTION_POWER_CONNECTED.equals(intent.getAction())){ShutDownWakeLock.releaseCpuLock();myHandler.removeCallbacks(myRunnable);if(mReceiver != null)unregisterReceiver(mReceiver);finish();}}};IntentFilter filter=new IntentFilter(Intent.ACTION_POWER_CONNECTED);filter.addAction(Intent.ACTION_BATTERY_OKAY);registerReceiver(mReceiver, filter);//}PhoneStateListener mPhoneStateListener = new PhoneStateListener() { //如果正数秒呢,电话呼入了。取消自动关机@Overridepublic void onCallStateChanged(int state, String ignored) {if (state == TelephonyManager.CALL_STATE_RINGING) {ShutDownWakeLock.releaseCpuLock();myHandler.removeCallbacks(myRunnable);finish();}}};TelephonyManager mTelephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);mTelephonyManager.listen(mPhoneStateListener,PhoneStateListener.LISTEN_CALL_STATE);requestWindowFeature(android.view.Window.FEATURE_NO_TITLE);Window win = getWindow();win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED| WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD);win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON| WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON);setContentView(new View(this));mDialog=new AlertDialog.Builder(this).create();mDialog.setTitle(com.android.internal.R.string.low_battery_shutdown_title);mDialog.setMessage(getString(com.android.internal.R.string.low_battery_shutdown_after_seconds,mSeconds));if(!getIntent().getBooleanExtra("cant_be_cancel_by_button", false)) {//读取配置文件,是否运行取消,然后根据这个显示取消自动关机按钮mDialog.setButton(DialogInterface.BUTTON_NEUTRAL,getText(com.android.internal.R.string.cancel), new DialogInterface.OnClickListener() {@Overridepublic void onClick(DialogInterface dialog, int which) {myHandler.removeCallbacks(myRunnable);dialog.cancel();if(mReceiver != null)unregisterReceiver(mReceiver);finish();}});}mDialog.setCancelable(false);//mDialog.getWindow().setType( WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);mDialog.show();if(mConfirm == false){myHandler.postDelayed(myRunnable, 1000);}myHandler.post(new Runnable(){public void run(){final ContentResolver cr = getContentResolver();String path=Settings.System.getString(cr,Settings.System.NOTIFICATION_SOUND);mplayer=new MediaPlayer();try{mplayer.reset();mplayer.setDataSource("system/media/audio/ui/LowBattery.ogg");                  mplayer.prepare();mplayer.start();mplayer.setOnCompletionListener(new OnCompletionListener() {@Overridepublic void onCompletion(MediaPlayer mp) {if(null != mplayer){mplayer.stop();mplayer.release();mplayer = null;}}});}catch(IOException e){}}});}
}

总结如下:这个类就是弹窗计时,提醒不连充电器就要关机了。

最后一个相关的类,文件路径:\frameworks\base\packages\SystemUI\src\com\android\systemui\BatteryMeterView.java

这个类是自定义控件,定义在手机状态栏里:

[java] view plain copy print ?
  1. /* 
  2.  * Copyright (C) 2013 The Android Open Source Project 
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License"); 
  5.  * you may not use this file except in compliance with the License. 
  6.  * You may obtain a copy of the License at 
  7.  * 
  8.  *      http://www.apache.org/licenses/LICENSE-2.0 
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software 
  11.  * distributed under the License is distributed on an "AS IS" BASIS, 
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  13.  * See the License for the specific language governing permissions and 
  14.  * limitations under the License. 
  15.  */  
  16.   
  17. package com.android.systemui;  
  18.   
  19. import android.content.BroadcastReceiver;  
  20. import android.content.Context;  
  21. import android.content.Intent;  
  22. import android.content.IntentFilter;  
  23. import android.content.res.Resources;  
  24. import android.content.res.TypedArray;  
  25. import android.graphics.Canvas;  
  26. import android.graphics.Paint;  
  27. import android.graphics.Path;  
  28. import android.graphics.PorterDuff;  
  29. import android.graphics.PorterDuffXfermode;  
  30. import android.graphics.Rect;  
  31. import android.graphics.RectF;  
  32. import android.graphics.Typeface;  
  33. import android.os.BatteryManager;  
  34. import android.os.Bundle;  
  35. import android.provider.Settings;  
  36. import android.util.AttributeSet;  
  37. import android.view.View;  
  38.   
  39. public class BatteryMeterView extends View implements DemoMode {  
  40.     public static final String TAG = BatteryMeterView.class.getSimpleName();  
  41.     public static final String ACTION_LEVEL_TEST = "com.android.systemui.BATTERY_LEVEL_TEST";  
  42.   
  43.     public static final boolean ENABLE_PERCENT = true;  
  44.     public static final boolean SINGLE_DIGIT_PERCENT = false;  
  45.     public static final boolean SHOW_100_PERCENT = false;  
  46.   
  47.     public static final int FULL = 96;  
  48.     public static final int EMPTY = 4;  
  49.   
  50.     public static final float SUBPIXEL = 0.4f;  // inset rects for softer edges  
  51.   
  52.     int[] mColors;  
  53.   
  54.     boolean mShowPercent = true;  
  55.     Paint mFramePaint, mBatteryPaint, mWarningTextPaint, mTextPaint, mBoltPaint;  
  56.     int mButtonHeight;  
  57.     private float mTextHeight, mWarningTextHeight;  
  58.   
  59.     private int mHeight;  
  60.     private int mWidth;  
  61.     private String mWarningString;  
  62.     private final int mChargeColor;  
  63.     private final float[] mBoltPoints;  
  64.     private final Path mBoltPath = new Path();  
  65.   
  66.     private final RectF mFrame = new RectF();  
  67.     private final RectF mButtonFrame = new RectF();  
  68.     private final RectF mClipFrame = new RectF();  
  69.     private final RectF mBoltFrame = new RectF();  
  70.   
  71.     private class BatteryTracker extends BroadcastReceiver {  
  72.         public static final int UNKNOWN_LEVEL = -1;  
  73.   
  74.         // current battery status  
  75.         int level = UNKNOWN_LEVEL;  
  76.         String percentStr;  
  77.         int plugType;  
  78.         boolean plugged;  
  79.         int health;  
  80.         int status;  
  81.         String technology;  
  82.         int voltage;  
  83.         int temperature;  
  84.         boolean testmode = false;  
  85.   
  86.         @Override  
  87.         public void onReceive(Context context, Intent intent) {  
  88.             final String action = intent.getAction();  
  89.             if (action.equals(Intent.ACTION_BATTERY_CHANGED)) { //接收电量改变的广播,取电池状态的属性  
  90.                 if (testmode && ! intent.getBooleanExtra("testmode"false)) return;  
  91.   
  92.                 level = (int)(100f  
  93.                         * intent.getIntExtra(BatteryManager.EXTRA_LEVEL, 0)  
  94.                         / intent.getIntExtra(BatteryManager.EXTRA_SCALE, 100));  
  95.   
  96.                 plugType = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0);  
  97.                 plugged = plugType != 0;  
  98.                 health = intent.getIntExtra(BatteryManager.EXTRA_HEALTH,  
  99.                         BatteryManager.BATTERY_HEALTH_UNKNOWN);  
  100.                 status = intent.getIntExtra(BatteryManager.EXTRA_STATUS,  
  101.                         BatteryManager.BATTERY_STATUS_UNKNOWN);  
  102.                 technology = intent.getStringExtra(BatteryManager.EXTRA_TECHNOLOGY);  
  103.                 voltage = intent.getIntExtra(BatteryManager.EXTRA_VOLTAGE, 0);  
  104.                 temperature = intent.getIntExtra(BatteryManager.EXTRA_TEMPERATURE, 0);  
  105.   
  106.                 setContentDescription(  
  107.                         context.getString(R.string.accessibility_battery_level, level));  
  108.                 postInvalidate();  
  109.             } else if (action.equals(ACTION_LEVEL_TEST)) {  
  110.                 testmode = true;  
  111.                 post(new Runnable() {  
  112.                     int curLevel = 0;  
  113.                     int incr = 1;  
  114.                     int saveLevel = level;  
  115.                     int savePlugged = plugType;  
  116.                     Intent dummy = new Intent(Intent.ACTION_BATTERY_CHANGED);  
  117.                     @Override  
  118.                     public void run() {  
  119.                         if (curLevel < 0) {  
  120.                             testmode = false;  
  121.                             dummy.putExtra("level", saveLevel);  
  122.                             dummy.putExtra("plugged", savePlugged);  
  123.                             dummy.putExtra("testmode"false);  
  124.                         } else {  
  125.                             dummy.putExtra("level", curLevel);  
  126.                             dummy.putExtra("plugged", incr > 0 ? BatteryManager.BATTERY_PLUGGED_AC : 0);  
  127.                             dummy.putExtra("testmode"true);  
  128.                         }  
  129.                         getContext().sendBroadcast(dummy);  
  130.   
  131.                         if (!testmode) return;  
  132.   
  133.                         curLevel += incr;  
  134.                         if (curLevel == 100) {  
  135.                             incr *= -1;  
  136.                         }  
  137.                         postDelayed(this200);  
  138.                     }  
  139.                 });  
  140.             }  
  141.         }  
  142.     }  
  143.   
  144.     BatteryTracker mTracker = new BatteryTracker();  
  145.   
  146.     @Override  
  147.     public void onAttachedToWindow() {  
  148.         super.onAttachedToWindow();  
  149.   
  150.         IntentFilter filter = new IntentFilter();  
  151.         filter.addAction(Intent.ACTION_BATTERY_CHANGED);  
  152.         filter.addAction(ACTION_LEVEL_TEST);  
  153.         final Intent sticky = getContext().registerReceiver(mTracker, filter);  
  154.         if (sticky != null) {  
  155.             // preload the battery level  
  156.             mTracker.onReceive(getContext(), sticky);  
  157.         }  
  158.     }  
  159.   
  160.     @Override  
  161.     public void onDetachedFromWindow() {  
  162.         super.onDetachedFromWindow();  
  163.   
  164.         getContext().unregisterReceiver(mTracker);  
  165.     }  
  166.   
  167.     public BatteryMeterView(Context context) {  
  168.         this(context, null0);  
  169.     }  
  170.   
  171.     public BatteryMeterView(Context context, AttributeSet attrs) {  
  172.         this(context, attrs, 0);  
  173.     }  
  174.   
  175.     public BatteryMeterView(Context context, AttributeSet attrs, int defStyle) {  
  176.         super(context, attrs, defStyle);  
  177.   
  178.         final Resources res = context.getResources();  
  179.         TypedArray levels = res.obtainTypedArray(R.array.batterymeter_color_levels);  
  180.         TypedArray colors = res.obtainTypedArray(R.array.batterymeter_color_values);  
  181.   
  182.         final int N = levels.length();  
  183.         mColors = new int[2*N];  
  184.         for (int i=0; i<N; i++) {  
  185.             mColors[2*i] = levels.getInt(i, 0);  
  186.             mColors[2*i+1] = colors.getColor(i, 0);  
  187.         }  
  188.         levels.recycle();  
  189.         colors.recycle();  
  190.         mShowPercent = ENABLE_PERCENT && 0 != Settings.System.getInt(  
  191.                 context.getContentResolver(), "status_bar_show_battery_percent"0);  
  192.   
  193.         mWarningString = context.getString(R.string.battery_meter_very_low_overlay_symbol);  
  194.   
  195.         mFramePaint = new Paint(Paint.ANTI_ALIAS_FLAG);  
  196.         mFramePaint.setColor(res.getColor(R.color.batterymeter_frame_color));  
  197.         mFramePaint.setDither(true);  
  198.         mFramePaint.setStrokeWidth(0);  
  199.         mFramePaint.setStyle(Paint.Style.FILL_AND_STROKE);  
  200.         mFramePaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_ATOP));  
  201.   
  202.         mBatteryPaint = new Paint(Paint.ANTI_ALIAS_FLAG);  
  203.         mBatteryPaint.setDither(true);  
  204.         mBatteryPaint.setStrokeWidth(0);  
  205.         mBatteryPaint.setStyle(Paint.Style.FILL_AND_STROKE);  
  206.   
  207.         mTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);  
  208.         mTextPaint.setColor(0xFFFFFFFF);  
  209.         Typeface font = Typeface.create("sans-serif-condensed", Typeface.NORMAL);  
  210.         mTextPaint.setTypeface(font);  
  211.         mTextPaint.setTextAlign(Paint.Align.CENTER);  
  212.   
  213.         mWarningTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);  
  214.         mWarningTextPaint.setColor(mColors[1]);  
  215.         font = Typeface.create("sans-serif", Typeface.BOLD);  
  216.         mWarningTextPaint.setTypeface(font);  
  217.         mWarningTextPaint.setTextAlign(Paint.Align.CENTER);  
  218.   
  219.         mChargeColor = getResources().getColor(R.color.batterymeter_charge_color);  
  220.   
  221.         mBoltPaint = new Paint();  
  222.         mBoltPaint.setAntiAlias(true);  
  223.         mBoltPaint.setColor(res.getColor(R.color.batterymeter_bolt_color));  
  224.         mBoltPoints = loadBoltPoints(res);  
  225.         setLayerType(View.LAYER_TYPE_SOFTWARE, null);  
  226.     }  
  227.   
  228.     private static float[] loadBoltPoints(Resources res) {  
  229.         final int[] pts = res.getIntArray(R.array.batterymeter_bolt_points);  
  230.         int maxX = 0, maxY = 0;  
  231.         for (int i = 0; i < pts.length; i += 2) {  
  232.             maxX = Math.max(maxX, pts[i]);  
  233.             maxY = Math.max(maxY, pts[i + 1]);  
  234.         }  
  235.         final float[] ptsF = new float[pts.length];  
  236.         for (int i = 0; i < pts.length; i += 2) {  
  237.             ptsF[i] = (float)pts[i] / maxX;  
  238.             ptsF[i + 1] = (float)pts[i + 1] / maxY;  
  239.         }  
  240.         return ptsF;  
  241.     }  
  242.   
  243.     @Override  
  244.     protected void onSizeChanged(int w, int h, int oldw, int oldh) {  
  245.         mHeight = h;  
  246.         mWidth = w;  
  247.         mWarningTextPaint.setTextSize(h * 0.75f);  
  248.         mWarningTextHeight = -mWarningTextPaint.getFontMetrics().ascent;  
  249.     }  
  250.   
  251.     private int getColorForLevel(int percent) {  
  252.         int thresh, color = 0;  
  253.         for (int i=0; i<mColors.length; i+=2) {  
  254.             thresh = mColors[i];  
  255.             color = mColors[i+1];  
  256.             if (percent <= thresh) return color;  
  257.         }  
  258.         return color;  
  259.     }  
  260.   
  261.     @Override  
  262.     public void draw(Canvas c) {  //通过电池属性绘制图标  
  263.         BatteryTracker tracker = mDemoMode ? mDemoTracker : mTracker;  
  264.         final int level = tracker.level;  
  265.   
  266.         if (level == BatteryTracker.UNKNOWN_LEVEL) return;  
  267.   
  268.         float drawFrac = (float) level / 100f;  
  269.         final int pt = getPaddingTop();  
  270.         final int pl = getPaddingLeft();  
  271.         final int pr = getPaddingRight();  
  272.         final int pb = getPaddingBottom();  
  273.         int height = mHeight - pt - pb;  
  274.         int width = mWidth - pl - pr;  
  275.   
  276.         mButtonHeight = (int) (height * 0.12f);  
  277.   
  278.         mFrame.set(00, width, height);  
  279.         mFrame.offset(pl, pt);  
  280.   
  281.         mButtonFrame.set(  //这个就是电池图标上边的突起  
  282.                 mFrame.left + width * 0.25f,  
  283.                 mFrame.top,  
  284.                 mFrame.right - width * 0.25f,  
  285.                 mFrame.top + mButtonHeight + 5 /*cover frame border of intersecting area*/);  
  286.   
  287.         mButtonFrame.top += SUBPIXEL;  
  288.         mButtonFrame.left += SUBPIXEL;  
  289.         mButtonFrame.right -= SUBPIXEL;  
  290.   
  291.         mFrame.top += mButtonHeight; //电池图标桶装图  
  292.         mFrame.left += SUBPIXEL;  
  293.         mFrame.top += SUBPIXEL;  
  294.         mFrame.right -= SUBPIXEL;  
  295.         mFrame.bottom -= SUBPIXEL;  
  296.   
  297.         // first, draw the battery shape  
  298.         c.drawRect(mFrame, mFramePaint);  
  299.   
  300.         // fill 'er up  
  301.         final int color = tracker.plugged ? mChargeColor : getColorForLevel(level); //根据等级获取颜色,如果是15以下,就是红色。15以上是白色  
  302.         mBatteryPaint.setColor(color);  
  303.   
  304.         if (level >= FULL) { //96时,电池图标里面填充完整,满电。  
  305.             drawFrac = 1f;  
  306.         } else if (level <= EMPTY) { //这个变量是说,当电量小于4的时候,电池图标里面没有填充色,空电量  
  307.             drawFrac = 0f;  
  308.         }  
  309.   
  310.         c.drawRect(mButtonFrame, drawFrac == 1f ? mBatteryPaint : mFramePaint);  
  311.   
  312.         mClipFrame.set(mFrame);  
  313.         mClipFrame.top += (mFrame.height() * (1f - drawFrac));  
  314.   
  315.         c.save(Canvas.CLIP_SAVE_FLAG);  
  316.         c.clipRect(mClipFrame);//在mFrame区域中保持mClipFrame的区域不变,参考下句注释  
  317.         c.drawRect(mFrame, mBatteryPaint);//在mFrame中,把除去mClipFrame的区域绘制。(电量状态,如果是15以下,就是红色。15以上是白色)  
  318.         c.restore();  
  319.   
  320.         if (tracker.plugged) { //这里就犀利了。这是说插上充电器就画一个闪电  
  321.             // draw the bolt  
  322.             final float bl = mFrame.left + mFrame.width() / 4.5f;  
  323.             final float bt = mFrame.top + mFrame.height() / 6f;  
  324.             final float br = mFrame.right - mFrame.width() / 7f;  
  325.             final float bb = mFrame.bottom - mFrame.height() / 10f;  
  326.             if (mBoltFrame.left != bl || mBoltFrame.top != bt  
  327.                     || mBoltFrame.right != br || mBoltFrame.bottom != bb) {  
  328.                 mBoltFrame.set(bl, bt, br, bb);  
  329.                 mBoltPath.reset();  
  330.                 mBoltPath.moveTo(  
  331.                         mBoltFrame.left + mBoltPoints[0] * mBoltFrame.width(),  
  332.                         mBoltFrame.top + mBoltPoints[1] * mBoltFrame.height());  
  333.                 for (int i = 2; i < mBoltPoints.length; i += 2) {  
  334.                     mBoltPath.lineTo(  
  335.                             mBoltFrame.left + mBoltPoints[i] * mBoltFrame.width(),  
  336.                             mBoltFrame.top + mBoltPoints[i + 1] * mBoltFrame.height());  
  337.                 }  
  338.                 mBoltPath.lineTo(  
  339.                         mBoltFrame.left + mBoltPoints[0] * mBoltFrame.width(),  
  340.                         mBoltFrame.top + mBoltPoints[1] * mBoltFrame.height());  
  341.             }  
  342.             c.drawPath(mBoltPath, mBoltPaint);  
  343.         } else if (level <= EMPTY) { //这个是空电量的时候,画一个红色的感叹号  
  344.             final float x = mWidth * 0.5f;  
  345.             final float y = (mHeight + mWarningTextHeight) * 0.48f;  
  346.             c.drawText(mWarningString, x, y, mWarningTextPaint);  
  347.         } else if (mShowPercent && !(tracker.level == 100 && !SHOW_100_PERCENT)) { //以文字显示电量。不过这个没有用到(除非mShowPercent变量获取的配置属性为true)  
  348.             mTextPaint.setTextSize(height *  
  349.                     (SINGLE_DIGIT_PERCENT ? 0.75f  
  350.                             : (tracker.level == 100 ? 0.38f : 0.5f)));  
  351.             mTextHeight = -mTextPaint.getFontMetrics().ascent;  
  352.   
  353.             final String str = String.valueOf(SINGLE_DIGIT_PERCENT ? (level/10) : level);  
  354.             final float x = mWidth * 0.5f;  
  355.             final float y = (mHeight + mTextHeight) * 0.47f;  
  356.             c.drawText(str,  
  357.                     x,  
  358.                     y,  
  359.                     mTextPaint);  
  360.         }  
  361.     }  
  362.   
  363.     private boolean mDemoMode;  
  364.     private BatteryTracker mDemoTracker = new BatteryTracker();  
  365.   
  366.     @Override  
  367.     public void dispatchDemoCommand(String command, Bundle args) {  
  368.         if (!mDemoMode && command.equals(COMMAND_ENTER)) {  
  369.             mDemoMode = true;  
  370.             mDemoTracker.level = mTracker.level;  
  371.             mDemoTracker.plugged = mTracker.plugged;  
  372.         } else if (mDemoMode && command.equals(COMMAND_EXIT)) {  
  373.             mDemoMode = false;  
  374.             postInvalidate();  
  375.         } else if (mDemoMode && command.equals(COMMAND_BATTERY)) {  
  376.            String level = args.getString("level");  
  377.            String plugged = args.getString("plugged");  
  378.            if (level != null) {  
  379.                mDemoTracker.level = Math.min(Math.max(Integer.parseInt(level), 0), 100);  
  380.            }  
  381.            if (plugged != null) {  
  382.                mDemoTracker.plugged = Boolean.parseBoolean(plugged);  
  383.            }  
  384.            postInvalidate();  
  385.         }  
  386.     }  
  387. }  
/** Copyright (C) 2013 The Android Open Source Project** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at**      http://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package com.android.systemui;import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Typeface;
import android.os.BatteryManager;
import android.os.Bundle;
import android.provider.Settings;
import android.util.AttributeSet;
import android.view.View;public class BatteryMeterView extends View implements DemoMode {public static final String TAG = BatteryMeterView.class.getSimpleName();public static final String ACTION_LEVEL_TEST = "com.android.systemui.BATTERY_LEVEL_TEST";public static final boolean ENABLE_PERCENT = true;public static final boolean SINGLE_DIGIT_PERCENT = false;public static final boolean SHOW_100_PERCENT = false;public static final int FULL = 96;public static final int EMPTY = 4;public static final float SUBPIXEL = 0.4f;  // inset rects for softer edgesint[] mColors;boolean mShowPercent = true;Paint mFramePaint, mBatteryPaint, mWarningTextPaint, mTextPaint, mBoltPaint;int mButtonHeight;private float mTextHeight, mWarningTextHeight;private int mHeight;private int mWidth;private String mWarningString;private final int mChargeColor;private final float[] mBoltPoints;private final Path mBoltPath = new Path();private final RectF mFrame = new RectF();private final RectF mButtonFrame = new RectF();private final RectF mClipFrame = new RectF();private final RectF mBoltFrame = new RectF();private class BatteryTracker extends BroadcastReceiver {public static final int UNKNOWN_LEVEL = -1;// current battery statusint level = UNKNOWN_LEVEL;String percentStr;int plugType;boolean plugged;int health;int status;String technology;int voltage;int temperature;boolean testmode = false;@Overridepublic void onReceive(Context context, Intent intent) {final String action = intent.getAction();if (action.equals(Intent.ACTION_BATTERY_CHANGED)) { //接收电量改变的广播,取电池状态的属性if (testmode && ! intent.getBooleanExtra("testmode", false)) return;level = (int)(100f* intent.getIntExtra(BatteryManager.EXTRA_LEVEL, 0)/ intent.getIntExtra(BatteryManager.EXTRA_SCALE, 100));plugType = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0);plugged = plugType != 0;health = intent.getIntExtra(BatteryManager.EXTRA_HEALTH,BatteryManager.BATTERY_HEALTH_UNKNOWN);status = intent.getIntExtra(BatteryManager.EXTRA_STATUS,BatteryManager.BATTERY_STATUS_UNKNOWN);technology = intent.getStringExtra(BatteryManager.EXTRA_TECHNOLOGY);voltage = intent.getIntExtra(BatteryManager.EXTRA_VOLTAGE, 0);temperature = intent.getIntExtra(BatteryManager.EXTRA_TEMPERATURE, 0);setContentDescription(context.getString(R.string.accessibility_battery_level, level));postInvalidate();} else if (action.equals(ACTION_LEVEL_TEST)) {testmode = true;post(new Runnable() {int curLevel = 0;int incr = 1;int saveLevel = level;int savePlugged = plugType;Intent dummy = new Intent(Intent.ACTION_BATTERY_CHANGED);@Overridepublic void run() {if (curLevel < 0) {testmode = false;dummy.putExtra("level", saveLevel);dummy.putExtra("plugged", savePlugged);dummy.putExtra("testmode", false);} else {dummy.putExtra("level", curLevel);dummy.putExtra("plugged", incr > 0 ? BatteryManager.BATTERY_PLUGGED_AC : 0);dummy.putExtra("testmode", true);}getContext().sendBroadcast(dummy);if (!testmode) return;curLevel += incr;if (curLevel == 100) {incr *= -1;}postDelayed(this, 200);}});}}}BatteryTracker mTracker = new BatteryTracker();@Overridepublic void onAttachedToWindow() {super.onAttachedToWindow();IntentFilter filter = new IntentFilter();filter.addAction(Intent.ACTION_BATTERY_CHANGED);filter.addAction(ACTION_LEVEL_TEST);final Intent sticky = getContext().registerReceiver(mTracker, filter);if (sticky != null) {// preload the battery levelmTracker.onReceive(getContext(), sticky);}}@Overridepublic void onDetachedFromWindow() {super.onDetachedFromWindow();getContext().unregisterReceiver(mTracker);}public BatteryMeterView(Context context) {this(context, null, 0);}public BatteryMeterView(Context context, AttributeSet attrs) {this(context, attrs, 0);}public BatteryMeterView(Context context, AttributeSet attrs, int defStyle) {super(context, attrs, defStyle);final Resources res = context.getResources();TypedArray levels = res.obtainTypedArray(R.array.batterymeter_color_levels);TypedArray colors = res.obtainTypedArray(R.array.batterymeter_color_values);final int N = levels.length();mColors = new int[2*N];for (int i=0; i<N; i++) {mColors[2*i] = levels.getInt(i, 0);mColors[2*i+1] = colors.getColor(i, 0);}levels.recycle();colors.recycle();mShowPercent = ENABLE_PERCENT && 0 != Settings.System.getInt(context.getContentResolver(), "status_bar_show_battery_percent", 0);mWarningString = context.getString(R.string.battery_meter_very_low_overlay_symbol);mFramePaint = new Paint(Paint.ANTI_ALIAS_FLAG);mFramePaint.setColor(res.getColor(R.color.batterymeter_frame_color));mFramePaint.setDither(true);mFramePaint.setStrokeWidth(0);mFramePaint.setStyle(Paint.Style.FILL_AND_STROKE);mFramePaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_ATOP));mBatteryPaint = new Paint(Paint.ANTI_ALIAS_FLAG);mBatteryPaint.setDither(true);mBatteryPaint.setStrokeWidth(0);mBatteryPaint.setStyle(Paint.Style.FILL_AND_STROKE);mTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);mTextPaint.setColor(0xFFFFFFFF);Typeface font = Typeface.create("sans-serif-condensed", Typeface.NORMAL);mTextPaint.setTypeface(font);mTextPaint.setTextAlign(Paint.Align.CENTER);mWarningTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);mWarningTextPaint.setColor(mColors[1]);font = Typeface.create("sans-serif", Typeface.BOLD);mWarningTextPaint.setTypeface(font);mWarningTextPaint.setTextAlign(Paint.Align.CENTER);mChargeColor = getResources().getColor(R.color.batterymeter_charge_color);mBoltPaint = new Paint();mBoltPaint.setAntiAlias(true);mBoltPaint.setColor(res.getColor(R.color.batterymeter_bolt_color));mBoltPoints = loadBoltPoints(res);setLayerType(View.LAYER_TYPE_SOFTWARE, null);}private static float[] loadBoltPoints(Resources res) {final int[] pts = res.getIntArray(R.array.batterymeter_bolt_points);int maxX = 0, maxY = 0;for (int i = 0; i < pts.length; i += 2) {maxX = Math.max(maxX, pts[i]);maxY = Math.max(maxY, pts[i + 1]);}final float[] ptsF = new float[pts.length];for (int i = 0; i < pts.length; i += 2) {ptsF[i] = (float)pts[i] / maxX;ptsF[i + 1] = (float)pts[i + 1] / maxY;}return ptsF;}@Overrideprotected void onSizeChanged(int w, int h, int oldw, int oldh) {mHeight = h;mWidth = w;mWarningTextPaint.setTextSize(h * 0.75f);mWarningTextHeight = -mWarningTextPaint.getFontMetrics().ascent;}private int getColorForLevel(int percent) {int thresh, color = 0;for (int i=0; i<mColors.length; i+=2) {thresh = mColors[i];color = mColors[i+1];if (percent <= thresh) return color;}return color;}@Overridepublic void draw(Canvas c) {  //通过电池属性绘制图标BatteryTracker tracker = mDemoMode ? mDemoTracker : mTracker;final int level = tracker.level;if (level == BatteryTracker.UNKNOWN_LEVEL) return;float drawFrac = (float) level / 100f;final int pt = getPaddingTop();final int pl = getPaddingLeft();final int pr = getPaddingRight();final int pb = getPaddingBottom();int height = mHeight - pt - pb;int width = mWidth - pl - pr;mButtonHeight = (int) (height * 0.12f);mFrame.set(0, 0, width, height);mFrame.offset(pl, pt);mButtonFrame.set(  //这个就是电池图标上边的突起mFrame.left + width * 0.25f,mFrame.top,mFrame.right - width * 0.25f,mFrame.top + mButtonHeight + 5 /*cover frame border of intersecting area*/);mButtonFrame.top += SUBPIXEL;mButtonFrame.left += SUBPIXEL;mButtonFrame.right -= SUBPIXEL;mFrame.top += mButtonHeight; //电池图标桶装图mFrame.left += SUBPIXEL;mFrame.top += SUBPIXEL;mFrame.right -= SUBPIXEL;mFrame.bottom -= SUBPIXEL;// first, draw the battery shapec.drawRect(mFrame, mFramePaint);// fill 'er upfinal int color = tracker.plugged ? mChargeColor : getColorForLevel(level); //根据等级获取颜色,如果是15以下,就是红色。15以上是白色mBatteryPaint.setColor(color);if (level >= FULL) { //96时,电池图标里面填充完整,满电。drawFrac = 1f;} else if (level <= EMPTY) { //这个变量是说,当电量小于4的时候,电池图标里面没有填充色,空电量drawFrac = 0f;}c.drawRect(mButtonFrame, drawFrac == 1f ? mBatteryPaint : mFramePaint);mClipFrame.set(mFrame);mClipFrame.top += (mFrame.height() * (1f - drawFrac));c.save(Canvas.CLIP_SAVE_FLAG);c.clipRect(mClipFrame);//在mFrame区域中保持mClipFrame的区域不变,参考下句注释c.drawRect(mFrame, mBatteryPaint);//在mFrame中,把除去mClipFrame的区域绘制。(电量状态,如果是15以下,就是红色。15以上是白色)c.restore();if (tracker.plugged) { //这里就犀利了。这是说插上充电器就画一个闪电// draw the boltfinal float bl = mFrame.left + mFrame.width() / 4.5f;final float bt = mFrame.top + mFrame.height() / 6f;final float br = mFrame.right - mFrame.width() / 7f;final float bb = mFrame.bottom - mFrame.height() / 10f;if (mBoltFrame.left != bl || mBoltFrame.top != bt|| mBoltFrame.right != br || mBoltFrame.bottom != bb) {mBoltFrame.set(bl, bt, br, bb);mBoltPath.reset();mBoltPath.moveTo(mBoltFrame.left + mBoltPoints[0] * mBoltFrame.width(),mBoltFrame.top + mBoltPoints[1] * mBoltFrame.height());for (int i = 2; i < mBoltPoints.length; i += 2) {mBoltPath.lineTo(mBoltFrame.left + mBoltPoints[i] * mBoltFrame.width(),mBoltFrame.top + mBoltPoints[i + 1] * mBoltFrame.height());}mBoltPath.lineTo(mBoltFrame.left + mBoltPoints[0] * mBoltFrame.width(),mBoltFrame.top + mBoltPoints[1] * mBoltFrame.height());}c.drawPath(mBoltPath, mBoltPaint);} else if (level <= EMPTY) { //这个是空电量的时候,画一个红色的感叹号final float x = mWidth * 0.5f;final float y = (mHeight + mWarningTextHeight) * 0.48f;c.drawText(mWarningString, x, y, mWarningTextPaint);} else if (mShowPercent && !(tracker.level == 100 && !SHOW_100_PERCENT)) { //以文字显示电量。不过这个没有用到(除非mShowPercent变量获取的配置属性为true)mTextPaint.setTextSize(height *(SINGLE_DIGIT_PERCENT ? 0.75f: (tracker.level == 100 ? 0.38f : 0.5f)));mTextHeight = -mTextPaint.getFontMetrics().ascent;final String str = String.valueOf(SINGLE_DIGIT_PERCENT ? (level/10) : level);final float x = mWidth * 0.5f;final float y = (mHeight + mTextHeight) * 0.47f;c.drawText(str,x,y,mTextPaint);}}private boolean mDemoMode;private BatteryTracker mDemoTracker = new BatteryTracker();@Overridepublic void dispatchDemoCommand(String command, Bundle args) {if (!mDemoMode && command.equals(COMMAND_ENTER)) {mDemoMode = true;mDemoTracker.level = mTracker.level;mDemoTracker.plugged = mTracker.plugged;} else if (mDemoMode && command.equals(COMMAND_EXIT)) {mDemoMode = false;postInvalidate();} else if (mDemoMode && command.equals(COMMAND_BATTERY)) {String level = args.getString("level");String plugged = args.getString("plugged");if (level != null) {mDemoTracker.level = Math.min(Math.max(Integer.parseInt(level), 0), 100);}if (plugged != null) {mDemoTracker.plugged = Boolean.parseBoolean(plugged);}postInvalidate();}}
}


总结:这个类就是绘制状态栏里面电量图标的自定义控件。


以上就是大概的逻辑,现总结,用于备忘。



本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/24242.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Battery Historian分析手机耗电神器

极力推荐Android 开发大总结文章&#xff1a;欢迎收藏程序员Android 力荐 &#xff0c;Android 开发者需要的必备技能 本篇文章主要介绍 Android 开发中 电量 的部分知识点&#xff0c;通过阅读本篇文章&#xff0c;您将收获以下内容: 1.安装Battery Historian 2.收集Batteryst…

卡尔曼滤波预测应用python实践

1. 什么是卡尔曼滤波 最佳线性滤波理论起源于二十世纪40年代美国科学家Wiener和前苏联科学家KOnMoropOB等人的研究工作&#xff0c;后人统称为维纳滤波理论。60年代Kalman把状态空间模型引入滤波理论&#xff0c;并导出了一套递推估计算法&#xff0c;后人称之为卡尔曼滤波理论…

BatteryStatsService电池电量统计服务分析

BatteryStatsService主要负责电池电量的统计信息,首先我们简单的看下电量统计服务的启动过程。 BatteryStatsService启动过程 从BatteryStatsService的启动时序图可以看出,BatteryStatsService服务是在ActivityManagerService服务中启动的 1. 在SystemServer中startBootstra…

使用Battery Historian采集android耗电数据

一、简介 Battery Historian是由Google提供的查看电量相关信息及事件的工具&#xff0c;Battery historian还可以上传bugreport文件&#xff0c;分析用户手机中App的电池耗电情况。详见&#xff1a;GitHub - google/battery-historian: Battery Historian is a tool to analyz…

利用XGBoost实现短期电力负荷预测

💥 项目专栏:【机器学习项目实战案例目录】项目详解 + 完整源码 文章目录 一、利用XGBoost实现短期电力负荷预测二、数据集介绍三、将数据进行标准化四、形成训练数据五、划分训练集、测试集六、定义模型七、模型训练八、训练集、测试集验证九、网络搜索十、绘制结果🌠 『…

性能优化十四之电量分析工具Battery Historian使用

上篇博客中并没有讲解BatterHistory该如何使用&#xff0c;这篇博客就开始给大家进行介绍。 数据准备 battery-historian工具需要使用bugreport中的BatteryHistory 1. 先断开adb服务&#xff0c;然后开启adb服务 adb kill-server 这一步很重要&#xff0c;因为当我们开…

使用BatteryHistorian分析和优化应用电量

欢迎Follow我的GitHub, 关注我的CSDN. 本文的合集已经编著成书&#xff0c;高级Android开发强化实战&#xff0c;欢迎各位读友的建议和指导。在京东即可购买&#xff1a;https://item.jd.com/12385680.html 在Android项目中, 较难监控应用的电量消耗, 但是用户却非常关心手机的…

Android 使用 Batterystats 和 Battery Historian 分析电池用量

Android 使用 Batterystats 和 Battery Historian 分析电池用量 专注于Android开发&#xff0c;分享经验总结&#xff0c;欢迎加入 Android开发中涉及到耗电量怎么分析呢 google官方提供了文档&#xff0c;链接&#xff1a;https://developer.android.com/studio/profile/batt…

GT的使用及耗电量统计的原理,对GT采集的电池数据采用VBA分析

注意&#xff1a;我测试时的ios操作系统是8.1&#xff0c;现在ios9.0及以后的耗电量比老的系统少了一个量级&#xff0c;官方说减少20%&#xff0c;我的手机在熄屏的耗电量减少了30%以上&#xff0c;亮屏幕减少不太多。 具体编译宏文件和GT采集的部分数据文件下载地址是&#…

Android电池功耗BatteryHistorian数据分析

BatteryHistorian的用法 BatteryHistorian环境搭建配置 官方文档 1.BatteryHistorian图形页面数据分析: Timeline: System stats: CPU runing: cpu运行的状态 Kernel only uptime: 只有kernell运行 Userspace wakelock: 用户空间申请的锁 Screen: 屏幕是否点亮 Top …

时间序列预测:用电量预测 07 灰色预测算法

&#x1f32e;开发平台&#xff1a;jupyter lab &#x1f356;运行环境&#xff1a;python3、TensorFlow2.x ----------------------------------------------- 2022.9.16 测验成功 ---------------------------------------------------------------- 1. 时间序列预测&#x…

时间序列预测15:Multi-input / Multi-head CNN 实现用电量/发电量预测

【时间序列预测/分类】 全系列60篇由浅入深的博文汇总&#xff1a;传送门 接上文&#xff0c;本文介绍如何为多变量数据开发多输入通道多步时间序列预测的CNN模型和多子模型异构多步时间序列预测的CNN模型。 文章目录 2. 多输入通道 CNN 模型2.1 建模2.2 完整代码 3. 多头&…

人工智能迅猛发展,如何应对避免失业?

“人工智能从感知智能向认知智能演进”&#xff0c;人工智能的发展带给我们哪些思考&#xff1f;它究竟会给我们的工作生活带来哪些变化?我们要如何去应对&#xff1f; 阿里达摩院票选出2020年十大科技趋势&#xff1a; 量子计算进入攻坚期工业互联网的超融合保护数据隐私的A…

【杂谈】人脸图像书看完了感觉不过瘾?这些拓展人脸资料值得你关注一下

相信许多朋友都看过我这本人脸图像处理的书籍了&#xff0c;内容涵盖了人脸检测&#xff0c;人脸关键点检测&#xff0c;人脸识别&#xff0c;人脸属性分析&#xff0c;人脸美颜&#xff0c;人脸编辑与风格化&#xff0c;三维人脸重建内容&#xff0c;基本上包括了人脸的所有领…

Guava、Spring 如何抽象观察者模式?

什么是观察者模式 观察者模式 是一种行为设计模式&#xff0c;允许定义一种订阅通知机制&#xff0c;可以在对象&#xff08;被观察者&#xff09;事件发生时通知多个 “观察” 该对象的观察者对象&#xff0c;所以也被称为 发布订阅模式 其实我个人而言&#xff0c;不太喜欢使…

苹果「Find My iPhone」立功,帮警察追踪偷车嫌犯

By 超神经 内容提要&#xff1a;在澳大利亚墨尔本的一起入室盗窃案中&#xff0c;警方在 iPad 上「Find My」的协助下追踪到嫌犯位置&#xff0c;但追踪过程中嫌犯却因车祸丧生。 关键词&#xff1a;Find My 协警 盗窃 苹果的「Fing My」最近在一起入室抢劫案中立功了。 2 月 …

Hive 知识体系保姆级教程

Hive涉及的知识点如下图所示&#xff0c;本文将逐一讲解&#xff1a; 正文开始&#xff1a; 一. Hive概览 1.1 hive的简介 Hive是基于Hadoop的一个数据仓库工具&#xff0c;可以将结构化的数据文件映射为一张数据库表&#xff0c;并提供类SQL查询功能。 其本质是将SQL转换为Map…

跟着 Guava、Spring 学习如何设计观察者模式

文章首发在公众号&#xff08;龙台的技术笔记&#xff09;&#xff0c;之后同步到掘金和个人网站&#xff1a;xiaomage.info 今天讲解一篇行为型设计模式&#xff0c;什么是行为型&#xff1f;行为型主要负责设计 类或对象之间的交互。工作中常用的观察者模式就是一种行为型设…

【总结】有三AI重要原创人脸相关的技术文章汇总(2022年8月)

人脸图像的应用领域想必所有做视觉算法的都不会陌生&#xff0c;所有的安防监控、几乎现在所有的在线身份认证、支付、考勤都需要用到人脸检测与人脸识别&#xff0c;人脸识别甚至被用于追逃疑犯&#xff0c;找寻失踪人口。 所有的在线直播平台&#xff0c;手机拍照软件&#x…

【总结】有三AI所有原创人脸相关的学习资料汇总(2022年12月)

人脸图像的应用领域想必所有做视觉算法的都不会陌生&#xff0c;所有的安防监控、几乎现在所有的在线身份认证、支付、考勤都需要用到人脸检测与人脸识别&#xff0c;人脸识别甚至被用于追逃疑犯&#xff0c;找寻失踪人口。 所有的在线直播平台&#xff0c;手机拍照软件&#x…