提示PMS和BatteryService、BatteryStatsService均有互動關係，這些內容放在後面分析。

    ......//ServerThread的run函式

    power =new PowerManagerService();//①建立PMS物件

   ServiceManager.addService(Context.POWER_SERVICE, power);//註冊到SM中

   ......

   //②呼叫PMS的init函式

   power.init(context,lights, ActivityManagerService.self(), battery);

   ......//其他服務

   power.systemReady();//③呼叫PMS的systemReady

   ......//系統啟動完畢，會收到ACTION_BOOT_COMPLETED廣播

   //④PMS處理ACTION_BOOT_COMPLETED廣播

PowerManagerService() {

    longtoken = Binder.clearCallingIdentity();

    MY_UID =Process.myUid();//取本程式（即SystemServer）的uid及pid

    MY_PID =Process.myPid();

   Binder.restoreCallingIdentity(token);

    //設定超時時間為1周。Power類封裝了同Linux核心互動的介面。本章最後再來分析它

   Power.setLastUserActivityTimeout(7*24*3600*1000);

    //初始化兩個狀態變數，它們非常有意義。其具體作用後續再分析

    mUserState= mPowerState = 0;

    //將自己新增到看門狗的監控管理佇列中

   Watchdog.getInstance().addMonitor(this);

 }

void init(Context context, LightsService lights,IActivityManager activity,

                            BatteryService battery) {

   //①儲存幾個成員變數

  mLightsService = lights;//儲存LightService

   mContext= context;

  mActivityService = activity;//儲存ActivityManagerService

   //儲存BatteryStatsService

  mBatteryStats = BatteryStatsService.getService();//

  mBatteryService = battery;//儲存BatteryService

   //從LightService中獲取代表不同硬體Light的Light物件

   mLcdLight= lights.getLight(LightsService.LIGHT_ID_BACKLIGHT);

  mButtonLight = lights.getLight(LightsService.LIGHT_ID_BUTTONS);

  mKeyboardLight = lights.getLight(LightsService.LIGHT_ID_KEYBOARD);

  mAttentionLight = lights.getLight(LightsService.LIGHT_ID_ATTENTION);

   //②呼叫nativeInit函式

  nativeInit();

  synchronized (mLocks) {

     updateNativePowerStateLocked();//③更新Native層的電源狀態

  }

static void android_server_PowerManagerService_nativeInit(JNIEnv*env,

                             jobject obj) {

    //非常簡單，就是建立一個全域性引用物件gPowerManagerServiceObj

   gPowerManagerServiceObj = env->NewGlobalRef(obj);

}

......

 mScreenOffThread= new HandlerThread("PowerManagerService.mScreenOffThread") {

   protected void onLooperPrepared() {

  mScreenOffHandler = new Handler();//向這個handler傳送的訊息，將由此執行緒處理

   synchronized (mScreenOffThread) {

      mInitComplete = true;

      mScreenOffThread.notifyAll();

      }

    }

   };

 mScreenOffThread.start();//建立對應的工作執行緒

 synchronized (mScreenOffThread) {

    while(!mInitComplete) {

       try {//等待mScreenOffThread執行緒建立完成

             mScreenOffThread.wait();

        } ......

       }

    }

   mInitComplete= false;

   //建立 mHandlerThread

  mHandlerThread = new HandlerThread("PowerManagerService") {

   protectedvoid onLooperPrepared() {

      super.onLooperPrepared();

      initInThread();//①初始化另外一些成員變數

     }

   };

 mHandlerThread.start();

        ......//等待mHandlerThread建立完成

void initInThread() {

   mHandler= new Handler();

   //PMS內部也需要使用WakeLock，此處定義了幾種不同的UnsynchronizedWakeLock。它們的

   //作用見後文分析

   mBroadcastWakeLock = newUnsynchronizedWakeLock(

              PowerManager.PARTIAL_WAKE_LOCK, "sleep_broadcast", true);

   //建立廣播通知的Intent，用於通知SCREEN_ON和SCREEN_OFF訊息

  mScreenOnIntent = new Intent(Intent.ACTION_SCREEN_ON);

  mScreenOnIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);

  mScreenOffIntent = new Intent(Intent.ACTION_SCREEN_OFF);

  mScreenOffIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);

   //取配置引數，這些引數是編譯時確定的，執行過程中無法修改

   Resourcesresources = mContext.getResources();

  mAnimateScreenLights = resources.getBoolean(

               com.android.internal.R.bool.config_animateScreenLights);

        ......//見下文的配置引數彙總

        //通過資料庫設定的配置引數

   ContentResolver resolver =mContext.getContentResolver();

   Cursor settingsCursor =resolver.query(Settings.System.CONTENT_URI, null,

               ......//設定查詢條件和查詢項的名字，見後文的配置引數彙總

               null);

   //ContentQueryMap是一個常用類，簡化了資料庫查詢工作。讀者可參考SDK中該類的說明文件

   mSettings= new ContentQueryMap(settingsCursor, Settings.System.NAME,

                                   true, mHandler);

   //監視上邊建立的ContentQueryMap中內容的變化

  SettingsObserver settingsObserver = new SettingsObserver();

   mSettings.addObserver(settingsObserver);

   settingsObserver.update(mSettings, null);

   //註冊接收通知的BroadcastReceiver

  IntentFilter filter = new IntentFilter();

  filter.addAction(Intent.ACTION_BATTERY_CHANGED);

  mContext.registerReceiver(new BatteryReceiver(), filter);

   filter =new IntentFilter();

  filter.addAction(Intent.ACTION_BOOT_COMPLETED);

  mContext.registerReceiver(new BootCompletedReceiver(), filter);

   filter =new IntentFilter();

  filter.addAction(Intent.ACTION_DOCK_EVENT);

  mContext.registerReceiver(new DockReceiver(), filter);

    //監視Settings資料中secure表的變化

  mContext.getContentResolver().registerContentObserver(

            Settings.Secure.CONTENT_URI, true,

           new ContentObserver(new Handler()) {

               public void onChange(boolean selfChange) {

                   updateSettingsValues();

               }

           });

   updateSettingsValues();

    ......//通知其他執行緒

 }

  nativeInit();//不知道此處為何還要呼叫一次nativeInit，筆者懷疑此處為bug

  synchronized (mLocks) {

     updateNativePowerStateLocked();//更新native層power狀態，以後分析

     forceUserActivityLocked();//強制觸發一次使用者事件

    mInitialized = true;

 }//init函式完畢

private void forceUserActivityLocked() {

   if(isScreenTurningOffLocked()) {

    mScreenBrightness.animating = false;

  }

   boolean savedActivityAllowed =mUserActivityAllowed;

  mUserActivityAllowed = true;

  //下面這個函式以後會分析， SDK中有對應的API

  userActivity(SystemClock.uptimeMillis(), false);

   mUserActivityAllowed= savedActivityAllowed;

 }

void systemReady() {

  /*

  建立一個SensorManager，用於和系統中的感測器系統互動，由於該部分涉及較多的native層

  程式碼，因此將相關內容放到本書後續章節進行討論

  */

 mSensorManager = new SensorManager(mHandlerThread.getLooper());

 mProximitySensor = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);

  if(mUseSoftwareAutoBrightness) {

      mLightSensor =mSensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);

  }

  if(mUseSoftwareAutoBrightness) {

     setPowerState(SCREEN_BRIGHT);

    } else {//不考慮軟體自動亮度調節，所以執行下面這個分支

   setPowerState(ALL_BRIGHT);//設定手機電源狀態為ALL_BRIGHT，即螢幕、按鍵燈都開啟

 }

 synchronized (mLocks) {

 mDoneBooting = true;

  //根據情況啟用LightSensor

 enableLightSensorLocked(mUseSoftwareAutoBrightness&&mAutoBrightessEnabled);

  longidentity = Binder.clearCallingIdentity();

  try {//通知BatteryStatsService，它將統計相關的電量使用情況，後續再分析它

    mBatteryStats.noteScreenBrightness(getPreferredBrightness());

    mBatteryStats.noteScreenOn();

  }......

}

private final class BootCompletedReceiver extendsBroadcastReceiver {

  publicvoid onReceive(Context context, Intent intent) {

  bootCompleted();//呼叫PMS的bootCompleted函式

  }

}

void bootCompleted() {

 synchronized (mLocks) {

  mBootCompleted = true;

   //再次碰見userActivity，根據前面的描述，此時將重新計算螢幕超時時間

  userActivity(SystemClock.uptimeMillis(), false, BUTTON_EVENT, true);

  updateWakeLockLocked();//此處先分析這個函式

  mLocks.notifyAll();

   }

 }

private void updateWakeLockLocked() {

  /*

    mStayOnConditions用於控制當插上USB時，手機是否保持喚醒狀態。

    mBatteryService的isPowered用於判斷當前是否處於USB充電狀態。

    如果滿足下面的if條件滿，則PMS需要使用wakeLock來確保系統不會掉電

  */

  if(mStayOnConditions != 0 &&mBatteryService.isPowered(mStayOnConditions)) {

     mStayOnWhilePluggedInScreenDimLock.acquire();

     mStayOnWhilePluggedInPartialLock.acquire();

  } else {

      //如果不滿足if條件，則釋放對應的wakeLock，這樣系統就可以進入休眠狀態

     mStayOnWhilePluggedInScreenDimLock.release();

     mStayOnWhilePluggedInPartialLock.release();

  }

}

PowerManager pm = (PowerManager)getSystemService(Context.POWER_SERVICE);

 //①建立一個WakeLock，注意它的引數

 PowerManager.WakeLock wl =pm.newWakeLock(PowerManager.SCREEN_DIM_WAKE_LOCK,

                                              "MyTag");

 wl.acquire();//②獲取該鎖

   ......//工作

 wl.release();//③釋放該鎖

public WakeLock newWakeLock(int flags, String tag)

{

  //tag不能為null，否則拋異常

  return new WakeLock(flags, tag);//WakeLock為PM的內部類，第一個引數flags很關鍵

 }

WakeLock(int flags, String tag)

{

     //檢查flags引數是否非法

    mFlags =flags;

    mTag =tag;

    //建立一個Binder物件，除了做Token外，PMS需要監視客戶端的生死狀況，否則有可能導致

    //WakeLock不能被釋放

     mToken= new Binder();

}

public void acquire()

 {

 synchronized (mToken) {

  acquireLocked();//呼叫acquireLocked函式

  }

 }

//acquireLoced函式

private void acquireLocked() {

  if(!mRefCounted || mCount++ == 0) {

     mHandler.removeCallbacks(mReleaser);//引用計數控制

  try {

      //呼叫PMS的acquirewakeLock，注意這裡傳遞的引數，其中mWorkSource為空

     mService.acquireWakeLock(mFlags, mToken, mTag, mWorkSource);

  }......

    mHeld =true;

   }

}

/**    見WorkSoure.java

 * Describesthe source of some work that may be done by someone else.

 * Currentlythe public representation of what a work source is is not

 * defined;this is an opaque container.

 */

public void acquireWakeLock(int flags, IBinderlock, String tag, WorkSource ws) {

        intuid = Binder.getCallingUid();

        intpid = Binder.getCallingPid();

        if(uid != Process.myUid()) {

           mContext.enforceCallingOrSelfPermission(//檢查WAKE_LOCK許可權

                          android.Manifest.permission.WAKE_LOCK,null);

        }

        if(ws != null) {

            //如果ws不為空，需要檢查呼叫程式是否有UPDATE_DEVICE_STATS的許可權

           enforceWakeSourcePermission(uid, pid);

        }

        longident = Binder.clearCallingIdentity();

        try{

           synchronized (mLocks) {呼叫acquireWakeLockLocked函式

               acquireWakeLockLocked(flags, lock, uid, pid, tag, ws);

           }

        } ......

    }

class WakeLock implements IBinder.DeathRecipient

public void acquireWakeLockLocked(int flags,IBinder lock, int uid,

                        int pid, Stringtag,WorkSource ws) {

  ......

  //mLocks是一個ArrayList，儲存PMS.WakeLock物件

  int index= mLocks.getIndex(lock);

  WakeLockwl;

  booleannewlock;

  booleandiffsource;

  WorkSourceoldsource;

  if (index< 0) {

     //建立一個PMS.WakeLock物件，儲存客戶端acquire傳來的引數

    wl = new WakeLock(flags, lock, tag, uid, pid);

    switch(wl.flags & LOCK_MASK)

    {    //將flags轉換成對應的minState

      casePowerManager.FULL_WAKE_LOCK:

       if(mUseSoftwareAutoBrightness) {

        wl.minState = SCREEN_BRIGHT;

       }else {

         wl.minState = (mKeyboardVisible ? ALL_BRIGHT: SCREEN_BUTTON_BRIGHT);

        }

       break;

      casePowerManager.SCREEN_BRIGHT_WAKE_LOCK:

        wl.minState = SCREEN_BRIGHT;

         break;

       casePowerManager.SCREEN_DIM_WAKE_LOCK:

        wl.minState = SCREEN_DIM;

        break;

       case PowerManager.PARTIAL_WAKE_LOCK:

       //PROXIMITY_SCREEN_OFF_WAKE_LOCK在SDK中並未輸出，原因是有部分手機並沒有接近

       //感測器

       casePowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK:

        break;

      default:

         return;

      }

   mLocks.addLock(wl);//將PMS.WakeLock物件儲存到mLocks中

    if (ws!= null) {

       wl.ws = new WorkSource(ws);

     }

     newlock= true;  //設定幾個引數資訊，newlock表示新建立了一個PMS.WakeLock物件

    diffsource = false;

    oldsource = null;

 }else{

   //如果之前儲存有PMS.WakeLock，則要判斷新傳入的WorkSource和之前儲存的WorkSource

   //是否一樣。此處不討論這種情況

   ......

}

  //isScreenLock用於判斷flags是否和螢幕有關，除PARTIAL_WAKE_LOCK外，其他WAKE_LOCK

  //都和螢幕有關

if (isScreenLock(flags)) {

  if ((flags& LOCK_MASK) == PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK) {

      mProximityWakeLockCount++;//引用計數控制

       if(mProximityWakeLockCount == 1) {

        enableProximityLockLocked();//使能Proximity感測器

        }

   } else {

   if((wl.flags & PowerManager.ACQUIRE_CAUSES_WAKEUP) != 0) {

     ......//ACQUIRE_CAUSES_WAKEUP標誌處理

  } else {

   //①gatherState返回一個狀態，稍後分析該函式

  mWakeLockState = (mUserState | mWakeLockState) &mLocks.gatherState();

  }

   //②設定電源狀態，

   setPowerState(mWakeLockState | mUserState);

   }

 }

int gatherState()

{

    intresult = 0;

    int N =this.size();

    for (inti=0; i<N; i++) {

     WakeLock wl = this.get(i);

     if(wl.activated)

        if(isScreenLock(wl.flags))

          result |= wl.minState;//對系統中所有活躍PMS.WakeLock的狀態進行或操作

  }

   returnresult;

 }

提示讀者也可參考PowerManagerService中SCREEN_DIM等變數的定義。

setPowerState(mWakeLockState | mUserState);

提示 “一個小小的變數背後代表了一個很重要的case”，讀者能體會到嗎？

private void setPowerState(int state)

{//呼叫另外一個同名函式

 setPowerState(state, false,WindowManagerPolicy.OFF_BECAUSE_OF_TIMEOUT);

}

//setPowerState

private void setPowerState(int newState, booleannoChangeLights, int reason)

{

 synchronized (mLocks) {

  int err;

  if (noChangeLights)//在這種情況中，noChangeLights為false

    newState = (newState & ~LIGHTS_MASK) | (mPowerState &LIGHTS_MASK);

  if(mProximitySensorActive)//如果開啟了接近感應器，就不需要在這裡點亮螢幕了

    newState = (newState & ~SCREEN_BRIGHT);

  if(batteryIsLow())//判斷是否處於低電狀態

     newState |= BATTERY_LOW_BIT;

   else

     newState &= ~BATTERY_LOW_BIT;

 ......

  //如果還沒啟動完成，則需要將newState置為ALL_BRIGHT。細心的讀者有沒有發現，在手機開機過程中

  //鍵盤、螢幕、按鍵等都會全部點亮一會兒呢？

  if(!mBootCompleted && !mUseSoftwareAutoBrightness)

      newState |= ALL_BRIGHT;

   booleanoldScreenOn = (mPowerState & SCREEN_ON_BIT) != 0;

   boolean newScreenOn = (newState &SCREEN_ON_BIT) != 0;

   finalboolean stateChanged = mPowerState != newState;

   if(oldScreenOn != newScreenOn) {

      if(newScreenOn) {

         if(mStillNeedSleepNotification) {

            //對sendNotificationLocked函式的分析見後文

            sendNotificationLocked(false,

                                      WindowManagerPolicy.OFF_BECAUSE_OF_USER);

        }// mStillNeedSleepNotification判斷

     booleanreallyTurnScreenOn = true;

     if(mPreventScreenOn)// mPreventScreenOn是何方神聖？

         reallyTurnScreenOn= false;

    if(reallyTurnScreenOn) {

     err = setScreenStateLocked(true);//點亮螢幕

     ......//通知mBatteryStats做電量統計

       mBatteryStats.noteScreenBrightness(getPreferredBrightness());

      mBatteryStats.noteScreenOn();

   } else {//reallyTurnScreenOn為false

      setScreenStateLocked(false);//關閉螢幕

       err =0;

   }

    if (err == 0) {

     sendNotificationLocked(true, -1);

      if(stateChanged)

          updateLightsLocked(newState, 0);//點亮按鍵燈或者鍵盤燈

     mPowerState |= SCREEN_ON_BIT;

  }

 }

注意閃屏的問題似乎解決了，但事情還沒完，這個解決方案還引入了另外一個問題：假設應用忘記重新使螢幕點亮，手機豈不是一直就黑屏了？為此，在程式碼中增加了一段處理邏輯，即如果5秒鐘後應用還沒有使螢幕點亮，PMS將自己設定mPreventScreenOn為false。

Google怎麼會寫這種程式碼？還好，程式碼開發者也意識到這是一個很難看的方法，只是目前還沒有一個比較完美的解決方案而已。

  else {//newScreenOn為false的情況

    ......//更新鍵盤燈、按鍵燈的狀態

   //從mHandler中移除mAutoBrightnessTask，這和光感測器有關。此處不討論

    mHandler.removeCallbacks(mAutoBrightnessTask);

    mBatteryStats.noteScreenOff();//通知BatteryStatsService,螢幕已關

   mPowerState = (mPowerState & ~LIGHTS_MASK) | (newState & LIGHTS_MASK);

   updateNativePowerStateLocked();

   }

  }//if(oldScreenOn != newScreenOn)判斷結束

  else if(stateChanged) {//螢幕的狀態不變，但是light的狀態有可能變化，所以

  updateLightsLocked(newState, 0);//單獨更新light的狀態

   }

  mPowerState= (mPowerState & ~LIGHTS_MASK) | (newState & LIGHTS_MASK);

  updateNativePowerStateLocked();

}//setPowerState完畢

private void sendNotificationLocked(boolean on,int why) {

  ......

  if (!on) {

    mStillNeedSleepNotification = false;

  }

  int index= 0;

  while(mBroadcastQueue[index] != -1) {

       index++;

  }

  // mBroadcastQueue和mBroadcastWhy均定義為int陣列，成員個數為3，它們有什麼作用呢

 mBroadcastQueue[index] = on ? 1 : 0;

 mBroadcastWhy[index] = why;

  /* mBroadcastQueue陣列一共有3個元素，根據程式碼中的註釋，其作用如下：

    當取得的index為2時，即0,1元素已經有值，由於螢幕ON/OFF請求是配對的，所以在這種情況

    下只需要處理最後一次的請求。例如0元素為ON，1元素為OFF，2元素為ON，則可以去掉0，

    1的請求，而直接處理2的請求，即螢幕ON。對於那種頻繁按Power鍵的操作，通過這種方式可以

    節省一次切換操作

  */

  if (index== 2) {

     if (!on&& mBroadcastWhy[0] > why) mBroadcastWhy[0] = why;

     //處理index為2的情況，見上文的說明

    mBroadcastQueue[0] = on ? 1 : 0;

    mBroadcastQueue[1] = -1;

    mBroadcastQueue[2] = -1;

     mBroadcastWakeLock.release();

     index =0;

   }

   /*

     如果index為1，on為false，即螢幕發出關閉請求，則無需處理。根據註釋中的說明，

     在此種情況，螢幕已經處於OFF狀態，所以無需處理。為什麼在此種情況下螢幕已經關閉了呢？

   */

   if (index== 1 && !on) {

       mBroadcastQueue[0] = -1;

       mBroadcastQueue[1] = -1;

       index = -1;

       mBroadcastWakeLock.release();

   }

   if(mSkippedScreenOn) {

      updateLightsLocked(mPowerState, SCREEN_ON_BIT);

    }

   //如果index不為負數，則拋送mNotificationTask給mHandler處理

   if (index>= 0) {

      mBroadcastWakeLock.acquire();

       mHandler.post(mNotificationTask);

    }

 }

private Runnable mNotificationTask = newRunnable()

{

  publicvoid run()

 {

   while(true) {//此處是一個while迴圈

    intvalue;

    int why;

   WindowManagerPolicy policy;

   synchronized (mLocks) {

       value =mBroadcastQueue[0];//取mBroadcastQueue第一個元素

       why= mBroadcastWhy[0];

       for(int i=0; i<2; i++) {//將後面的元素往前挪一位

           mBroadcastQueue[i] = mBroadcastQueue[i+1];

           mBroadcastWhy[i] = mBroadcastWhy[i+1];

        }

      policy = getPolicyLocked();//policy指向PhoneWindowManager

      if(value == 1 && !mPreparingForScreenOn) {

             mPreparingForScreenOn = true;

              mBroadcastWakeLock.acquire();

         }

      }// synchronized結束

    if(value == 1) {//value為1，表示發出螢幕ON請求

       mScreenOnStart = SystemClock.uptimeMillis();

        //和WindowManagerService互動，和鎖屏介面有關

         //mScreenOnListener為回撥通知物件

         policy.screenTurningOn(mScreenOnListener);

         ActivityManagerNative.getDefault().wakingUp();//和AMS互動

         if (mContext != null &&ActivityManagerNative.isSystemReady()) {

           //傳送SCREEN_ON廣播

            mContext.sendOrderedBroadcast(mScreenOnIntent,null,

              mScreenOnBroadcastDone, mHandler, 0, null, null);

        }......

      }elseif (value == 0) {

         mScreenOffStart = SystemClock.uptimeMillis();

          policy.screenTurnedOff(why);//通知WindowManagerService

          ActivityManagerNative.getDefault().goingToSleep();//和AMS互動

           if(mContext != null && ActivityManagerNative.isSystemReady()) {

                        //傳送螢幕OFF廣播

                mContext.sendOrderedBroadcast(mScreenOffIntent, null,

                                mScreenOffBroadcastDone, mHandler, 0, null,null);

            }

       }elsebreak；

     }

 };

else if ((flags & LOCK_MASK) == PowerManager.PARTIAL_WAKE_LOCK){

    if(newlock) {

   mPartialCount++;

   }

   //獲取kernel層的PARTIAL_WAKE_LOCK，該函式後續再分析

   Power.acquireWakeLock(Power.PARTIAL_WAKE_LOCK,PARTIAL_NAME);

  }//else if判斷結束

   if(diffsource) {

   noteStopWakeLocked(wl, oldsource);

  }

  if(newlock || diffsource) {

      noteStartWakeLocked(wl, ws);//通知BatteryStatsService做電量統計

 }

int setScreenState(boolean on);//開啟或關閉螢幕光

int setLastUserActivityTimeout(long ms);//設定超時時間

void reboot(String reason);//用於手機重啟，內部呼叫rebootNative

void shutdown();//已作廢，建議不要呼叫

void acquireWakeLock(int lock, String id);//獲取Kernel層的WakeLock

void releaseWakeLock(String id);//釋放Kernel層的WakeLock

static void acquireWakeLock(JNIEnv *env, jobjectclazz, jint lock, jstring idObj)

{

 ......

    constchar *id = env->GetStringUTFChars(idObj, NULL);

   acquire_wake_lock(lock, id);//呼叫此函式和Kernel層互動

   env->ReleaseStringUTFChars(idObj, id);

}

static void releaseWakeLock(JNIEnv *env, jobjectclazz, jstring idObj)

{

    constchar *id = env->GetStringUTFChars(idObj, NULL);

   release_wake_lock(id);//釋放Kernel層的WakeLock

    env->ReleaseStringUTFChars(idObj,id);

}

static int setLastUserActivityTimeout(JNIEnv *env,jobject clazz, jlong timeMS)

{

    returnset_last_user_activity_timeout(timeMS/1000);//設定超時時間

}

static int setScreenState(JNIEnv *env, jobjectclazz, jboolean on)

{

    return set_screen_state(on);//開啟或關閉螢幕光

}

static void android_os_Power_shutdown(JNIEnv *env,jobject clazz)

{

   android_reboot(ANDROID_RB_POWEROFF, 0, 0);//關機

}

static void android_os_Power_reboot(JNIEnv *env,jobject clazz, jstring reason)

{

    if (reason== NULL) {

       android_reboot(ANDROID_RB_RESTART, 0, 0);//重啟

    } else {

       const char *chars = env->GetStringUTFChars(reason, NULL);

       android_reboot(ANDROID_RB_RESTART2, 0, (char *) chars);//重啟

       env->ReleaseStringUTFChars(reason, chars);

    }

   jniThrowIOException(env, errno);

}

static jint init_native(JNIEnv *env, jobjectclazz)

{

    int err;

   hw_module_t* module;

    Devices*devices;

    devices= (Devices*)malloc(sizeof(Devices));

    //初始化硬體相關的模組，模組名為“lights”

    err =hw_get_module(LIGHTS_HARDWARE_MODULE_ID,

                             (hw_module_tconst**)&module);

    if (err== 0) {

       devices->lights[LIGHT_INDEX_BACKLIGHT]//背光

               = get_device(module, LIGHT_ID_BACKLIGHT);

       devices->lights[LIGHT_INDEX_KEYBOARD]//鍵盤燈

               = get_device(module, LIGHT_ID_KEYBOARD);

       devices->lights[LIGHT_INDEX_BUTTONS]//按鍵燈

               = get_device(module, LIGHT_ID_BUTTONS);

       devices->lights[LIGHT_INDEX_BATTERY]//電源指示燈

               = get_device(module, LIGHT_ID_BATTERY);

       devices->lights[LIGHT_INDEX_NOTIFICATIONS] //通知燈

               = get_device(module, LIGHT_ID_NOTIFICATIONS);

       devices->lights[LIGHT_INDEX_ATTENTION] //警示燈

               = get_device(module, LIGHT_ID_ATTENTION);

       devices->lights[LIGHT_INDEX_BLUETOOTH] //藍芽提示燈

               = get_device(module, LIGHT_ID_BLUETOOTH);

       devices->lights[LIGHT_INDEX_WIFI] //WIFI提示燈

               = get_device(module, LIGHT_ID_WIFI);

    } else {

       memset(devices, 0, sizeof(Devices));

    }

    return(jint)devices;

}

static void setLight_native(JNIEnv *env, jobjectclazz, int ptr,

        intlight, int colorARGB, int flashMode, int onMS, int offMS,

        intbrightnessMode)

{

    Devices*devices = (Devices*)ptr;

   light_state_t state;

    ......

   memset(&state, 0, sizeof(light_state_t));

   state.color = colorARGB;   //設定顏色

   state.flashMode = flashMode; //設定閃光模式

   state.flashOnMS = onMS;  //和閃光模式有關，例如亮2秒，滅2秒

   state.flashOffMS = offMS;

   state.brightnessMode = brightnessMode;//

    //傳遞給HAL層模組進行處理

   devices->lights[light]->set_light(devices->lights[light],&state);

}

private void updateNativePowerStateLocked() {

       nativeSetPowerState(//呼叫native函式，傳入兩個引數

               (mPowerState & SCREEN_ON_BIT) != 0,

               (mPowerState & SCREEN_BRIGHT) == SCREEN_BRIGHT);

    }

//jni層實現程式碼如下

static void android_server_PowerManagerService_nativeSetPowerState(

       JNIEnv* env,jobject serviceObj, jboolean screenOn, jbooleanscreenBright) {

   AutoMutex _l(gPowerManagerLock);

   gScreenOn = screenOn;//螢幕是否開啟

   gScreenBright = screenBright; //螢幕光是否全亮

}

 public voiduserActivity(long time, boolean noChangeLights) {

    ......//檢查呼叫程式是否有DEVICE_POWER的許可權

   userActivity(time, -1, noChangeLights, OTHER_EVENT, false);

 }

private void userActivity(long time, long timeoutOverride,

              boolean noChangeLights,inteventType, boolean force) {

   if(((mPokey & POKE_LOCK_IGNORE_TOUCH_EVENTS) != 0) &&

                 (eventType == TOUCH_EVENT)) {

   //mPokey和輸入事件的處理策略有關。如果此處的if判斷得到滿足，表示忽略TOUCH_EVENT

   return;

  }

   synchronized (mLocks) {

     if(isScreenTurningOffLocked()) {

          return;

      }

    if(mProximitySensorActive && mProximityWakeLockCount == 0)

          mProximitySensorActive = false;//控制接近感測器

    if(mLastEventTime <= time || force) {

         mLastEventTime = time;

          if((mUserActivityAllowed && !mProximitySensorActive) || force) {

               if (eventType == BUTTON_EVENT && !mUseSoftwareAutoBrightness) {

                     mUserState =(mKeyboardVisible ? ALL_BRIGHT :

                                      SCREEN_BUTTON_BRIGHT);

                   } else {

                        mUserState |=SCREEN_BRIGHT;//設定使用者事件導致的mUserState

                   }

                        ......//通知BatteryStatsService進行電量統計

                        mBatteryStats.noteUserActivity(uid,eventType);

               //重新計算WakeLock狀態

                mWakeLockState = mLocks.reactivateScreenLocksLocked();

               setPowerState(mUserState | mWakeLockState, noChangeLights,

                           WindowManagerPolicy.OFF_BECAUSE_OF_USER);

                //重新開始螢幕計時

                setTimeoutLocked(time, timeoutOverride, SCREEN_BRIGHT);

               }

           }

        }

        //mPolicy指向PhoneWindowManager，用於和WindowManagerService互動

        if(mPolicy != null) {

           mPolicy.userActivity();

        }

    }

private void setTimeoutLocked(long now, final longoriginalTimeoutOverride,

                                    intnextState) {

   //在本例中，nextState為SCREEN_BRIGHT，originalTimeoutOverride為-1

   longtimeoutOverride = originalTimeoutOverride;

   if(mBootCompleted) {

       synchronized (mLocks) {

        long when = 0;

         if(timeoutOverride <= 0) {

            switch (nextState)

            {

               case SCREEN_BRIGHT:

                 when = now + mKeylightDelay;//得到一個超時時間

                  break;

               case SCREEN_DIM:

                 if (mDimDelay >= 0) {

                     when = now + mDimDelay;

                      break;

                  } ......

                case SCREEN_OFF:

                  synchronized (mLocks) {

                      when = now +mScreenOffDelay;

                     }

                       break;

                  default:

                      when = now;

                      break;

           }

        }......//處理timeoutOverride大於零的情況，無非就是設定狀態和超時時間

      mHandler.removeCallbacks(mTimeoutTask);

      mTimeoutTask.nextState = nextState;

      mTimeoutTask.remainingTimeoutOverride = timeoutOverride > 0

                        ? (originalTimeoutOverride- timeoutOverride)

                        : -1;

       //拋送一個mTimeoutTask交給mHandler執行，執行時間為when秒後

      mHandler.postAtTime(mTimeoutTask, when);

      mNextTimeout = when; //除錯用

      }

    }

}

private class TimeoutTask implements Runnable

{

   intnextState;

   longremainingTimeoutOverride;

   publicvoid run()

   {

     synchronized (mLocks) {

        if(nextState == -1)return;

       mUserState = this.nextState;

        //呼叫setPowerState去真正改變螢幕狀態

        setPowerState(this.nextState| mWakeLockState);

        long now = SystemClock.uptimeMillis();

        switch (this.nextState)

         {

           case SCREEN_BRIGHT:

            if (mDimDelay >= 0) {//設定下一個狀態為SCREEN_DIM

                setTimeoutLocked(now,remainingTimeoutOverride, SCREEN_DIM);

                break;

             }

          case SCREEN_DIM://設定下一個狀態為SCREEN_OFF

            setTimeoutLocked(now, remainingTimeoutOverride, SCREEN_OFF);

            break;

         }......//省略花括號

 }

voidNativeInputManager::handleInterceptActions(jint wmActions, nsecs_t when,

                uint32_t& policyFlags) {

      //按下Power鍵並鬆開後，將設定wmActions為WM_ACTION_GO_TO_SLEEP，表示需要休眠

      if(wmActions & WM_ACTION_GO_TO_SLEEP) {

      //利用JNI呼叫PMS的goToSleep函式

     android_server_PowerManagerService_goToSleep(when);

   }

  //一般的輸入事件將觸發userActivity函式被呼叫，此時將喚醒手機

  if(wmActions & WM_ACTION_POKE_USER_ACTIVITY) {

      //利用JNI呼叫PMS的userActivity函式。相關內容在前一節已經分析過了

     android_server_PowerManagerService_userActivity(when,

                                  POWER_MANAGER_BUTTON_EVENT);

    }

      ......//其他處理

}

public void goToSleep(long time)

{

    goToSleepWithReason(time,WindowManagerPolicy.OFF_BECAUSE_OF_USER);

}

public void goToSleepWithReason(long time, intreason)

{

  mContext.enforceCallingOrSelfPermission(//檢查呼叫程式是否有DEVICE_POWER許可權

            android.Manifest.permission.DEVICE_POWER,null);

  synchronized (mLocks) {

        goToSleepLocked(time, reason);//呼叫goToSleepLocked函式

   }

 }

private void goToSleepLocked(long time, intreason) {

 if(mLastEventTime <= time) {

    mLastEventTime = time;

    mWakeLockState = SCREEN_OFF;

     int N= mLocks.size();

     intnumCleared = 0;

     boolean proxLock = false;

     for(int i=0; i<N; i++) {

      WakeLock wl = mLocks.get(i);

       if(isScreenLock(wl.flags)) {

          if(((wl.flags & LOCK_MASK) ==

                PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK)

               && reason == WindowManagerPolicy.OFF_BECAUSE_OF_PROX_SENSOR) {

                proxLock = true;//判斷goToSleep的原因是否與接近感測器有關

            } else{

               mLocks.get(i).activated = false;//禁止和螢幕相關的WakeLock

               numCleared++;

             }

        }// isScreenLock判斷結束

        }//for迴圈結束

       if(!proxLock) {

           mProxIgnoredBecauseScreenTurnedOff = true;

       }

       mStillNeedSleepNotification = true;

       mUserState = SCREEN_OFF;

       setPowerState(SCREEN_OFF, false, reason);//關閉螢幕

       cancelTimerLocked();//從mHandler中撤銷mTimeoutTask任務

    }

 }

battery = new BatteryService(context, lights);

ServiceManager.addService("battery",battery);

public BatteryService(Context context,LightsService lights) {

  mContext =context;

  mLed = newLed(context, lights);//提示燈控制，感興趣的讀者可自行閱讀相關程式碼

  //BatteryService也需要和BatteryStatsService互動

 mBatteryStats = BatteryStatsService.getService();

  //獲取一些配置引數

 mCriticalBatteryLevel = mContext.getResources().getInteger(

    com.android.internal.R.integer.config_criticalBatteryWarningLevel);

 mLowBatteryWarningLevel = mContext.getResources().getInteger(

    com.android.internal.R.integer.config_lowBatteryWarningLevel);

 mLowBatteryCloseWarningLevel = mContext.getResources().getInteger(

     com.android.internal.R.integer.config_lowBatteryCloseWarningLevel);

  //啟動uevent監聽物件，監視power_supply資訊

 mPowerSupplyObserver.startObserving("SUBSYSTEM=power_supply");

  //如果下列檔案存在，那麼啟動另一個uevent監聽物件。該uevent事件來自invalid charger

  //switch裝置（即不匹配的充電裝置）

 if (newFile("/sys/devices/virtual/switch/invalid_charger/state").exists()) {

     mInvalidChargerObserver.startObserving(

              "DEVPATH=/devices/virtual/switch/invalid_charger");

  }

   update();//①查詢HAL層，獲取此時的電池資訊

}

private synchronized final void update() {

 native_update();//到Native層查詢並更新內部變數的值

 processValues();//處理更新後的狀態

}

static voidandroid_server_BatteryService_update(JNIEnv* env, jobject obj)

{

   setBooleanField(env, obj, gPaths.acOnlinePath, gFieldIds.mAcOnline);

    ......//獲取電池資訊，並通過JNI設定到Java層對應的變數中

   setIntField(env, obj, gPaths.batteryTemperaturePath,

                  gFieldIds.mBatteryTemperature);

    constint SIZE = 128;

    charbuf[SIZE];

    //獲取資訊，以下引數並不是所有手機都支援的

    if(readFromFile(gPaths.batteryStatusPath, buf, SIZE) > 0)

       env->SetIntField(obj, gFieldIds.mBatteryStatus,getBatteryStatus(buf));

    else

       env->SetIntField(obj, gFieldIds.mBatteryStatus,

                            gConstants.statusUnknown);

   ......

}

提示 讀者可通過dumpsys battery檢視自己手機的電池資訊。

private void processValues() {

   longdischargeDuration = 0;

  mBatteryLevelCritical = mBatteryLevel <= mCriticalBatteryLevel;

   if (mAcOnline) {

     mPlugType = BatteryManager.BATTERY_PLUGGED_AC;

    } elseif (mUsbOnline) {

     mPlugType = BatteryManager.BATTERY_PLUGGED_USB;

    } else {

     mPlugType = BATTERY_PLUGGED_NONE;

   }

   //通知BatteryStatsService，該函式以後再分析

  mBatteryStats.setBatteryState(mBatteryStatus, mBatteryHealth,

              mPlugType, mBatteryLevel, mBatteryTemperature, mBatteryVoltage

              );

   shutdownIfNoPower();//如果電量不夠，彈出關機對話方塊

  shutdownIfOverTemp();//如果電池過熱，彈出關機對話方塊

   ......//根據當前電池資訊與上次電池資訊比較，判斷是否需要傳送廣播等

   if (比較前後兩次電池資訊是否發生變化) {

     ......//記錄資訊到日誌檔案

     Intent statusIntent = new Intent();

     statusIntent.setFlags(

             Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);

     if (mPlugType != 0 && mLastPlugType ==0) {

       statusIntent.setAction(Intent.ACTION_POWER_CONNECTED);

               mContext.sendBroadcast(statusIntent);

      }......

    if(sendBatteryLow) {

        mSentLowBatteryBroadcast = true;//傳送低電提醒

       statusIntent.setAction(Intent.ACTION_BATTERY_LOW);

       mContext.sendBroadcast(statusIntent);

     } ......

     mLed.updateLightsLocked();//更新LED燈狀態

    mLastBatteryStatus= mBatteryStatus;//儲存新的電池資訊

    ......

}

private ActivityManagerService() {

     ......//建立BSS物件，傳遞一個File物件，指向/data/system/batterystats.bin

     mBatteryStatsService= new BatteryStatsService(new File(

               systemDir, "batterystats.bin").toString());

}

//呼叫BSS的publish函式，在內部將其註冊到ServiceManager

m.mBatteryStatsService.publish(context);

BatteryStatsService(String filename) {

    mStats = new BatteryStatsImpl(filename);

}

public byte[] getStatistics() {

   mContext.enforceCallingPermission(//檢查呼叫程式是否有BATTERY_STATS許可權

        android.Manifest.permission.BATTERY_STATS, null);

  Parcel out= Parcel.obtain();

 mStats.writeToParcel(out, 0);//將BSImpl資訊寫到資料包中

  byte[]data = out.marshall();//序列化為一個buffer，然後通過Binder傳遞

 out.recycle();

  returndata;

 }

public BatteryStatsImpl(String filename) {

   //JournaledFile為日誌檔案物件，內部包含兩個檔案，原始檔案和臨時檔案。目的是雙備份，

   //以防止在讀寫過程中檔案資訊丟失或出錯

   mFile =new JournaledFile(new File(filename), new File(filename + ".tmp"));

   mHandler= new MyHandler();//建立一個Handler物件

  mStartCount++;

   //建立表5-5中的用電統計項物件

  mScreenOnTimer = new StopwatchTimer(null, -1, null, mUnpluggables);

   for (inti=0; i<NUM_SCREEN_BRIGHTNESS_BINS; i++) {

      mScreenBrightnessTimer[i] = new StopwatchTimer(null, -100-i, null,

               mUnpluggables);

   }

  mInputEventCounter = new Counter(mUnpluggables);

   ......

   mOnBattery= mOnBatteryInternal = false;//設定這兩位成員變數為false

  initTimes();//①初始化統計時間

  mTrackBatteryPastUptime = 0;

  mTrackBatteryPastRealtime = 0;

   mUptimeStart= mTrackBatteryUptimeStart =

                             SystemClock.uptimeMillis()* 1000;

   mRealtimeStart= mTrackBatteryRealtimeStart =

                                SystemClock.elapsedRealtime()* 1000;

  mUnpluggedBatteryUptime = getBatteryUptimeLocked(mUptimeStart);

  mUnpluggedBatteryRealtime = getBatteryRealtimeLocked(mRealtimeStart);

  mDischargeStartLevel = 0;

  mDischargeUnplugLevel = 0;

  mDischargeCurrentLevel = 0;

  initDischarge();     //②初始化和電池level有關的成員變數

  clearHistoryLocked();//③刪除用電統計的歷史記錄

 }

//呼叫方式

mPhoneSignalScanningTimer = newStopwatchTimer(null, -200+1,

                                   null,mUnpluggables);

//mUnpluggables型別為ArrayList<Unpluggable>，用於儲存插拔USB線時需要對應更新用電

//資訊的統計物件

// StopwatchTimer的建構函式

StopwatchTimer(Uid uid, int type,ArrayList<StopwatchTimer> timerPool,

                 ArrayList<Unpluggable>unpluggables) {

   //在本例中，uid為0，type為負數，timerPool為空，unpluggables為mUnpluggables

  super(type, unpluggables);

   mUid =uid;

  mTimerPool = timerPool;

}

// Timer的建構函式

Timer(int type, ArrayList<Unpluggable>unpluggables) {

     mType =type;

    mUnpluggables = unpluggables;

    unpluggables.add(this);

}

void startRunningLocked(BatteryStatsImpl stats) {

  if(mNesting++ == 0) {//巢狀呼叫控制

        // getBatteryRealtimeLocked函式返回總的電池使用時間

       mUpdateTime = stats.getBatteryRealtimeLocked(

                            SystemClock.elapsedRealtime()* 1000);

         if (mTimerPool != null) {//不討論這種情況

         }

        mCount++;

        mAcquireTime = mTotalTime;//計數控制，請讀者閱讀相關注釋說明

       }

   }

void stopRunningLocked(BatteryStatsImpl stats) {

  if (mNesting == 0) {

     return; //巢狀控制

  }

  if(--mNesting == 0) {

       if(mTimerPool != null) {//不討論這種情況

        }else {

        final long realtime = SystemClock.elapsedRealtime() * 1000;

         //計算此次啟動/停止週期的時間

        final long batteryRealtime = stats.getBatteryRealtimeLocked(realtime);

          mNesting = 1;

          //mTotalTime代表從啟動開始該秒停表一共記錄的時間

         mTotalTime = computeRunTimeLocked(batteryRealtime);

         mNesting = 0;

          }

       if (mTotalTime == mAcquireTime)  mCount--;

     }

 }

mBatteryStatsService = new BatteryStatsService(newFile(

               systemDir, "batterystats.bin").toString());

  //操作通過BSImpl建立的JournaledFile檔案

 mBatteryStatsService.getActiveStatistics().readLocked();

 mBatteryStatsService.getActiveStatistics().writeAsyncLocked();

  //BSImpl的getIsOnBattery返回mOnBattery變數，初始化值為false

  mOnBattery= DEBUG_POWER ? true

           : mBatteryStatsService.getActiveStatistics().getIsOnBattery();

   //設定回撥，該回撥也是用於資訊統計，只能留到介紹ActivityManagerService時再來分析了

mBatteryStatsService.getActiveStatistics().setCallback(this);

m.mBatteryStatsService.publish(context);

public void publish(Context context) {

  mContext =context;

  //注意，BSS服務叫做batteryinfo，而BatteryService服務叫做battery

 ServiceManager.addService("batteryinfo", asBinder());

  //PowerProfile見下文解釋

 mStats.setNumSpeedSteps(new PowerProfile(mContext).getNumSpeedSteps());

  //設定通訊訊號掃描超時時間

 mStats.setRadioScanningTimeout(mContext.getResources().getInteger(

             com.android.internal.R.integer.config_radioScanningTimeout)

              * 1000L);

    }

注意在編譯時，各廠家會將特定硬體平臺的power_profile.xml複製到輸出目錄。此處展示的power_profile.xml和硬體平臺無關。

private void processValues() {

   ......

   mBatteryStats.setBatteryState(mBatteryStatus,mBatteryHealth, mPlugType,

                 mBatteryLevel, mBatteryTemperature,mBatteryVoltage);

}

public void setBatteryState(int status, inthealth, int plugType, int level,

                                int temp, int volt) {

  synchronized(this) {

      boolean onBattery = plugType == BATTERY_PLUGGED_NONE;//判斷是否為電池供電

       intoldStatus = mHistoryCur.batteryStatus;

       ......

        if(onBattery) {

            //mDischargeCurrentLevel記錄當前使用電池供電時的電池電量

            mDischargeCurrentLevel = level;

            mRecordingHistory = true;//mRecordingHistory表示需要記錄一次歷史值

         }

       //此時,onBattery為當前狀態，mOnBattery為歷史狀態

      if(onBattery != mOnBattery) {

          mHistoryCur.batteryLevel = (byte)level;

          mHistoryCur.batteryStatus = (byte)status;

           mHistoryCur.batteryHealth = (byte)health;

           ......//更新mHistoryCur中的電池資訊

               setOnBatteryLocked(onBattery, oldStatus, level);

           } else {

               boolean changed = false;

               if (mHistoryCur.batteryLevel != level) {

                   mHistoryCur.batteryLevel = (byte)level;

                   changed = true;

               }

               ......//判斷電池資訊是否發生變化

               if (changed) {//如果發生變化，則需要增加一次歷史記錄

                   addHistoryRecordLocked(SystemClock.elapsedRealtime());

               }

           }

           if (!onBattery && status == BatteryManager.BATTERY_STATUS_FULL){

               mRecordingHistory = false;

           }

        }

    }

void setOnBatteryLocked(boolean onBattery, intoldStatus, int level) {

   boolean doWrite = false;

   //傳送一個訊息給mHandler，將在內部呼叫ActivityManagerService設定的回撥函式

   Message m= mHandler.obtainMessage(MSG_REPORT_POWER_CHANGE);

   m.arg1 =onBattery ? 1 : 0;

  mHandler.sendMessage(m);

  mOnBattery = mOnBatteryInternal = onBattery;

   longuptime = SystemClock.uptimeMillis() * 1000;

   longmSecRealtime = SystemClock.elapsedRealtime();

   longrealtime = mSecRealtime * 1000;

   if(onBattery) {

       //關於電量資訊統計，有一個值得注意的地方：當oldStatus為滿電狀態，或當前電量

      //大於90，或mDischargeCurrentLevel小於20並且當前電量大於80時，要清空統計

      //資訊，以開始新的統計。也就是說在滿足特定條件的情況下，電量使用統計資訊會清零並重

     //新開始。讀者不妨用自己手機一試

       if(oldStatus == BatteryManager.BATTERY_STATUS_FULL || level >= 90

           || (mDischargeCurrentLevel < 20 && level >= 80)) {

           doWrite = true;

           resetAllStatsLocked();

           mDischargeStartLevel = level;

       }

        //讀取/proc/wakelock檔案，該檔案反映了系統wakelock的使用狀態，

        //感興趣的讀者可自行研究

       updateKernelWakelocksLocked();

       mHistoryCur.batteryLevel = (byte)level;

       mHistoryCur.states &= ~HistoryItem.STATE_BATTERY_PLUGGED_FLAG;

        //新增一條歷史記錄

        addHistoryRecordLocked(mSecRealtime);

        //mTrackBatteryUptimeStart表示使用電池的開始時間，由uptime表示

       mTrackBatteryUptimeStart = uptime;

        // mTrackBatteryRealtimeStart表示使用電池的開始時間，由realtime表示

       mTrackBatteryRealtimeStart = realtime;

        //mUnpluggedBatteryUptime記錄總的電池使用時間（不論中間插拔多少次）

       mUnpluggedBatteryUptime = getBatteryUptimeLocked(uptime);

        // mUnpluggedBatteryRealtime記錄總的電池使用時間

       mUnpluggedBatteryRealtime = getBatteryRealtimeLocked(realtime);

        //記錄電量

        mDischargeCurrentLevel =mDischargeUnplugLevel = level;

        if(mScreenOn) {

            mDischargeScreenOnUnplugLevel = level;

            mDischargeScreenOffUnplugLevel = 0;

          }else {

              mDischargeScreenOnUnplugLevel = 0;

             mDischargeScreenOffUnplugLevel = level;

          }

         mDischargeAmountScreenOn = 0;

         mDischargeAmountScreenOff = 0;

          //呼叫doUnplugLocked函式

         doUnplugLocked(mUnpluggedBatteryUptime, mUnpluggedBatteryRealtime);

        }else {

            ......//處理使用USB充電的情況，請讀者在上面討論的基礎上自行分析

        }

      ......//記錄資訊到檔案

      }

    }

public void noteScreenOnLocked() {

   if(!mScreenOn) {

     mHistoryCur.states |= HistoryItem.STATE_SCREEN_ON_FLAG;

      //增加一條歷史記錄

      addHistoryRecordLocked(SystemClock.elapsedRealtime());

     mScreenOn = true;

     //啟動mScreenOnTime秒停表，內部就是記錄時間，讀者可自行研究

     mScreenOnTimer.startRunningLocked(this);

      if(mScreenBrightnessBin >= 0)//啟動對應螢幕亮度的秒停表（參考表5-5）

       mScreenBrightnessTimer[mScreenBrightnessBin].startRunningLocked(this);

      //螢幕開啟也和核心WakeLock有關，所以這裡一樣要更新WakeLock的用電統計

     noteStartWakeLocked(-1, -1, "dummy", WAKE_TYPE_PARTIAL);

      if(mOnBatteryInternal)

        updateDischargeScreenLevelsLocked(false, true);

     }

 }

//BSS的noteUserActivity將呼叫BSImpl的noteUserActivityLocked

public void noteUserActivityLocked(int uid, intevent) {

        getUidStatsLocked(uid).noteUserActivityLocked(event);

}

public void noteUserActivityLocked(int type) {

 if(mUserActivityCounters == null) {

    initUserActivityLocked();

   }

  if (type< 0) type = 0;

  else if(type >= NUM_USER_ACTIVITY_TYPES)

     type= NUM_USER_ACTIVITY_TYPES-1;

   // noteUserActivityLocked只是呼叫對應type的Counter的stepAtomic函式

   //每個Counter內部都有個計數器，stepAtomic使該計數器增1

  mUserActivityCounters[type].stepAtomic();

}

static final String[] USER_ACTIVITY_TYPES = {

 "other", "cheek", "touch","long_touch", "touch_up", "button", "unknown"

};

public interface LocalPowerManager {

    publicstatic final int OTHER_EVENT = 0;

    publicstatic final int BUTTON_EVENT = 1;

    publicstatic final int TOUCH_EVENT = 2; //目前只使用這三種事件

    ......

}

注意雖然Google費盡心血來完善電量統計，但這並不是解決耗電量大的根本途徑。另外，讀者可分析Settings程式中電量統計圖的繪製以加深對各種統計物件的理解。Settings中和電量相關的檔案在Android 4.0原始碼的/packages/apps/Settings/src/com/android/settings/fuelgauge/目錄中。