Android 6.0 PowerManagerService状态分析

最新推荐文章于 2023-10-13 11:06:47 发布
最新推荐文章于 2023-10-13 11:06:47 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： Android深度探索 Android / Power Manager Service Android Framework Android 6.0 文章标签： Android Power Manager Servic Power Manager
本文详细分析了Android系统中PowerManagerService的四个关键函数：goToSleep、wakeUp、userActivity和nap。通过这些函数的深入解读，揭示了设备进入不同状态的内部逻辑。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

这篇博客我们主要分析下PowerManagerService的各个状态，主要从goToSleep，wakeUp，userActivity，nap函数作为入口分析。

一、PowerManagerService的goToSleep函数

我们先来看下goToSleep函数：

goToSleep函数主要调用了goToSleepInternal函数：

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void goToSleepInternal(long eventTime, int reason, int flags, int uid) {  
  2.     synchronized (mLock) {  
  3.         if (goToSleepNoUpdateLocked(eventTime, reason, flags, uid)) {  
  4.             updatePowerStateLocked();  
  5.         }  
  6.     }  
  7. }  

我们再来看看goToSleepNoUpdateLocked函数

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private boolean goToSleepNoUpdateLocked(long eventTime, int reason, int flags, int uid) {  
  2.     if (eventTime < mLastWakeTime  
  3.             || mWakefulness == WAKEFULNESS_ASLEEP  
  4.             || mWakefulness == WAKEFULNESS_DOZING  
  5.             || !mBootCompleted || !mSystemReady) {  
  6.         return false;  
  7.     }  
  8.   
  9.     Trace.traceBegin(Trace.TRACE_TAG_POWER, "goToSleep");  
  10.     try {  
  11.         switch (reason) {//打印原因  
  12.             case PowerManager.GO_TO_SLEEP_REASON_DEVICE_ADMIN:  
  13.                 Slog.i(TAG, "Going to sleep due to device administration policy "  
  14.                         + "(uid " + uid +")...");  
  15.                 break;  
  16.             case PowerManager.GO_TO_SLEEP_REASON_TIMEOUT:  
  17.                 Slog.i(TAG, "Going to sleep due to screen timeout (uid " + uid +")...");  
  18.                 break;  
  19.             case PowerManager.GO_TO_SLEEP_REASON_LID_SWITCH:  
  20.                 Slog.i(TAG, "Going to sleep due to lid switch (uid " + uid +")...");  
  21.                 break;  
  22.             case PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON:  
  23.                 Slog.i(TAG, "Going to sleep due to power button (uid " + uid +")...");  
  24.                 break;  
  25.             case PowerManager.GO_TO_SLEEP_REASON_SLEEP_BUTTON:  
  26.                 Slog.i(TAG, "Going to sleep due to sleep button (uid " + uid +")...");  
  27.                 break;  
  28.             case PowerManager.GO_TO_SLEEP_REASON_HDMI:  
  29.                 Slog.i(TAG, "Going to sleep due to HDMI standby (uid " + uid +")...");  
  30.                 break;  
  31.             default:  
  32.                 Slog.i(TAG, "Going to sleep by application request (uid " + uid +")...");  
  33.                 reason = PowerManager.GO_TO_SLEEP_REASON_APPLICATION;  
  34.                 break;  
  35.         }  
  36.   
  37.         mLastSleepTime = eventTime;  
  38.         mSandmanSummoned = true;  
  39.         setWakefulnessLocked(WAKEFULNESS_DOZING, reason);//置状态  
  40.   
  41.         // Report the number of wake locks that will be cleared by going to sleep.  
  42.         int numWakeLocksCleared = 0;  
  43.         final int numWakeLocks = mWakeLocks.size();  
  44.         for (int i = 0; i < numWakeLocks; i++) {//统计将会被清除的WakeLock  
  45.             final WakeLock wakeLock = mWakeLocks.get(i);  
  46.             switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) {  
  47.                 case PowerManager.FULL_WAKE_LOCK:  
  48.                 case PowerManager.SCREEN_BRIGHT_WAKE_LOCK:  
  49.                 case PowerManager.SCREEN_DIM_WAKE_LOCK:  
  50.                     numWakeLocksCleared += 1;  
  51.                     break;  
  52.             }  
  53.         }  
  54.         EventLog.writeEvent(EventLogTags.POWER_SLEEP_REQUESTED, numWakeLocksCleared);  
  55.   
  56.         // Skip dozing if requested.  
  57.         if ((flags & PowerManager.GO_TO_SLEEP_FLAG_NO_DOZE) != 0) {  
  58.             reallyGoToSleepNoUpdateLocked(eventTime, uid);//有这个flag直接进入sleep。而不用先进入WAKEFULNESS_DOZING状态  
  59.         }  
  60.     } finally {  
  61.         Trace.traceEnd(Trace.TRACE_TAG_POWER);  
  62.     }  
  63.     return true;  
  64. }  

上面函数会先调用setWakefulnessLocked来设置PowerManagerService的状态，我们来看下这个函数：

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void setWakefulnessLocked(int wakefulness, int reason) {  
  2.     if (mWakefulness != wakefulness) {  
  3.         mWakefulness = wakefulness;  
  4.         mWakefulnessChanging = true;  
  5.         mDirty |= DIRTY_WAKEFULNESS;  
  6.         mNotifier.onWakefulnessChangeStarted(wakefulness, reason);  
  7.     }  
  8. }  

我们来看这个Notifier的onWakefulnessChangeStarted函数：

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public void onWakefulnessChangeStarted(final int wakefulness, int reason) {  
  2.     final boolean interactive = PowerManagerInternal.isInteractive(wakefulness);  
  3.   
  4.     // Tell the activity manager about changes in wakefulness, not just interactivity.  
  5.     // It needs more granularity than other components.  
  6.     mHandler.post(new Runnable() {  
  7.         @Override  
  8.         public void run() {  
  9.             mActivityManagerInternal.onWakefulnessChanged(wakefulness);//调用AMS的onWakefulnessChanged函数  
  10.         }  
  11.     });  
  12.   
  13.     // Handle any early interactive state changes.  
  14.     // Finish pending incomplete ones from a previous cycle.  
  15.     if (mInteractive != interactive) {  
  16.         // Finish up late behaviors if needed.  
  17.         if (mInteractiveChanging) {  
  18.             handleLateInteractiveChange();  
  19.         }  
  20.   
  21.         // Start input as soon as we start waking up or going to sleep.  
  22.         mInputManagerInternal.setInteractive(interactive);//Input设置状态，在PhoneWindowManager那篇博客有分析  
  23.         mInputMethodManagerInternal.setInteractive(interactive);  
  24.   
  25.         // Notify battery stats.  
  26.         try {  
  27.             mBatteryStats.noteInteractive(interactive);  
  28.         } catch (RemoteException ex) { }  
  29.   
  30.         // Handle early behaviors.  
  31.         mInteractive = interactive;  
  32.         mInteractiveChangeReason = reason;  
  33.         mInteractiveChanging = true;  
  34.         handleEarlyInteractiveChange();  
  35.     }  
  36. }  

上面这个函数做了很多重要的事情，通知AMS调用onWakefulnessChanged函数来将之前的Activity resume。也会调用Inpu相关接口，这个我们在之前分析Power按键，到PhoneWindowManager的时候分析过，就是这个时候将power状态设置到Input中，保存在成员变量。然后又按键过来，将这个变量传到了PhoneWindowManager中。
还有在handleEarlyInteractiveChange函数中会发送灭屏和亮屏广播，以及通知PhoneWindowManager做一些事情，这个我会在之前专门写一篇关于Notifier的博客。


我们再回过头分析goToSleepNoUpdateLocked函数，如果睡眠的话，会调用reallyGoToSleepNoUpdateLocked函数，其实也就是将状态设置成睡眠的。

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private boolean reallyGoToSleepNoUpdateLocked(long eventTime, int uid) {  
  2.     if (DEBUG_SPEW) {  
  3.         Slog.d(TAG, "reallyGoToSleepNoUpdateLocked: eventTime=" + eventTime  
  4.                 + ", uid=" + uid);  
  5.     }  
  6.   
  7.     if (eventTime < mLastWakeTime || mWakefulness == WAKEFULNESS_ASLEEP  
  8.             || !mBootCompleted || !mSystemReady) {  
  9.         return false;  
  10.     }  
  11.   
  12.     Trace.traceBegin(Trace.TRACE_TAG_POWER, "reallyGoToSleep");  
  13.     try {  
  14.         Slog.i(TAG, "Sleeping (uid " + uid +")...");  
  15.   
  16.         setWakefulnessLocked(WAKEFULNESS_ASLEEP, PowerManager.GO_TO_SLEEP_REASON_TIMEOUT);//设置Power状态  
  17.     } finally {  
  18.         Trace.traceEnd(Trace.TRACE_TAG_POWER);  
  19.     }  
  20.     return true;  
  21. }  
然后我们再来看goToSleepInternal函数，当goToSleepNoUpdateLocked返回true，就会调用updatePowerStateLocked函数。

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void goToSleepInternal(long eventTime, int reason, int flags, int uid) {  
  2.     synchronized (mLock) {  
  3.         if (goToSleepNoUpdateLocked(eventTime, reason, flags, uid)) {  
  4.             updatePowerStateLocked();  
  5.         }  
  6.     }  
  7. }  


二、PowerManagerService的updatePowerStateLocked函数

我们来看下PowerManagerService最核心的函数updatePowerStateLocked：

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void updatePowerStateLocked() {  
  2.     if (!mSystemReady || mDirty == 0) {  
  3.         return;  
  4.     }  
  5.     if (!Thread.holdsLock(mLock)) {  
  6.         Slog.wtf(TAG, "Power manager lock was not held when calling updatePowerStateLocked");  
  7.     }  
  8.   
  9.     Trace.traceBegin(Trace.TRACE_TAG_POWER, "updatePowerState");  
  10.     try {  
  11.         // Phase 0: Basic state updates.  
  12.         updateIsPoweredLocked(mDirty);  
  13.         updateStayOnLocked(mDirty);  
  14.         updateScreenBrightnessBoostLocked(mDirty);  
  15.   
  16.         // Phase 1: Update wakefulness.  
  17.         // Loop because the wake lock and user activity computations are influenced  
  18.         // by changes in wakefulness.  
  19.         final long now = SystemClock.uptimeMillis();  
  20.         int dirtyPhase2 = 0;  
  21.         for (;;) {  
  22.             int dirtyPhase1 = mDirty;  
  23.             dirtyPhase2 |= dirtyPhase1;  
  24.             mDirty = 0;  
  25.   
  26.             updateWakeLockSummaryLocked(dirtyPhase1);  
  27.             updateUserActivitySummaryLocked(now, dirtyPhase1);  
  28.             if (!updateWakefulnessLocked(dirtyPhase1)) {  
  29.                 break;  
  30.             }  
  31.         }  
  32.   
  33.         // Phase 2: Update display power state.  
  34.         boolean displayBecameReady = updateDisplayPowerStateLocked(dirtyPhase2);  
  35.   
  36.         // Phase 3: Update dream state (depends on display ready signal).  
  37.         updateDreamLocked(dirtyPhase2, displayBecameReady);  
  38.   
  39.         // Phase 4: Send notifications, if needed.  
  40.         finishWakefulnessChangeIfNeededLocked();  
  41.   
  42.         // Phase 5: Update suspend blocker.  
  43.         // Because we might release the last suspend blocker here, we need to make sure  
  44.         // we finished everything else first!  
  45.         updateSuspendBlockerLocked();  
  46.     } finally {  
  47.         Trace.traceEnd(Trace.TRACE_TAG_POWER);  
  48.     }  
  49. }  


2.1 updateIsPoweredLocked函数

我们先来看第一个函数updateIsPoweredLocked函数，主要是电池的一些状态。当收到电池广播时，就是更新电池信息。

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void updateIsPoweredLocked(int dirty) {  
  2.     if ((dirty & DIRTY_BATTERY_STATE) != 0) {  
  3.         final boolean wasPowered = mIsPowered;  
  4.         final int oldPlugType = mPlugType;  
  5.         final boolean oldLevelLow = mBatteryLevelLow;  
  6.         mIsPowered = mBatteryManagerInternal.isPowered(BatteryManager.BATTERY_PLUGGED_ANY);//是否充电  
  7.         mPlugType = mBatteryManagerInternal.getPlugType();  
  8.         mBatteryLevel = mBatteryManagerInternal.getBatteryLevel();//现在的电量  
  9.         mBatteryLevelLow = mBatteryManagerInternal.getBatteryLevelLow();  
  10.   
  11.         if (wasPowered != mIsPowered || oldPlugType != mPlugType) {  
  12.             mDirty |= DIRTY_IS_POWERED;  
  13.   
  14.             // Update wireless dock detection state.  
  15.             final boolean dockedOnWirelessCharger = mWirelessChargerDetector.update(  
  16.                     mIsPowered, mPlugType, mBatteryLevel);  
  17.   
  18.             final long now = SystemClock.uptimeMillis();  
  19.             if (shouldWakeUpWhenPluggedOrUnpluggedLocked(wasPowered, oldPlugType,//充电方式改变是否需要点亮屏幕  
  20.                     dockedOnWirelessCharger)) {  
  21.                 wakeUpNoUpdateLocked(now, "android.server.power:POWER", Process.SYSTEM_UID,  
  22.                         mContext.getOpPackageName(), Process.SYSTEM_UID);  
  23.             }  
  24.             userActivityNoUpdateLocked(//触发userActivity事件  
  25.                     now, PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, Process.SYSTEM_UID);  
  26.   
  27.             // Tell the notifier whether wireless charging has started so that  
  28.             // it can provide feedback to the user.  
  29.             if (dockedOnWirelessCharger) {  
  30.                 mNotifier.onWirelessChargingStarted();  
  31.             }  
  32.         }  
  33.   
  34.         if (wasPowered != mIsPowered || oldLevelLow != mBatteryLevelLow) {//更新低功耗相关配置  
  35.             if (oldLevelLow != mBatteryLevelLow && !mBatteryLevelLow) {  
  36.                 if (DEBUG_SPEW) {  
  37.                     Slog.d(TAG, "updateIsPoweredLocked: resetting low power snooze");  
  38.                 }  
  39.                 mAutoLowPowerModeSnoozing = false;  
  40.             }  
  41.             updateLowPowerModeLocked();  
  42.         }  
  43.     }  
  44. }  

上面函数就是保存了一些电池信息，然后充电方式改变后是否唤醒屏幕，一些更新低功耗的配置。


2.2 updateStayOnLocked函数 

再来看updateStayOnLocked函数，mStayOnWhilePluggedInSetting这个配置为0，所以mStayOn只能为false

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void updateStayOnLocked(int dirty) {  
  2.     if ((dirty & (DIRTY_BATTERY_STATE | DIRTY_SETTINGS)) != 0) {  
  3.         final boolean wasStayOn = mStayOn;  
  4.         if (mStayOnWhilePluggedInSetting != 0  
  5.                 && !isMaximumScreenOffTimeoutFromDeviceAdminEnforcedLocked()) {  
  6.             mStayOn = mBatteryManagerInternal.isPowered(mStayOnWhilePluggedInSetting);  
  7.         } else {  
  8.             mStayOn = false;  
  9.         }  
  10.   
  11.         if (mStayOn != wasStayOn) {  
  12.             mDirty |= DIRTY_STAY_ON;  
  13.         }  
  14.     }  
  15. }  


2.3 updateScreenBrightnessBoostLocked函数

再来看updateScreenBrightnessBoostLocked函数，看这个接口之前我们先来看下这个接口：boostScreenBrightnessInternal 将屏幕点最亮

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void boostScreenBrightnessInternal(long eventTime, int uid) {  
  2.     synchronized (mLock) {  
  3.         if (!mSystemReady || mWakefulness == WAKEFULNESS_ASLEEP  
  4.                 || eventTime < mLastScreenBrightnessBoostTime) {  
  5.             return;  
  6.         }  
  7.   
  8.         Slog.i(TAG, "Brightness boost activated (uid " + uid +")...");  
  9.         mLastScreenBrightnessBoostTime = eventTime;  
  10.         if (!mScreenBrightnessBoostInProgress) {  
  11.             mScreenBrightnessBoostInProgress = true;//屏幕最亮的状态变量  
  12.             mNotifier.onScreenBrightnessBoostChanged();  
  13.         }  
  14.         mDirty |= DIRTY_SCREEN_BRIGHTNESS_BOOST;  
  15.   
  16.         userActivityNoUpdateLocked(eventTime,  
  17.                 PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, uid);  
  18.         updatePowerStateLocked();  
  19.     }  
  20. }  

再来看updateScreenBrightnessBoostLocked函数

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void updateScreenBrightnessBoostLocked(int dirty) {  
  2.     if ((dirty & DIRTY_SCREEN_BRIGHTNESS_BOOST) != 0) {  
  3.         if (mScreenBrightnessBoostInProgress) {//将屏幕最亮  
  4.             final long now = SystemClock.uptimeMillis();  
  5.             mHandler.removeMessages(MSG_SCREEN_BRIGHTNESS_BOOST_TIMEOUT);  
  6.             if (mLastScreenBrightnessBoostTime > mLastSleepTime) {  
  7.                 final long boostTimeout = mLastScreenBrightnessBoostTime +  
  8.                         SCREEN_BRIGHTNESS_BOOST_TIMEOUT;  
  9.                 if (boostTimeout > now) {//还没到时间（最亮屏幕）  
  10.                     Message msg = mHandler.obtainMessage(MSG_SCREEN_BRIGHTNESS_BOOST_TIMEOUT);  
  11.                     msg.setAsynchronous(true);  
  12.                     mHandler.sendMessageAtTime(msg, boostTimeout);  
  13.                     return;//发送消息退出  
  14.                 }  
  15.             }  
  16.             mScreenBrightnessBoostInProgress = false;//状态改变  
  17.             mNotifier.onScreenBrightnessBoostChanged();  
  18.             userActivityNoUpdateLocked(now,//触发userActivity事件  
  19.                     PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, Process.SYSTEM_UID);  
  20.         }  
  21.     }  
  22. }  

上面发送消息，最后处理函数：继续点亮屏幕。

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void handleScreenBrightnessBoostTimeout() { // runs on handler thread  
  2.     synchronized (mLock) {  
  3.         if (DEBUG_SPEW) {  
  4.             Slog.d(TAG, "handleScreenBrightnessBoostTimeout");  
  5.         }  
  6.   
  7.         mDirty |= DIRTY_SCREEN_BRIGHTNESS_BOOST;  
  8.         updatePowerStateLocked();  
  9.     }  
  10. }  

最终我们会把mScreenBrightnessBoostInProgress 变量传到DisplayPowerController中去，在那里会把它设置最亮。

2.4 updateWakeLockSummaryLocked函数

updateWakeLockSummaryLocked函数，将各个锁的状态汇总。

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void updateWakeLockSummaryLocked(int dirty) {  
  2.      if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_WAKEFULNESS)) != 0) {  
  3.          mWakeLockSummary = 0;  
  4.   
  5.          final int numWakeLocks = mWakeLocks.size();  
  6.          for (int i = 0; i < numWakeLocks; i++) {  
  7.              final WakeLock wakeLock = mWakeLocks.get(i);  
  8.              switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) {  
  9.                  case PowerManager.PARTIAL_WAKE_LOCK:  
  10.                      if (!wakeLock.mDisabled) {  
  11.                          // We only respect this if the wake lock is not disabled.  
  12.                          mWakeLockSummary |= WAKE_LOCK_CPU;  
  13.                      }  
  14.                      break;  
  15.                  case PowerManager.FULL_WAKE_LOCK:  
  16.                      mWakeLockSummary |= WAKE_LOCK_SCREEN_BRIGHT | WAKE_LOCK_BUTTON_BRIGHT;  
  17.                      break;  
  18.                  case PowerManager.SCREEN_BRIGHT_WAKE_LOCK:  
  19.                      mWakeLockSummary |= WAKE_LOCK_SCREEN_BRIGHT;  
  20.                      break;  
  21.                  case PowerManager.SCREEN_DIM_WAKE_LOCK:  
  22.                      mWakeLockSummary |= WAKE_LOCK_SCREEN_DIM;  
  23.                      break;  
  24.                  case PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK:  
  25.                      mWakeLockSummary |= WAKE_LOCK_PROXIMITY_SCREEN_OFF;  
  26.                      break;  
  27.                  case PowerManager.DOZE_WAKE_LOCK:  
  28.                      mWakeLockSummary |= WAKE_LOCK_DOZE;  
  29.                      break;  
  30.                  case PowerManager.DRAW_WAKE_LOCK:  
  31.                      mWakeLockSummary |= WAKE_LOCK_DRAW;  
  32.                      break;  
  33.              }  
  34.          }  
  35.   
  36.          // Cancel wake locks that make no sense based on the current state.  
  37.          if (mWakefulness != WAKEFULNESS_DOZING) {  
  38.              mWakeLockSummary &= ~(WAKE_LOCK_DOZE | WAKE_LOCK_DRAW);  
  39.          }  
  40.          if (mWakefulness == WAKEFULNESS_ASLEEP  
  41.                  || (mWakeLockSummary & WAKE_LOCK_DOZE) != 0) {  
  42.              mWakeLockSummary &= ~(WAKE_LOCK_SCREEN_BRIGHT | WAKE_LOCK_SCREEN_DIM  
  43.                      | WAKE_LOCK_BUTTON_BRIGHT);  
  44.              if (mWakefulness == WAKEFULNESS_ASLEEP) {  
  45.                  mWakeLockSummary &= ~WAKE_LOCK_PROXIMITY_SCREEN_OFF;  
  46.              }  
  47.          }  
  48.   
  49.          // Infer implied wake locks where necessary based on the current state.  
  50.          if ((mWakeLockSummary & (WAKE_LOCK_SCREEN_BRIGHT | WAKE_LOCK_SCREEN_DIM)) != 0) {  
  51.              if (mWakefulness == WAKEFULNESS_AWAKE) {  
  52.                  mWakeLockSummary |= WAKE_LOCK_CPU | WAKE_LOCK_STAY_AWAKE;  
  53.              } else if (mWakefulness == WAKEFULNESS_DREAMING) {  
  54.                  mWakeLockSummary |= WAKE_LOCK_CPU;  
  55.              }  
  56.          }  
  57.          if ((mWakeLockSummary & WAKE_LOCK_DRAW) != 0) {  
  58.              mWakeLockSummary |= WAKE_LOCK_CPU;  
  59.          }  
  60.   
  61.          if (DEBUG_SPEW) {  
  62.              Slog.d(TAG, "updateWakeLockSummaryLocked: mWakefulness="  
  63.                      + PowerManagerInternal.wakefulnessToString(mWakefulness)  
  64.                      + ", mWakeLockSummary=0x" + Integer.toHexString(mWakeLockSummary));  
  65.          }  
  66.      }  
  67.  }  


2.5 updateUserActivitySummaryLocked函数


再来看updateUserActivitySummaryLocked是来改变userActivity事件的时间

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void updateUserActivitySummaryLocked(long now, int dirty) {  
  2.       // Update the status of the user activity timeout timer.  
  3.       if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY  
  4.               | DIRTY_WAKEFULNESS | DIRTY_SETTINGS)) != 0) {  
  5.           mHandler.removeMessages(MSG_USER_ACTIVITY_TIMEOUT);//取消消息  
  6.   
  7.           long nextTimeout = 0;  
  8.           if (mWakefulness == WAKEFULNESS_AWAKE  
  9.                   || mWakefulness == WAKEFULNESS_DREAMING  
  10.                   || mWakefulness == WAKEFULNESS_DOZING) {  
  11.               final int sleepTimeout = getSleepTimeoutLocked();//各种进入睡眠，屏幕灭屏，亮度调低时间  
  12.               final int screenOffTimeout = getScreenOffTimeoutLocked(sleepTimeout);  
  13.               final int screenDimDuration = getScreenDimDurationLocked(screenOffTimeout);  
  14.   
  15.               mUserActivitySummary = 0;  
  16.               if (mLastUserActivityTime >= mLastWakeTime) {  
  17.                   nextTimeout = mLastUserActivityTime  
  18.                           + screenOffTimeout - screenDimDuration;  
  19.                   if (now < nextTimeout) {  
  20.                       mUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;//亮屏  
  21.                   } else {  
  22.                       nextTimeout = mLastUserActivityTime + screenOffTimeout;  
  23.                       if (now < nextTimeout) {  
  24.                           mUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;//暗屏  
  25.                       }  
  26.                   }  
  27.               }  
  28.               if (mUserActivitySummary == 0  
  29.                       && mLastUserActivityTimeNoChangeLights >= mLastWakeTime) {  
  30.                   nextTimeout = mLastUserActivityTimeNoChangeLights + screenOffTimeout;  
  31.                   if (now < nextTimeout) {  
  32.                       if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_BRIGHT) {  
  33.                           mUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;  
  34.                       } else if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DIM) {  
  35.                           mUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;  
  36.                       }  
  37.                   }  
  38.               }  
  39.               if (mUserActivitySummary == 0) {  
  40.                   if (sleepTimeout >= 0) {  
  41.                       final long anyUserActivity = Math.max(mLastUserActivityTime,  
  42.                               mLastUserActivityTimeNoChangeLights);  
  43.                       if (anyUserActivity >= mLastWakeTime) {  
  44.                           nextTimeout = anyUserActivity + sleepTimeout;  
  45.                           if (now < nextTimeout) {  
  46.                               mUserActivitySummary = USER_ACTIVITY_SCREEN_DREAM;  
  47.                           }  
  48.                       }  
  49.                   } else {  
  50.                       mUserActivitySummary = USER_ACTIVITY_SCREEN_DREAM;  
  51.                       nextTimeout = -1;  
  52.                   }  
  53.               }  
  54.               if (mUserActivitySummary != 0 && nextTimeout >= 0) {//不为0，发送消息继续执行这个函数，为0说明要灭屏了不用发消息。  
  55.                   Message msg = mHandler.obtainMessage(MSG_USER_ACTIVITY_TIMEOUT);  
  56.                   msg.setAsynchronous(true);  
  57.                   mHandler.sendMessageAtTime(msg, nextTimeout);  
  58.               }  
  59.           } else {  
  60.               mUserActivitySummary = 0;  
  61.           }  
  62.       }  
  63.   }  


2.6 updateWakefulnessLocked函数

我们再来看updateWakefulnessLocked，这个函数必须返回false，才能跳出循环。

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. for (;;) {  
  2.     int dirtyPhase1 = mDirty;  
  3.     dirtyPhase2 |= dirtyPhase1;  
  4.     mDirty = 0;  
  5.   
  6.     updateWakeLockSummaryLocked(dirtyPhase1);  
  7.     updateUserActivitySummaryLocked(now, dirtyPhase1);  
  8.     if (!updateWakefulnessLocked(dirtyPhase1)) {  
  9.         break;  
  10.     }  
  11. }  

我们来看下这个函数：

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private boolean updateWakefulnessLocked(int dirty) {  
  2.     boolean changed = false;  
  3.     if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY | DIRTY_BOOT_COMPLETED  
  4.             | DIRTY_WAKEFULNESS | DIRTY_STAY_ON | DIRTY_PROXIMITY_POSITIVE  
  5.             | DIRTY_DOCK_STATE)) != 0) {  
  6.         if (mWakefulness == WAKEFULNESS_AWAKE && isItBedTimeYetLocked()) {//如果状态不是wake的返回false  
  7.             if (DEBUG_SPEW) {  
  8.                 Slog.d(TAG, "updateWakefulnessLocked: Bed time...");  
  9.             }  
  10.             final long time = SystemClock.uptimeMillis();  
  11.             if (shouldNapAtBedTimeLocked()) {  
  12.                 changed = napNoUpdateLocked(time, Process.SYSTEM_UID);  
  13.             } else {  
  14.                 changed = goToSleepNoUpdateLocked(time,  
  15.                         PowerManager.GO_TO_SLEEP_REASON_TIMEOUT, 0, Process.SYSTEM_UID);  
  16.             }  
  17.         }  
  18.     }  
  19.     return changed;  
  20. }  

先来看isItBedTimeYetLocked函数

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private boolean isItBedTimeYetLocked() {  
  2.     return mBootCompleted && !isBeingKeptAwakeLocked();  
  3. }  

isBeingKeptAwakeLocked需要返回false

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private boolean isBeingKeptAwakeLocked() {  
  2.     return mStayOn// 常为false  
  3.             || mProximityPositive//距离传感器  
  4.             || (mWakeLockSummary & WAKE_LOCK_STAY_AWAKE) != 0//是否有屏幕持锁  
  5.             || (mUserActivitySummary & (USER_ACTIVITY_SCREEN_BRIGHT//userActivity事件  
  6.                     | USER_ACTIVITY_SCREEN_DIM)) != 0  
  7.             || mScreenBrightnessBoostInProgress;//最亮事件  
  8. }  

只有mWakefulness == WAKEFULNESS_AWAKE和isBeingKeptAwakeLocked为true这两个条件才能进入这个判断，只要不满足直接为false，也就能跳出循环了。

那上面时候才会满足这两个条件呢，只要调用wakup唤醒设备时才会满足这个条件。而且需要设备不用保存唤醒状态时。那也即是说之前调用过wakeUp函数，而且又不用保持唤醒才会进入这个条件，因为shouldNapAtBedTimeLocked函数为我们只会返回false。所以只会调用goToSleepNoUpdateLocked，而这个函数会返回true的。这样的情况一般是之前设备被调用wakeUp函数唤醒屏幕了，然后过一段时间没有点击userActivity事件，这个时候其实又不用保持唤醒状态，这样的情况就不会被处理了，但是会调用goToSleepNoUpdateLocked函数重新走睡眠流程。

再来看这个函数，我们两个配置全为false，只能返回false

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private boolean shouldNapAtBedTimeLocked() {  
  2.     return mDreamsActivateOnSleepSetting  
  3.             || (mDreamsActivateOnDockSetting  
  4.                     && mDockState != Intent.EXTRA_DOCK_STATE_UNDOCKED);  
  5. }  


2.7 updateDisplayPowerStateLocked函数


再后面调用updateDisplayPowerStateLocked函数，我们之前分析过了，就是把一些状态传到DisplayPowerControlller来设置背光等。这里就不分析了。


2.8 updateDreamLocked函数

我们再来看updateDreamLocked函数

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void updateDreamLocked(int dirty, boolean displayBecameReady) {  
  2.     if ((dirty & (DIRTY_WAKEFULNESS  
  3.             | DIRTY_USER_ACTIVITY  
  4.             | DIRTY_WAKE_LOCKS  
  5.             | DIRTY_BOOT_COMPLETED  
  6.             | DIRTY_SETTINGS  
  7.             | DIRTY_IS_POWERED  
  8.             | DIRTY_STAY_ON  
  9.             | DIRTY_PROXIMITY_POSITIVE  
  10.             | DIRTY_BATTERY_STATE)) != 0 || displayBecameReady) {  
  11.         if (mDisplayReady) {  
  12.             scheduleSandmanLocked();  
  13.         }  
  14.     }  
  15. }  

scheduleSandmanLocked就是发送一个消息，这是一个异步过程。

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void scheduleSandmanLocked() {  
  2.     if (!mSandmanScheduled) {  
  3.         mSandmanScheduled = true;  
  4.         Message msg = mHandler.obtainMessage(MSG_SANDMAN);  
  5.         msg.setAsynchronous(true);  
  6.         mHandler.sendMessage(msg);  
  7.     }  
  8. }  

最后在handleSandman函数中处理

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void handleSandman() { // runs on handler thread  
  2.     // Handle preconditions.  
  3.     final boolean startDreaming;  
  4.     final int wakefulness;  
  5.     synchronized (mLock) {  
  6.         mSandmanScheduled = false;  
  7.         wakefulness = mWakefulness;  
  8.         if (mSandmanSummoned && mDisplayReady) {// 在goToSleep和nap中将mSandmanSummoned置为true  
  9.             startDreaming = canDreamLocked() || canDozeLocked();//是否能做梦  
  10.             mSandmanSummoned = false;  
  11.         } else {  
  12.             startDreaming = false;  
  13.         }  
  14.     }  
  15.   
  16.     // Start dreaming if needed.  
  17.     // We only control the dream on the handler thread, so we don't need to worry about  
  18.     // concurrent attempts to start or stop the dream.  
  19.     final boolean isDreaming;  
  20.     if (mDreamManager != null) {  
  21.         // Restart the dream whenever the sandman is summoned.  
  22.         if (startDreaming) {  
  23.             mDreamManager.stopDream(false /*immediate*/);  
  24.             mDreamManager.startDream(wakefulness == WAKEFULNESS_DOZING);//开始做梦  
  25.         }  
  26.         isDreaming = mDreamManager.isDreaming();  
  27.     } else {  
  28.         isDreaming = false;  
  29.     }  
  30.   
  31.     // Update dream state.  
  32.     synchronized (mLock) {  
  33.         // Remember the initial battery level when the dream started.  
  34.         if (startDreaming && isDreaming) {//正在做梦  
  35.             mBatteryLevelWhenDreamStarted = mBatteryLevel;  
  36.             if (wakefulness == WAKEFULNESS_DOZING) {  
  37.                 Slog.i(TAG, "Dozing...");  
  38.             } else {  
  39.                 Slog.i(TAG, "Dreaming...");  
  40.             }  
  41.         }  
  42.   
  43.         // If preconditions changed, wait for the next iteration to determine  
  44.         // whether the dream should continue (or be restarted).  
  45.         if (mSandmanSummoned || mWakefulness != wakefulness) {  
  46.             return; // wait for next cycle  
  47.         }  
  48.   
  49.         // Determine whether the dream should continue.  
  50.         if (wakefulness == WAKEFULNESS_DREAMING) {  
  51.             if (isDreaming && canDreamLocked()) {  
  52.                 if (mDreamsBatteryLevelDrainCutoffConfig >= 0  
  53.                         && mBatteryLevel < mBatteryLevelWhenDreamStarted  
  54.                                 - mDreamsBatteryLevelDrainCutoffConfig  
  55.                         && !isBeingKeptAwakeLocked()) {  
  56.                     // If the user activity timeout expired and the battery appears  
  57.                     // to be draining faster than it is charging then stop dreaming  
  58.                     // and go to sleep.  
  59.                     Slog.i(TAG, "Stopping dream because the battery appears to "  
  60.                             + "be draining faster than it is charging.  "  
  61.                             + "Battery level when dream started: "  
  62.                             + mBatteryLevelWhenDreamStarted + "%.  "  
  63.                             + "Battery level now: " + mBatteryLevel + "%.");  
  64.                 } else {  
  65.                     return; // continue dreaming  
  66.                 }  
  67.             }  
  68.   
  69.             // Dream has ended or will be stopped.  Update the power state.  
  70.             if (isItBedTimeYetLocked()) {  
  71.                 goToSleepNoUpdateLocked(SystemClock.uptimeMillis(),  
  72.                         PowerManager.GO_TO_SLEEP_REASON_TIMEOUT, 0, Process.SYSTEM_UID);  
  73.                 updatePowerStateLocked();  
  74.             } else {  
  75.                 wakeUpNoUpdateLocked(SystemClock.uptimeMillis(), "android.server.power:DREAM",  
  76.                         Process.SYSTEM_UID, mContext.getOpPackageName(), Process.SYSTEM_UID);  
  77.                 updatePowerStateLocked();  
  78.             }  
  79.         } else if (wakefulness == WAKEFULNESS_DOZING) {  
  80.             if (isDreaming) {//还在做梦退出  
  81.                 return; // continue dozing  
  82.             }  
  83.   
  84.             // Doze has ended or will be stopped.  Update the power state.  
  85.             reallyGoToSleepNoUpdateLocked(SystemClock.uptimeMillis(), Process.SYSTEM_UID);// 设置成睡眠状态  
  86.             updatePowerStateLocked();  
  87.         }  
  88.     }  
  89.   
  90.     // Stop dream.  
  91.     if (isDreaming) {  
  92.         mDreamManager.stopDream(false /*immediate*/);//停止做梦  
  93.     }  
  94. }  

上面这个函数是异步执行的，那就是updatePowerState会继续执行，这个函数的作用就是等做梦结束会把power的状态由WAKEFULNESS_DOZING变成睡眠状态

说了这么多那到底把这状态改成睡眠状态后有和之前的Dozing状态什么区别呢？


2.8.1 睡眠状态和Dozing状态区别

1. finishWakefulnessChangeIfNeededLocked函数中，只有在睡眠状态才会调用mNotifier.onWakefulnessChangeFinished

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void finishWakefulnessChangeIfNeededLocked() {  
  2.     if (mWakefulnessChanging && mDisplayReady) {  
  3.         if (mWakefulness == WAKEFULNESS_DOZING  
  4.                 && (mWakeLockSummary & WAKE_LOCK_DOZE) == 0) {  
  5.             return; // wait until dream has enabled dozing  
  6.         }  
  7.         mWakefulnessChanging = false;  
  8.         mNotifier.onWakefulnessChangeFinished();  
  9.     }  
  10. }  


2. 在updateUserActivitySummaryLocked函数中，如果是睡眠状态mUserActivitySummary 直接为0，而Dozing状态还要走userActivity事件流程。

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1.    private void updateUserActivitySummaryLocked(long now, int dirty) {  
  2.        // Update the status of the user activity timeout timer.  
  3.        if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY  
  4.                | DIRTY_WAKEFULNESS | DIRTY_SETTINGS)) != 0) {  
  5.            mHandler.removeMessages(MSG_USER_ACTIVITY_TIMEOUT);  
  6.   
  7.            long nextTimeout = 0;  
  8.            if (mWakefulness == WAKEFULNESS_AWAKE  
  9.                    || mWakefulness == WAKEFULNESS_DREAMING  
  10.                    || mWakefulness == WAKEFULNESS_DOZING) {  
  11.             ......  
  12.         }  
  13.         else {  
  14.                mUserActivitySummary = 0;  
  15.            }  
  16. }  


3. 第三个区别最重要，看下面函数，当是睡眠状态返回POLICY_OFF，而是Dozing状态最终返回的是POLICY_DIM状态。

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private int getDesiredScreenPolicyLocked() {  
  2.     if (mWakefulness == WAKEFULNESS_ASLEEP) {  
  3.         return DisplayPowerRequest.POLICY_OFF;  
  4.     }  
  5.   
  6.     if (mWakefulness == WAKEFULNESS_DOZING) {  
  7.         if ((mWakeLockSummary & WAKE_LOCK_DOZE) != 0) {  
  8.             return DisplayPowerRequest.POLICY_DOZE;  
  9.         }  
  10.         if (mDozeAfterScreenOffConfig) {  
  11.             return DisplayPowerRequest.POLICY_OFF;  
  12.         }  
  13.         // Fall through and preserve the current screen policy if not configured to  
  14.         // doze after screen off.  This causes the screen off transition to be skipped.  
  15.     }  
  16.   
  17.     if ((mWakeLockSummary & WAKE_LOCK_SCREEN_BRIGHT) != 0  
  18.             || (mUserActivitySummary & USER_ACTIVITY_SCREEN_BRIGHT) != 0  
  19.             || !mBootCompleted  
  20.             || mScreenBrightnessBoostInProgress) {  
  21.         return DisplayPowerRequest.POLICY_BRIGHT;  
  22.     }  
  23.   
  24.     return DisplayPowerRequest.POLICY_DIM;  
  25. }  

我们再来看updateDisplayPowerStateLocked函数，mDisplayPowerRequest.policy就是从这个函数返回的。然后再传到DisplayPowerController中去。

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private boolean updateDisplayPowerStateLocked(int dirty) {  
  2.     final boolean oldDisplayReady = mDisplayReady;  
  3.     if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY | DIRTY_WAKEFULNESS  
  4.             | DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED | DIRTY_BOOT_COMPLETED  
  5.             | DIRTY_SETTINGS | DIRTY_SCREEN_BRIGHTNESS_BOOST)) != 0) {  
  6.         mDisplayPowerRequest.policy = getDesiredScreenPolicyLocked();  

这样如果power状态是Dozing，DisplayPowerController会把背光设置成暗的状态。
在最后的updateSuspendBlockerLocked函数中，会调用needDisplaySuspendBlockerLocked函数来决定是否要吃Displays锁。

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private void updateSuspendBlockerLocked() {  
  2.     final boolean needWakeLockSuspendBlocker = ((mWakeLockSummary & WAKE_LOCK_CPU) != 0);  
  3.     final boolean needDisplaySuspendBlocker = needDisplaySuspendBlockerLocked();  

needDisplaySuspendBlockerLocked函数如果DisplayPowerRequest是暗的时候就会返回 true，导致Displays锁不能释放。也就不会睡眠了

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private boolean needDisplaySuspendBlockerLocked() {  
  2.     if (!mDisplayReady) {  
  3.         return true;  
  4.     }  
  5.     if (mDisplayPowerRequest.isBrightOrDim()) {  
  6.         // If we asked for the screen to be on but it is off due to the proximity  
  7.         // sensor then we may suspend but only if the configuration allows it.  
  8.         // On some hardware it may not be safe to suspend because the proximity  
  9.         // sensor may not be correctly configured as a wake-up source.  
  10.         if (!mDisplayPowerRequest.useProximitySensor || !mProximityPositive  
  11.                 || !mSuspendWhenScreenOffDueToProximityConfig) {  
  12.             return true;  
  13.         }  
  14.     }  
  15.     if (mScreenBrightnessBoostInProgress) {  
  16.         return true;  
  17.     }  
  18.     // Let the system suspend if the screen is off or dozing.  
  19.     return false;  
  20. }  


三、wakeUp函数


wakeUp函数最终调用了wakeUpNoUpdateLocked函数之后也调用了updatePowerState函数

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private boolean wakeUpNoUpdateLocked(long eventTime, String reason, int reasonUid,  
  2.         String opPackageName, int opUid) {  
  3.     if (eventTime < mLastSleepTime || mWakefulness == WAKEFULNESS_AWAKE  
  4.             || !mBootCompleted || !mSystemReady) {  
  5.         return false;  
  6.     }  
  7.   
  8.     Trace.traceBegin(Trace.TRACE_TAG_POWER, "wakeUp");  
  9.     try {  
  10.         switch (mWakefulness) {  
  11.             case WAKEFULNESS_ASLEEP:  
  12.                 Slog.i(TAG, "Waking up from sleep (uid " + reasonUid +")...");  
  13.                 break;  
  14.             case WAKEFULNESS_DREAMING:  
  15.                 Slog.i(TAG, "Waking up from dream (uid " + reasonUid +")...");  
  16.                 break;  
  17.             case WAKEFULNESS_DOZING:  
  18.                 Slog.i(TAG, "Waking up from dozing (uid " + reasonUid +")...");  
  19.                 break;  
  20.         }  
  21.   
  22.         mLastWakeTime = eventTime;  
  23.         setWakefulnessLocked(WAKEFULNESS_AWAKE, 0);//设置状态  
  24.   
  25.         mNotifier.onWakeUp(reason, reasonUid, opPackageName, opUid);//通知  
  26.         userActivityNoUpdateLocked(//触发userActivity事件  
  27.                 eventTime, PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, reasonUid);  
  28.     } finally {  
  29.         Trace.traceEnd(Trace.TRACE_TAG_POWER);  
  30.     }  
  31.     return true;  
  32. }  



四、userActivity函数

这个函数也是调用了userActivityNoUpdateLocked函数之后调用updatePowerState函数

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private boolean userActivityNoUpdateLocked(long eventTime, int event, int flags, int uid) {  
  2.     if (eventTime < mLastSleepTime || eventTime < mLastWakeTime  
  3.             || !mBootCompleted || !mSystemReady) {  
  4.         return false;  
  5.     }  
  6.   
  7.     Trace.traceBegin(Trace.TRACE_TAG_POWER, "userActivity");  
  8.     try {  
  9.         if (eventTime > mLastInteractivePowerHintTime) {  
  10.             powerHintInternal(POWER_HINT_INTERACTION, 0);  
  11.             mLastInteractivePowerHintTime = eventTime;  
  12.         }  
  13.   
  14.         mNotifier.onUserActivity(event, uid);//通知  
  15.   
  16.         if (mWakefulness == WAKEFULNESS_ASLEEP  
  17.                 || mWakefulness == WAKEFULNESS_DOZING  
  18.                 || (flags & PowerManager.USER_ACTIVITY_FLAG_INDIRECT) != 0) {  
  19.             return false;  
  20.         }  
  21.   
  22.         if ((flags & PowerManager.USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS) != 0) {//记录userActivity时间  
  23.             if (eventTime > mLastUserActivityTimeNoChangeLights  
  24.                     && eventTime > mLastUserActivityTime) {  
  25.                 mLastUserActivityTimeNoChangeLights = eventTime;  
  26.                 mDirty |= DIRTY_USER_ACTIVITY;  
  27.                 return true;  
  28.             }  
  29.         } else {//记录userActivity发生时间  
  30.             if (eventTime > mLastUserActivityTime) {  
  31.                 mLastUserActivityTime = eventTime;  
  32.                 mDirty |= DIRTY_USER_ACTIVITY;  
  33.                 return true;  
  34.             }  
  35.         }  
  36.     } finally {  
  37.         Trace.traceEnd(Trace.TRACE_TAG_POWER);  
  38.     }  
  39.     return false;  
  40. }  


五、nap函数

nap函数最后调用了napNoUpdateLocked，之后也会调用updatePowerState函数

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private boolean napNoUpdateLocked(long eventTime, int uid) {  
  2.   
  3.     if (eventTime < mLastWakeTime || mWakefulness != WAKEFULNESS_AWAKE  
  4.             || !mBootCompleted || !mSystemReady) {  
  5.         return false;  
  6.     }  
  7.   
  8.     Trace.traceBegin(Trace.TRACE_TAG_POWER, "nap");  
  9.     try {  
  10.         Slog.i(TAG, "Nap time (uid " + uid +")...");  
  11.   
  12.         mSandmanSummoned = true;  
  13.         setWakefulnessLocked(WAKEFULNESS_DREAMING, 0);//设置状态  
  14.     } finally {  
  15.         Trace.traceEnd(Trace.TRACE_TAG_POWER);  
  16.     }  
  17.     return true;  
  18. }  

六、总结

我们发现当由goToSleep函数引出updatePowerState函数之后，我们详细的分析过updatePowerState函数。后面的nap，wakeUp，userActivity函数的分析都非常容易。


原文地址：http://46aae4d1e2371e4aa769798941cef698.devproxy.yunshipei.com/kc58236582/article/details/51595390
android6.0 PowerManagerService dream分析
kc58236582的博客
06-07 5119
上一篇博客分析了PowerManagerService的各种状态，最后分析到dream相关，讲的不详细。这里我们再分析下。 一、Dream关闭 首先我们结合打印的log，看看handleSandman函数，log直接加在下面的函数中。当然我们现在说的情况是mWakefulness是dozing状态。 private void handleSandman() { // runs
android6.0 power显示(亮度等)深入分析(一)PowerManagerService & DisplayPowerController
kc58236582的博客
01-22 7003
之前android5.1我们分析过power，但是那篇博客从整体分析显得有些杂乱，这几篇博客都从power的功能来分析，个人觉得更好理解。   一、PowerManagerService的显示相关函数 由于之前博客都分析过，我们就直接进入PowerManagerService的和显示相关的主体： updateDisplayPowerStateLocked函数： private b...
android 电源管理(PowerManager)
Kuangjp的专栏
06-08 1876
1. 概述 PowerManager 管理设备的电源状态。它的使用会显著地影响到设备电池寿命，除非的确需要，轻易不要获取PowerManager唤醒锁（PowerManager.WakeLock）,而且尽可能使用最小级别，一定要尽快释放。 您可以通过调用Context.getSystemService()获取PowerManager 的实例，以及使用newWakeLock()方法创建Pow
android6.0 PowerManagerService状态分析
kc58236582的博客
06-06 9652
这篇博客我们主要分析下PowerManagerService的各个状态，主要从goToSleep，wakeUp，userActivity，nap函数作为入口分析。 一、PowerManagerService的goToSleep函数  我们先来看下goToSleep函数： goToSleep函数主要调用了goToSleepInternal函数： private void
Android PowerManager分析
lp542718520的专栏
06-16 1262
概述 一直以来,电源管理是电子产品设计中非常重要的环节，也是任何电子设备中最为重要的系统模块之一，优秀的电源管理方案，能够提供持久的续航能力，良好的用户体验，更能提升电子产品的竞争力。 移动设备的电量主要由两种元件消耗：CPU和显示屏，因此设法降低这两种元件的耗电量就是电源管理的关键，为移动设备设计的CPU大多有两种工作频率，为了省电，大部分时间内cpu都工作在降低频率下，只有进行密集
按电源键休眠流程(framework层)
jacob的专栏
08-27 849
这里以Android6.0为例 frameworks/base/services/core/java/com/android/server/policy/PhoneWindowManager.java PowerManager mPowerManager; private void powerPress(long eventTime, boolean interactive, int coun...
Andorid屏幕唤醒异常，Power按键无法点亮屏幕的分析
从0到1，突破自己
03-04 7394
写在前面：     关于这个话题我们需要了解屏幕唤醒的一些基本流程，物理按键的Keycode，CPU使用率，Low Memeory，还需要关注ANR（由于广播是按顺序发送的，ANR会导致唤醒屏幕的广播阻塞引起屏幕无法正常点亮），再结合现场其他的一些情况进行综合分析。 结合案例分析：     案例描述：打开应用市场更新软件，操作Power键无法正常唤醒屏幕 分析过程：  
android6.0 power按键深入分析
热门推荐
kc58236582的博客
06-02 1万+
这篇博客主要分析power按键点亮屏幕和灭屏，而且我们主要分析在PhoneWIndowManager的流程。 之前的博客我们分析过按键的流程，当有按键会先到PhoneWindowManager的interceptKeyBeforeQueueing函数，然后再去分析到应用，而power按键也是如此，并且其最后不会分发到应用中去，下面我们看下PhoneWindowManager的interceptK
android pms powermanagerservice
最新发布
03-14
PowerManagerService（PMS）是Android电源管理的核心服务，负责协调系统的休眠/唤醒状态，通过**wakelock机制**管理设备功耗。其架构分为四层： 1. **应用接口层**：通过`PowerManager`类提供API（如申请wakelock）...
Android6.0 设备Idle状态（三） PowerManagerService
kc58236582的博客
01-21 2401
新增的Idle状态感觉在PowerManagerService的代码变动不大，但是其功能其实还有很大的变化，我们先看下持锁这个函数新加的地方。 一、持wakelock的流程 private void acquireWakeLockInternal(IBinder lock, int flags, String tag, String packageName,
android休眠与唤醒
04-26
android休眠与唤醒 讲解精辟 绝对值得学习
2021-09-03 eventlog对应各标识表示的含义
qq_34024778的博客
09-03 4708
当前联想设备路径 /system/etc/event-log-tags eventlog中各标识表示的含义 当前看的比较多的标识 am_pss 42 answer (to life the universe etc|3) 314 pi 1003 auditd (avc|3) 1004 chatty (dropped|3) 1005 tag_def (tag|1),(name|3),(format|3) 1006 liblog (dropped|1) 2718 e 2719 ...
android 屏幕 休眠 超时,安卓修改屏幕超时后，系统不进入休眠的方法。
weixin_29008055的博客
05-31 1787
修改系统行为，让屏幕超时后，不去休眠。frameworks\base\services\core\java\com\android\server\power\PowerManagerService，电源管理类，屏蔽休眠在此方法中修改。关键函数如下@VisibleForTestingvoid setWakefulnessLocked(int wakefulness, int reason) {if ...
Android 解读Event和Main Log
weixin_33775572的博客
06-09 2138
1 Android P EventLogTags文件 Android P 9.0.0 所有EventLogTags文件List： system/bt/EventLogTags.logtags system/core/liblog/event.logtags system/core/libsysutils/EventLogTags.logtags system/core/logcat/event.l...
Android7.0 PowerManagerService(3) 核心函数updatePowerStateLocked的主要流程
ZhangJian的博客
10-22 5605
前面的博客中，我们已经分析过，当Android中的进程要使用电量时，需要向PMS申请WakeLock；当进程完成工作后，需要释放对应的WakeLock。 PMS收到申请和释放WakeLock的请求后，均需要调用updatePowerStateLocked来更新电源的状态，该函数是PMS的核心方法。 接下来，我们就结合代码，看一下updatePowerStateLocked的工作流程。
Android Event Log
fenghanfenghan的博客
10-13 2130
日志是极好的，可以及时记录程序的运行状态信息，和出现异常的时候的异常状态信息，是程序运行的后知后觉的晴雨表。它可以给我们查找问题指明方向，带来查找问题的便利。因此，可以读懂Android Event Log显得很重要。为了让您可以懂它，使用它，我来做一个小小总结。
[通话][MTK]来电黑屏需按电源键才能点亮屏
wed110的专栏
08-22 2656
该问题是因为在来电亮屏之后, 紧接着又有进程调用了 PowerManagerService.gotoSleep 操作.  导致系统关闭背光. 所以才出现来电无法亮屏的情况. 而这个调用 goToSleep 的进程对应的 uid 为 10018. 所以我们需要先确认 10018 这个 uid 到底是哪个 application. 请知悉. 您可以通过下面的方式确认 ui
PowerManagerService学习笔记
a87636764的专栏
07-21 736
平台：Android4.0 场景：PMS是framework中相对简单明了的service，学习老邓第二本android书籍。 时间：2012.8.8以下大部分内容摘抄于老邓第二本android书籍。1.在PMS的init()函数中，将创建两个HandlerThread对象。一个为mScreenOffThread，用于调节关闭屏幕时的亮度的渐变过程。另一个为PMS的主要工作线程——mHandle
Android 跳转手机管家的自启动界面
qq_34207582的博客
03-28 4866
在开发中遇到这样一个问题,当我们写了开机自启后发现有的手机并不能很顺利的自启动,因为手机管家有最高权限,有个自启动管理,想直接调到这个页面把自己的app的自启动打开就可以,还有oppo,vivo,加入白名单,查了好多资料发现没有直接跳入自启动的界面的Intent, 我想到了可以通过手机的包名类名可以直接跳转,但是手机型号这么多,我怎么知道每个管家的包名类名是个啥
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值