android6.0 power显示(亮度等)深入分析(一)PowerManagerService & DisplayPowerController

thinkinwm thinkinwm 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 1.4k累计阅读 1.5k平均单平台 已同步平台 CSDN 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄17年
关注
转载 最新推荐文章于 2022-11-06 23:22:23 发布 1.4k 阅读 AI 写同款· GEO 优化 ›
Android 8.1 DisplayPowerController(四) 自动调节亮度(1)——流程 和手动调节亮度相比，自动调节亮度则稍微复杂些。其中涉及到多个算法。这里先笼统地介绍其流程，对涉及到的算法在下一篇文章中进行学习。 从前面的分析得到，不管是哪种背光调节方式，其最终都会在DisplayPowerController的updatePowerState()方法中进行决策，得到最终的背光值，自动背光的亮度也不例外： private void updatePowerState() { ... 阅读详情

http://blog.csdn.net/kc58236582/article/details/51582950

这是第一篇文章，博主后续还有一篇文章，


在下面这篇的基础上补充上了DisplayPowerController部分，两篇一起看更好

http://blog.csdn.net/thinkinwm/article/details/51958048


之前android5.1我们分析过power，但是那篇博客从整体分析显得有些杂乱，这几篇博客都从power的功能来分析，个人觉得更好理解。


一、PowerManagerService的显示相关函数

由于之前博客都分析过，我们就直接进入PowerManagerService的和显示相关的主体：

updateDisplayPowerStateLocked函数：

[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();//根据PowerManager的mWakefulness返回状态  
  7.   
  8.          // Determine appropriate screen brightness and auto-brightness adjustments.  
  9.          boolean brightnessSetByUser = true;  
  10.          int screenBrightness = mScreenBrightnessSettingDefault;  
  11.          float screenAutoBrightnessAdjustment = 0.0f;  
  12.          boolean autoBrightness = (mScreenBrightnessModeSetting ==  
  13.                  Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);  
  14.          if (isValidBrightness(mScreenBrightnessOverrideFromWindowManager)) {//计算屏幕亮度  
  15.              screenBrightness = mScreenBrightnessOverrideFromWindowManager;  
  16.              autoBrightness = false;  
  17.              brightnessSetByUser = false;  
  18.          } else if (isValidBrightness(mTemporaryScreenBrightnessSettingOverride)) {  
  19.              screenBrightness = mTemporaryScreenBrightnessSettingOverride;  
  20.          } else if (isValidBrightness(mScreenBrightnessSetting)) {  
  21.              screenBrightness = mScreenBrightnessSetting;  
  22.          }  
  23.          if (autoBrightness) {//和屏幕自动亮度相关  
  24.              screenBrightness = mScreenBrightnessSettingDefault;  
  25.              if (isValidAutoBrightnessAdjustment(  
  26.                      mTemporaryScreenAutoBrightnessAdjustmentSettingOverride)) {  
  27.                  screenAutoBrightnessAdjustment =  
  28.                          mTemporaryScreenAutoBrightnessAdjustmentSettingOverride;  
  29.              } else if (isValidAutoBrightnessAdjustment(  
  30.                      mScreenAutoBrightnessAdjustmentSetting)) {  
  31.                  screenAutoBrightnessAdjustment = mScreenAutoBrightnessAdjustmentSetting;  
  32.              }  
  33.          }  
  34.          screenBrightness = Math.max(Math.min(screenBrightness,  
  35.                  mScreenBrightnessSettingMaximum), mScreenBrightnessSettingMinimum);  
  36.          screenAutoBrightnessAdjustment = Math.max(Math.min(  
  37.                  screenAutoBrightnessAdjustment, 1.0f), -1.0f);  
  38.   
  39.          // Update display power request.  
  40.          mDisplayPowerRequest.screenBrightness = screenBrightness;  
  41.          mDisplayPowerRequest.screenAutoBrightnessAdjustment =  
  42.                  screenAutoBrightnessAdjustment;  
  43.          mDisplayPowerRequest.brightnessSetByUser = brightnessSetByUser;  
  44.          mDisplayPowerRequest.useAutoBrightness = autoBrightness;  
  45.          mDisplayPowerRequest.useProximitySensor = shouldUseProximitySensorLocked();//距离传感器相关  
  46.          mDisplayPowerRequest.lowPowerMode = mLowPowerModeEnabled;//低功耗模式  
  47.          mDisplayPowerRequest.boostScreenBrightness = mScreenBrightnessBoostInProgress;//屏幕最亮  
  48.   
  49.          if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DOZE) {  
  50.              mDisplayPowerRequest.dozeScreenState = mDozeScreenStateOverrideFromDreamManager;  
  51.              if (mDisplayPowerRequest.dozeScreenState == Display.STATE_DOZE_SUSPEND  
  52.                      && (mWakeLockSummary & WAKE_LOCK_DRAW) != 0) {  
  53.                  mDisplayPowerRequest.dozeScreenState = Display.STATE_DOZE;  
  54.              }  
  55.              mDisplayPowerRequest.dozeScreenBrightness =  
  56.                      mDozeScreenBrightnessOverrideFromDreamManager;  
  57.          } else {  
  58.              mDisplayPowerRequest.dozeScreenState = Display.STATE_UNKNOWN;  
  59.              mDisplayPowerRequest.dozeScreenBrightness = PowerManager.BRIGHTNESS_DEFAULT;  
  60.          }  
  61.   
  62.          mDisplayReady = mDisplayManagerInternal.requestPowerState(mDisplayPowerRequest,//调用DisplayPowerController的函数  
  63.                  mRequestWaitForNegativeProximity);  
  64.          mRequestWaitForNegativeProximity = false;  
  65.   
  66.      return mDisplayReady && !oldDisplayReady;  
  67.  }  

我们先看看getDesiredScreenPolicyLocked函数，就是根据现在PowerManager中mWakefulness的状态返回各个值。

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

我们先来看看DisplayManagerService中下面的LocalService，在PowerManagerService中先调用了initPowerManagement，然后在上面函数中调用了requestPowerState函数，最后等于调用了DisplayPowerController的requestPowerState接口。

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. private final class LocalService extends DisplayManagerInternal {  
  2.     @Override  
  3.     public void initPowerManagement(final DisplayPowerCallbacks callbacks, Handler handler,  
  4.             SensorManager sensorManager) {  
  5.         synchronized (mSyncRoot) {  
  6.             DisplayBlanker blanker = new DisplayBlanker() {  
  7.                 @Override  
  8.                 public void requestDisplayState(int state, int brightness) {  
  9.                     // The order of operations is important for legacy reasons.  
  10.                     if (state == Display.STATE_OFF) {  
  11.                         requestGlobalDisplayStateInternal(state, brightness);  
  12.                     }  
  13.   
  14.                     callbacks.onDisplayStateChange(state);  
  15.   
  16.                     if (state != Display.STATE_OFF) {  
  17.                         requestGlobalDisplayStateInternal(state, brightness);  
  18.                     }  
  19.                 }  
  20.             };  
  21.             mDisplayPowerController = new DisplayPowerController(  
  22.                     mContext, callbacks, handler, sensorManager, blanker);  
  23.         }  
  24.     }  
  25.   
  26.     @Override  
  27.     public boolean requestPowerState(DisplayPowerRequest request,  
  28.             boolean waitForNegativeProximity) {  
  29.         return mDisplayPowerController.requestPowerState(request,  
  30.                 waitForNegativeProximity);  
  31.     }  

这里我们还得注意在PowerManagerService调用LocalService的initPowerManagement接口时，传入的几个参数，后面会分析到。


二、DisplayPowerController

我们先来看DisplayPowerController的构造函数，先将传入的参数保存起来，我们看传入的handler是从PowerManagerService中传过来的，说明DisplayPowerController的消息处理线程是在PowerManagerService中的，这个构造函数后面是各种参数的配置我们就不看了。

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public DisplayPowerController(Context context,  
  2.         DisplayPowerCallbacks callbacks, Handler handler,  
  3.         SensorManager sensorManager, DisplayBlanker blanker) {  
  4.     mHandler = new DisplayControllerHandler(handler.getLooper());  
  5.     mCallbacks = callbacks;  
  6.   
  7.     mBatteryStats = BatteryStatsService.getService();  
  8.     mSensorManager = sensorManager;  
  9.     mWindowManagerPolicy = LocalServices.getService(WindowManagerPolicy.class);  
  10.     mBlanker = blanker;  
  11.     mContext = context;  
  12.   
  13.     mPowerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE);  

下面我们来看requestPowerState函数：

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public boolean requestPowerState(DisplayPowerRequest request,  
  2.         boolean waitForNegativeProximity) {  
  3.     synchronized (mLock) {  
  4.         boolean changed = false;  
  5.   
  6.         if (waitForNegativeProximity  
  7.                 && !mPendingWaitForNegativeProximityLocked) {  
  8.             mPendingWaitForNegativeProximityLocked = true;  
  9.             changed = true;  
  10.         }  
  11.   
  12.         if (mPendingRequestLocked == null) {//第一次过来  
  13.             mPendingRequestLocked = new DisplayPowerRequest(request);//把传过来的值保存在DisplayPowerRequest中  
  14.             changed = true;  
  15.         } else if (!mPendingRequestLocked.equals(request)) {  
  16.             mPendingRequestLocked.copyFrom(request);  
  17.             changed = true;  
  18.         }  
  19.   
  20.         if (changed) {  
  21.             mDisplayReadyLocked = false;//还没准备好  
  22.         }  
  23.   
  24.         if (changed && !mPendingRequestChangedLocked) {//第一次调用mPendingRequestChangedLocked为false  
  25.             mPendingRequestChangedLocked = true;//置true了  
  26.             sendUpdatePowerStateLocked();  
  27.         }  
  28.   
  29.         return mDisplayReadyLocked;  
  30.     }  
  31. }  

sendUpdatePowerStateLocked就是发送了MSG_UPDATE_POWER_STATE消息

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

这个消息处理就是调用了updatePowerState函数：

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public void handleMessage(Message msg) {  
  2.     switch (msg.what) {  
  3.         case MSG_UPDATE_POWER_STATE:  
  4.             updatePowerState();  
  5.             break;  
  6.   
  7.         case MSG_PROXIMITY_SENSOR_DEBOUNCED:  
  8.             debounceProximitySensor();  
  9.             break;  
  10.   
  11.         case MSG_SCREEN_ON_UNBLOCKED:  
  12.             if (mPendingScreenOnUnblocker == msg.obj) {  
  13.                 unblockScreenOn();  
  14.                 updatePowerState();  
  15.             }  
  16.             break;  
  17.     }  
  18. }  

updatePowerState函数：

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. private void updatePowerState() {  
  2.     // Update the power state request.  
  3.     final boolean mustNotify;  
  4.     boolean mustInitialize = false;  
  5.     boolean autoBrightnessAdjustmentChanged = false;  
  6.   
  7.     synchronized (mLock) {  
  8.         mPendingUpdatePowerStateLocked = false;  
  9.         if (mPendingRequestLocked == null) {//不为null  
  10.             return; // wait until first actual power request  
  11.         }  
  12.   
  13.         if (mPowerRequest == null) {//第一次  
  14.             mPowerRequest = new DisplayPowerRequest(mPendingRequestLocked);  
  15.             mWaitingForNegativeProximity = mPendingWaitForNegativeProximityLocked;  
  16.             mPendingWaitForNegativeProximityLocked = false;  
  17.             mPendingRequestChangedLocked = false;  
  18.             mustInitialize = true;  
  19.         } else if (mPendingRequestChangedLocked) {  
  20.             autoBrightnessAdjustmentChanged = (mPowerRequest.screenAutoBrightnessAdjustment  
  21.                     != mPendingRequestLocked.screenAutoBrightnessAdjustment);  
  22.             mPowerRequest.copyFrom(mPendingRequestLocked);  
  23.             mWaitingForNegativeProximity |= mPendingWaitForNegativeProximityLocked;  
  24.             mPendingWaitForNegativeProximityLocked = false;  
  25.             mPendingRequestChangedLocked = false;  
  26.             mDisplayReadyLocked = false;  
  27.         }  
  28.   
  29.         mustNotify = !mDisplayReadyLocked;  
  30.     }  
  31.   
  32.     // Initialize things the first time the power state is changed.  
  33.     if (mustInitialize) {//第一次调用  
  34.         initialize();  
  35.     }  

我们来看看initialize函数，初始化了mPowerState

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. private void initialize() {  
  2.     // Initialize the power state object for the default display.  
  3.     // In the future, we might manage multiple displays independently.  
  4.     mPowerState = new DisplayPowerState(mBlanker,  
  5.             new ColorFade(Display.DEFAULT_DISPLAY));  
  6.   
  7.     mColorFadeOnAnimator = ObjectAnimator.ofFloat(  
  8.             mPowerState, DisplayPowerState.COLOR_FADE_LEVEL, 0.0f, 1.0f);  
  9.     mColorFadeOnAnimator.setDuration(COLOR_FADE_ON_ANIMATION_DURATION_MILLIS);  
  10.     mColorFadeOnAnimator.addListener(mAnimatorListener);  
  11.   
  12.     mColorFadeOffAnimator = ObjectAnimator.ofFloat(  
  13.             mPowerState, DisplayPowerState.COLOR_FADE_LEVEL, 1.0f, 0.0f);  
  14.     mColorFadeOffAnimator.setDuration(COLOR_FADE_OFF_ANIMATION_DURATION_MILLIS);  
  15.     mColorFadeOffAnimator.addListener(mAnimatorListener);  
  16.   
  17.     mScreenBrightnessRampAnimator = new RampAnimator<DisplayPowerState>(  
  18.             mPowerState, DisplayPowerState.SCREEN_BRIGHTNESS);  
  19.     mScreenBrightnessRampAnimator.setListener(mRampAnimatorListener);  
  20.   
  21.     // Initialize screen state for battery stats.  
  22.     try {  
  23.         mBatteryStats.noteScreenState(mPowerState.getScreenState());  
  24.         mBatteryStats.noteScreenBrightness(mPowerState.getScreenBrightness());  
  25.     } catch (RemoteException ex) {  
  26.         // same process  
  27.     }  
  28. }  

继续分析updatePowerState函数：

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. int state;  
  2. int brightness = PowerManager.BRIGHTNESS_DEFAULT;  
  3. boolean performScreenOffTransition = false;  
  4. switch (mPowerRequest.policy) {  
  5.     case DisplayPowerRequest.POLICY_OFF:  
  6.         state = Display.STATE_OFF;  
  7.         performScreenOffTransition = true;  
  8.         break;  
  9.     case DisplayPowerRequest.POLICY_DOZE:  
  10.         if (mPowerRequest.dozeScreenState != Display.STATE_UNKNOWN) {  
  11.             state = mPowerRequest.dozeScreenState;  
  12.         } else {  
  13.             state = Display.STATE_DOZE;  
  14.         }  
  15.         if (!mAllowAutoBrightnessWhileDozingConfig) {  
  16.             brightness = mPowerRequest.dozeScreenBrightness;  
  17.         }  
  18.         break;  
  19.     case DisplayPowerRequest.POLICY_DIM:  
  20.     case DisplayPowerRequest.POLICY_BRIGHT:  
  21.     default:  
  22.         state = Display.STATE_ON;  
  23.         break;  
  24. }  
  25. assert(state != Display.STATE_UNKNOWN);  

上面根据传入的policy来决定state的状态，后面又调用了

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. animateScreenStateChange(state, performScreenOffTransition);  
  2. state = mPowerState.getScreenState();  

。。。

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. if (!mPendingScreenOff) {  
  2.     if (state == Display.STATE_ON || state == Display.STATE_DOZE) {  
  3.         animateScreenBrightness(brightness,  
  4.                 slowChange ? BRIGHTNESS_RAMP_RATE_SLOW : BRIGHTNESS_RAMP_RATE_FAST);  
  5.     } else {  
  6.         animateScreenBrightness(brightness, 0);  
  7.     }  
  8. }  


三、DisplayPowerState

animateScreenStateChange函数最终会调用DisplayPowerState的setScreenState函数：

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public void setScreenState(int state) {  
  2.     if (mScreenState != state) {  
  3.         if (DEBUG) {  
  4.             Slog.d(TAG, "setScreenState: state=" + state);  
  5.         }  
  6.   
  7.         mScreenState = state;  
  8.         mScreenReady = false;  
  9.         scheduleScreenUpdate();  
  10.     }  
  11. }  

而animateScreenBrightness通过泛型技术，这里我们就不说了，也最终调用了

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public void setScreenBrightness(int brightness) {  
  2.     if (mScreenBrightness != brightness) {  
  3.         if (DEBUG) {  
  4.             Slog.d(TAG, "setScreenBrightness: brightness=" + brightness);  
  5.         }  
  6.   
  7.         mScreenBrightness = brightness;  
  8.         if (mScreenState != Display.STATE_OFF) {  
  9.             mScreenReady = false;  
  10.             scheduleScreenUpdate();  
  11.         }  
  12.     }  
  13. }  

我们再来看scheduleScreenUpdate函数最终通过异步的形式发送消息。

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. private void scheduleScreenUpdate() {  
  2.     if (!mScreenUpdatePending) {  
  3.         mScreenUpdatePending = true;  
  4.         postScreenUpdateThreadSafe();  
  5.     }  
  6. }  
  7.   
  8. private void postScreenUpdateThreadSafe() {  
  9.     mHandler.removeCallbacks(mScreenUpdateRunnable);  
  10.     mHandler.post(mScreenUpdateRunnable);  
  11. }  

我们再来看mScreenUpdateRunnable

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. private final Runnable mScreenUpdateRunnable = new Runnable() {  
  2.     @Override  
  3.     public void run() {  
  4.         mScreenUpdatePending = false;  
  5.   
  6.         int brightness = mScreenState != Display.STATE_OFF  
  7.                 && mColorFadeLevel > 0f ? mScreenBrightness : 0;  
  8.         if (mPhotonicModulator.setState(mScreenState, brightness)) {  
  9.             if (DEBUG) {  
  10.                 Slog.d(TAG, "Screen ready");  
  11.             }  
  12.             mScreenReady = true;  
  13.             invokeCleanListenerIfNeeded();  
  14.         } else {  
  15.             if (DEBUG) {  
  16.                 Slog.d(TAG, "Screen not ready");  
  17.             }  
  18.         }  
  19.     }  
  20. };  

先调用了mPhotonicModulator.setState函数，我们来看下这个函数：

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public boolean setState(int state, int backlight) {  
  2.     synchronized (mLock) {  
  3.         boolean stateChanged = state != mPendingState;  
  4.         boolean backlightChanged = backlight != mPendingBacklight;  
  5.         if (stateChanged || backlightChanged) {  
  6.             if (DEBUG) {  
  7.                 Slog.d(TAG, "Requesting new screen state: state="  
  8.                         + Display.stateToString(state) + ", backlight=" + backlight);  
  9.             }  
  10.   
  11.             mPendingState = state;// 状态  
  12.             mPendingBacklight = backlight;//亮度  
  13.   
  14.             boolean changeInProgress = mStateChangeInProgress || mBacklightChangeInProgress;  
  15.             mStateChangeInProgress = stateChanged;  
  16.             mBacklightChangeInProgress = backlightChanged;  
  17.   
  18.             if (!changeInProgress) {  
  19.                 Slog.d(TAG,"notify set backlight thread run");  
  20.                 mLock.notifyAll();  
  21.             }  
  22.         }  
  23.         return !mStateChangeInProgress;  
  24.     }  
  25. }  

而这个PhotonicModulator其实是个线程，在DisplayPowerState构造函数中就开启了这个线程：

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public void run() {  
  2.     for (;;) {  
  3.         // Get pending change.  
  4.         final int state;  
  5.         final boolean stateChanged;  
  6.         final int backlight;  
  7.         final boolean backlightChanged;  
  8.         synchronized (mLock) {  
  9.             state = mPendingState;  
  10.             stateChanged = (state != mActualState);  
  11.             backlight = mPendingBacklight;  
  12.             backlightChanged = (backlight != mActualBacklight);  
  13.             if (!stateChanged) {  
  14.                 // State changed applied, notify outer class.  
  15.                 postScreenUpdateThreadSafe();  
  16.                 mStateChangeInProgress = false;  
  17.             }  
  18.             if (!backlightChanged) {  
  19.                 mBacklightChangeInProgress = false;  
  20.             }  
  21.             if (!stateChanged && !backlightChanged) {  
  22.                 try {  
  23.                     mLock.wait();  
  24.                 } catch (InterruptedException ex) { }  
  25.                 continue;  
  26.             }  
  27.             mActualState = state;  
  28.             mActualBacklight = backlight;  
  29.         }  
  30.   
  31.         // Apply pending change.  
  32.         if (true) {  
  33.             Slog.d(TAG, "Updating screen state: state="  
  34.                     + Display.stateToString(state) + ", backlight=" + backlight);  
  35.         }  
  36.         mBlanker.requestDisplayState(state, backlight);  
  37.     }  
  38. }  


四、回调

最后调用了mBlanker.requestDisplayState函数，而这个blanker是从DisplayPowerController传过来的。最终我们看

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public void initPowerManagement(final DisplayPowerCallbacks callbacks, Handler handler,  
  2.         SensorManager sensorManager) {  
  3.     synchronized (mSyncRoot) {  
  4.         DisplayBlanker blanker = new DisplayBlanker() {  
  5.             @Override  
  6.             public void requestDisplayState(int state, int brightness) {  
  7.                 // The order of operations is important for legacy reasons.  
  8.                 if (state == Display.STATE_OFF) {  
  9.                     requestGlobalDisplayStateInternal(state, brightness);  
  10.                 }  
  11.   
  12.                 callbacks.onDisplayStateChange(state);  
  13.   
  14.                 if (state != Display.STATE_OFF) {  
  15.                     requestGlobalDisplayStateInternal(state, brightness);  
  16.                 }  
  17.             }  
  18.         };  
  19.         mDisplayPowerController = new DisplayPowerController(  
  20.                 mContext, callbacks, handler, sensorManager, blanker);  
  21.     }  
  22. }  

是在DisplayManagerService中的initPowerManagement函数中初始化的，而我们现在真正设置节点亮度是放在DisplayManagerService中了，不像以前了。

我们再来看callbacks.onDisplayStateChange函数，是PowerManagerService的onDisplayStateChange也是一些设置。

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public void onDisplayStateChange(int state) {  
  2.     // This method is only needed to support legacy display blanking behavior  
  3.     // where the display's power state is coupled to suspend or to the power HAL.  
  4.     // The order of operations matters here.  
  5.     synchronized (mLock) {  
  6.         if (mDisplayState != state) {  
  7.             mDisplayState = state;  
  8.             if (state == Display.STATE_OFF) {  
  9.                 if (!mDecoupleHalInteractiveModeFromDisplayConfig) {  
  10.                     setHalInteractiveModeLocked(false);  
  11.                 }  
  12.                 if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) {  
  13.                     setHalAutoSuspendModeLocked(true);  
  14.                 }  
  15.             } else {  
  16.                 if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) {  
  17.                     setHalAutoSuspendModeLocked(false);  
  18.                 }  
  19.                 if (!mDecoupleHalInteractiveModeFromDisplayConfig) {  
  20.                     setHalInteractiveModeLocked(true);  
  21.                 }  
  22.             }  
  23.         }  
  24.     }  
  25. }  

最后我们再回到DisplayPowerController中的updatePowerState函数的最后一段代码：

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. final boolean ready = mPendingScreenOnUnblocker == null  
  2.          && !mColorFadeOnAnimator.isStarted()  
  3.          && !mColorFadeOffAnimator.isStarted()  
  4.          && mPowerState.waitUntilClean(mCleanListener);  
  5.  final boolean finished = ready  
  6.          && !mScreenBrightnessRampAnimator.isAnimating();  
  7.   
  8.  // Notify policy about screen turned on.  
  9.  if (ready && state != Display.STATE_OFF  
  10.          && mReportedScreenStateToPolicy == REPORTED_TO_POLICY_SCREEN_TURNING_ON) {  
  11.      mReportedScreenStateToPolicy = REPORTED_TO_POLICY_SCREEN_ON;  
  12.      mWindowManagerPolicy.screenTurnedOn();  
  13.  }  
  14.   
  15.  // Grab a wake lock if we have unfinished business.  
  16.  if (!finished && !mUnfinishedBusiness) {//没有完成  
  17.      if (DEBUG) {  
  18.          Slog.d(TAG, "Unfinished business...");  
  19.      }  
  20.      mCallbacks.acquireSuspendBlocker();//持锁，PowerManagerService的回调  
  21.      mUnfinishedBusiness = true;  
  22.  }  
  23.   
  24.  // Notify the power manager when ready.  
  25.  if (ready && mustNotify) {  
  26.      // Send state change.  
  27.      synchronized (mLock) {  
  28.          if (!mPendingRequestChangedLocked) {  
  29.              mDisplayReadyLocked = true;  
  30.   
  31.              if (DEBUG) {  
  32.                  Slog.d(TAG, "Display ready!");  
  33.              }  
  34.          }  
  35.      }  
  36.      sendOnStateChangedWithWakelock();  
  37.  }  
  38.   
  39.  // Release the wake lock when we have no unfinished business.  
  40.  if (finished && mUnfinishedBusiness) {  
  41.      if (DEBUG) {  
  42.          Slog.d(TAG, "Finished business...");  
  43.      }  
  44.      mUnfinishedBusiness = false;  
  45.      mCallbacks.releaseSuspendBlocker();//完成释放锁  
  46.  }  

ready这个变量非常重要，直接说明DisplayPowerController是否准备好，我们看这个ready变量和DisplayPowerState的waitUntilClean相关

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public boolean waitUntilClean(Runnable listener) {  
  2.     if (!mScreenReady || !mColorFadeReady) {  
  3.         mCleanListener = listener;  
  4.         return false;  
  5.     } else {  
  6.         mCleanListener = null;  
  7.         return true;  
  8.     }  
  9. }  

只有到mScreenReady才会返回true，而这个变量是在之前setScreenState和setScreenBrightness函数中异步发送消息，才会调用。

补充：原文里面没有提到waitUntilClean被调用时，屏幕还没有完成更新，所以mScreenReady为false，

所以这里会向mCleanListener注册的这个回调，这个回调的作用是等待DisplayPowerState中mPhotonicModulator线程

更新状态mScreenReady为true，然后进入invokeCleanListenerIfNeeded调用mCleanListener，这样会再次进入到

DisplayPowerController.updatePowerState函数，从而打通DisplayPowerState更新过程

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. private final Runnable mScreenUpdateRunnable = new Runnable() {  
  2.     @Override  
  3.     public void run() {  
  4.         mScreenUpdatePending = false;  
  5.   
  6.         int brightness = mScreenState != Display.STATE_OFF  
  7.                 && mColorFadeLevel > 0f ? mScreenBrightness : 0;  
  8.         if (mPhotonicModulator.setState(mScreenState, brightness)) {  
  9.             if (DEBUG) {  
  10.                 Slog.d(TAG, "Screen ready");  
  11.             }  
  12.             mScreenReady = true;  
  13.             invokeCleanListenerIfNeeded();  
  14.         } else {  
  15.             if (DEBUG) {  
  16.                 Slog.d(TAG, "Screen not ready");  
  17.             }  
  18.         }  
  19.     }  
  20. };  

最后我们再来看DisplayPowerController的updatePowerState函数

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. // Grab a wake lock if we have unfinished business.  
  2. if (!finished && !mUnfinishedBusiness) {//没有完成  
  3.     if (DEBUG) {  
  4.         Slog.d(TAG, "Unfinished business...");  
  5.     }  
  6.     mCallbacks.acquireSuspendBlocker();//持锁，PowerManagerService的回调  
  7.     mUnfinishedBusiness = true;  
  8. }  
  9.   
  10. // Notify the power manager when ready.  
  11. if (ready && mustNotify) {  
  12.     // Send state change.  
  13.     synchronized (mLock) {  
  14.         if (!mPendingRequestChangedLocked) {  
  15.             mDisplayReadyLocked = true;  
  16.   
  17.             if (DEBUG) {  
  18.                 Slog.d(TAG, "Display ready!");  
  19.             }  
  20.         }  
  21.     }  
  22.     sendOnStateChangedWithWakelock();  
  23. }  
  24.   
  25. // Release the wake lock when we have no unfinished business.  
  26. if (finished && mUnfinishedBusiness) {  
  27.     if (DEBUG) {  
  28.         Slog.d(TAG, "Finished business...");  
  29.     }  
  30.     mUnfinishedBusiness = false;  
  31.     mCallbacks.releaseSuspendBlocker();//完成释放锁  
  32. }  

没完成，调用PowerManagerService的回调，下面就是持锁和释放锁，调用的是Displays的锁。

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. @Override  
  2. public void acquireSuspendBlocker() {  
  3.     mDisplaySuspendBlocker.acquire();  
  4. }  
  5.   
  6. @Override  
  7. public void releaseSuspendBlocker() {  
  8.     mDisplaySuspendBlocker.release();  
  9. }  

最后完成了释放锁，mDisplayReadyLocked = true，调用了sendOnStateChangedWithWakelock函数

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. private void sendOnStateChangedWithWakelock() {  
  2.     mCallbacks.acquireSuspendBlocker();  
  3.     mHandler.post(mOnStateChangedRunnable);  
  4. }  
  5.   
  6. private final Runnable mOnStateChangedRunnable = new Runnable() {  
  7.     @Override  
  8.     public void run() {  
  9.         mCallbacks.onStateChanged();  
  10.         mCallbacks.releaseSuspendBlocker();  
  11.     }  
  12. };  


五、PowerManagerService第二次调用requestPowerState

我们再来看看onStateChanged，就是调用PowerManagerService的updatePowerStateLocked函数，最终会再次调用DisplayPowerController的requestPowerState函数

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public void onStateChanged() {  
  2.     synchronized (mLock) {  
  3.         mDirty |= DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED;  
  4.         updatePowerStateLocked();  
  5.     }  
  6. }  

在updatePowerStateLocked中第二次调用updateDisplayPowerStateLocked。于是又来到了DisplayPowerController的requestPowerState函数，现在是第二次调用过来了。

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public boolean requestPowerState(DisplayPowerRequest request,  
  2.         boolean waitForNegativeProximity) {  
  3.   
  4.     synchronized (mLock) {  
  5.         boolean changed = false;  
  6.   
  7.         if (waitForNegativeProximity  
  8.                 && !mPendingWaitForNegativeProximityLocked) {  
  9.             mPendingWaitForNegativeProximityLocked = true;  
  10.             changed = true;  
  11.         }  
  12.   
  13.         if (mPendingRequestLocked == null) {  
  14.             mPendingRequestLocked = new DisplayPowerRequest(request);  
  15.             changed = true;  
  16.         } else if (!mPendingRequestLocked.equals(request)) {  
  17.             mPendingRequestLocked.copyFrom(request);  
  18.             changed = true;  
  19.         }  
  20.   
  21.         if (changed) {  
  22.             mDisplayReadyLocked = false;  
  23.         }  
  24.   
  25.         if (changed && !mPendingRequestChangedLocked) {  
  26.             mPendingRequestChangedLocked = true;  
  27.             sendUpdatePowerStateLocked();  
  28.         }  
  29.   
  30.         return mDisplayReadyLocked;//这回直接就返回true了，这个变量是updatePowerState在完成任务后置为true  
  31.     }  
  32. }  

我们再来看updateDisplayPowerStateLocked调用requestPowerState的返回值。只有这次返回mDisplayReady这个成员变量的才是true

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. mDisplayReady = mDisplayManagerInternal.requestPowerState(mDisplayPowerRequest,  
  2.         mRequestWaitForNegativeProximity);  


六、总结

之前分析过android5.1的这块内容，最大的区别是以前设置背光的那部分是放在了DisplayPowerState中的，而现在又放在了DisplayManagerService中了。


收录于
android power

当前文章被收录于：

android power
7 篇文章 0 人学习
订阅专栏 查看详情
Android 8.1 DisplayPowerController(二) Proximity Sensor的亮灭屏 概述 PSensor亮屏和按Power键亮屏流程还是有些不同之处，如开始调用位置、PowerManagerService中的流程等，由于在平常遇到过许多PSensor亮屏相关Bug，因此这里独立地进行下分析。 流程 在DisplayPowerController中，实例化了一个SensorEventListener对PSensor事件进行监听： private final Sensor... 阅读详情

相关推荐

Android6.0 亮屏灭屏流程（DisplayPowerController、WMS）（一）WMS绘制

亮屏、灭屏流程整个流程涉及的模块比较多，包括PowerManagerService、DisplayPowerControl、WMS、AMS。因此在分析完WMS之后，我们把这块也分析下。 DisplayPowerControl 我们知道灭屏流程的发起是在PowerManagerService中，会通过updatePowerState函数调用updateDisplayPowerStateL

kc58236582的博客 8162

Android 8.1 DisplayPowerController(一) 亮灭屏流程

作者：FightFightFight 来源：CSDN 原文：https://blog.csdn.net/FightFightFight/article/details/81320519 概述 DisplayPowerController（以下简称DPC）用于控制显示电源状态，用来处理亮灭屏、背光的调节，包括接近传感器(P-Senser)、光线传感器(L-senser)和亮灭屏动画。它独立于...

sdkdlwk的博客 5767

Android 7.1 亮度调节完整流程分析（一）

Android 7.1 亮度调节完整流程分析（一）： 上一篇说到BrightnessController中设置屏幕亮度是通过调用PowerManagerServicer的setTemporaryScreenBrightnessSettingOverride，那么本篇就从这继续往下分析。 为了对下面的分析有一个总体的认识，我画了一个时序图，以帮助理解。 首先还是从PowerManagerServic...

wangzhiruiyingmuxt的博客 1462

Android 8.1 DisplayPowerController(五) 自动调节亮度(2)——算法

作者：FightFightFight 来源：CSDN 原文：https://blog.csdn.net/FightFightFight/article/details/83718273 在上一篇文章中，对自动背光的流程做了总结，在本篇中，将对自动背光涉及到的一些算法进行分析总结。 1.采集光强缓冲区 AmbientLightRingBuffer类是一个用于存储采集到的光照强度和对应时间点...

sdkdlwk的博客 2687

Android7.0 PowerManagerService亮灭屏分析(二)

    在PowerManagerService中对各种状态进行判断后，将其数值封装进DisplayPowerRequest中传入DisplayPowerController中进一步处理。在亮屏过程中DisplayPowerController会根据传过来的数值来设置新的电源状态为亮屏，然后调用DisplayPowerState来对状态进行设置，在分析DisplayPowerState时会具体讲解...

宇落 生命不息，奋斗不止...... 1万+

android6.0 power显示(亮度等)深入分析(一)PowerManagerService &amp; DisplayPowerController

之前android5.1我们分析过power，但是那篇博客从整体分析显得有些杂乱，这几篇博客都从power的功能来分析，个人觉得更好理解。一、PowerManagerService的显示相关函数由于之前博客都分析过，我们就直接进入PowerManagerService的和显示相关的主体：updateDisplayPowerStateLocked函数：[cpp] view plain copy pr...

淡淡的宁静的博客 411

Android 知识点 109 —— Android7.0 PowerManagerService 之亮灭屏

原文地址：https://www.cnblogs.com/dyufei/p/8017604.html 写的太好了，粘过来！ 本篇从按下power按键后，按键事件从InputManagerService 传到PhoneWindowManager.java开始分析power 按键做屏幕亮灭过程的分析，关于power 按键的其他行为参考另一篇博文（Android 7.0 Power 按键处理流程）...

编程到管理、技术到产品 818

Android 8.0 手机亮灭屏

本文主要跟踪分析通过按松power键来唤醒，熄灭屏幕的逻辑。下面是一些相关类的介绍 PowerManagerService.java：简称PMS，负责Andorid系统中电源管理方面的工作。作为系统核心服务之一，主要处理系统中与power相关的计算，然后决策系统该如何反应。同时PowerManagerService与其他服务及HAL层等都有交互关系，协调power如何与系统其他模块的交互，比如没...

2136

Android电源管理分析

Android电源管理 1.电源管理服务–PowerManagerService ​ PowerManagerService提供Android系统的电源管理服务，主要功能是控制系统的待机状态，控制显示屏的开关和亮度调节，以及查询和控制光线传感器和距离传感器等。 1.1 初始化过程 ​ PowerManagerService是在SystemServer中创建并加入到ServiceManager中的： Slog.i(TAG, "Power Manager"); power = new PowerManag

k663514387的博客 1993

Android7.0 PowerManagerService 之亮灭屏（一）

本篇从按下power按键后，按键事件从InputManagerService 传到PhoneWindowManager.java开始分析power 按键做屏幕亮灭过程的分析，关于power 按键的其他行为参考另一篇博文（Android 7.0 Power 按键处理流程）     （注：博客园显示的图片很模糊，上传的为大图，可以图片另存为查看）     言归正传，本篇涉及的几个模块（文件）如下，...

weixin_34038293的博客 439

PowerManagerService之亮屏流程分析

亮屏的方式有很多，其中最常用的是 Power 键亮屏，这个流程比较简单，本文希望通过分析这个流程，从而理清操作屏幕的通用流程。

m0_56144365的博客 909

Android背光灯控制实现

Android中所有系统灯光的定义：lights.h #define LIGHT_ID_BACKLIGHT “backlight” JNI: com_android_server_lights_LightsService.cpp setLight_native：调用HAL去控制背光 Service：LightsService.java 1.它是各种灯光和背光的Service，提供了对背光灯操作的所有方法 2.setLightLocked()：是实际调用JNI操作背光灯的函数，所有向应用

qq_34888036的博客 2823

android app设置亮屏的几种方式以及功耗对比

在Android app开发中，为了让某个页面持续显示一定时间，需要设置亮屏代码。 常用的方法有四种，分别如下： 方法1：通过PowerManager获取wakelock。 方法2：在view中设置view.setKeepScreenOn(true); 方法3：设置WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON 和 setTurnScreenO...

linchuanzhi_886的专栏 4134

AOD相关机制

AOD的概念： AOD,即A（lways） O（n） D（isplay）是android一种低功耗的显示模式的一种应用，他能保证屏幕某块区域一直亮，该应用开启时绘制的频率会低于正常的频率。由于AOD现实的不是和正常的亮屏之后显示的一样，只 会显示非黑色的部分，而且频率低于正常的频率 ，所以即使一直在显示功耗也比较低。 AOD进程的流程： AOD是一个应用，主要是通过DreamManagerS...

cr459464757的专栏 7837

Android手机亮屏流程分析

极力推荐Android 开发大总结文章：欢迎收藏程序员Android 力荐 ，Android 开发者需要的必备技能注：文章转于网络，点击查看原文PowerManagerS...

程序员Android 1849

Android 10亮屏、熄屏和自动调光

Android 10 亮屏、息屏、自动亮度代码流程

mart!nhu的博客 1万+
上一篇： Android 'M' Doze
下一篇： android6.0 power显示(亮度等)深入分析(二)DisplayManagerService
点赞 0
评论 0
书签 书签 0
thinkinwm
thinkinwm
博客等级 码龄17年 346粉丝 50原创
+ 关注 专栏目录 订阅专栏
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值