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

最新推荐文章于 2024-05-10 12:19:56 发布
最新推荐文章于 2024-05-10 12:19:56 发布
阅读量1.2k 收藏
点赞数
分类专栏： android power

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中了。


thinkinwm
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rk平台android6.0系统栏以广播的方式显示与隐藏
05-21
才用广播的形式控制系统导航栏，状态栏的显示与隐藏，同时增添系统属性def_systembar_hide来控制默认开机时系统栏的显示与否
Android 10亮屏、熄屏和自动调光
mart!nhu的博客
09-02 9346
Android 10 亮屏、息屏、自动亮度代码流程
Android 8.1 DisplayPowerController(五) 自动调节亮度(2)——算法
sdkdlwk的博客
03-09 2192
作者：FightFightFight 来源：CSDN 原文：https://blog.csdn.net/FightFightFight/article/details/83718273 在上一篇文章中，对自动背光的流程做了总结，在本篇中，将对自动背光涉及到的一些算法进行分析总结。 1.采集光强缓冲区 AmbientLightRingBuffer类是一个用于存储采集到的光照强度和对应时间点...
PowerManagerService之亮屏流程分析_powermanagerservice display(2)
最新发布
2401_84871506的博客
05-10 556
根据英文注释，更新 PMS 的 wakefulness 过程分为三个阶段，最主要的是在第二个阶段，更新 wakefulness 相关变量，然后 Notifier 通知其它组件并发送亮屏通知，过程如下，大家看一下就行，这不是重点。// TODO: 为何 PMS 的 wakefulness 要设置为所有 display group 的最大的 wakefulness?// mDirty 设置 DIRTY_WAKEFULNESS，表示 PMS 的 wakefulness 改变了。
Android 8.1 DisplayPowerController(一) 亮灭屏流程
sdkdlwk的博客
03-09 4711
作者：FightFightFight 来源：CSDN 原文：https://blog.csdn.net/FightFightFight/article/details/81320519 概述 DisplayPowerController（以下简称DPC）用于控制显示电源状态，用来处理亮灭屏、背光的调节，包括接近传感器(P-Senser)、光线传感器(L-senser)和亮灭屏动画。它独立于...
PowerManagerService之亮屏流程分析
m0_56144365的博客
11-06 635
亮屏的方式有很多，其中最常用的是 Power 键亮屏，这个流程比较简单，本文希望通过分析这个流程，从而理清操作屏幕的通用流程。
Android背光灯控制实现
qq_34888036的博客
04-13 1868
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操作背光灯的函数，所有向应用
android app设置亮屏的几种方式以及功耗对比
linchuanzhi_886的专栏
01-17 2820
在Android app开发中，为了让某个页面持续显示一定时间，需要设置亮屏代码。 常用的方法有四种，分别如下： 方法1：通过PowerManager获取wakelock。 方法2：在view中设置view.setKeepScreenOn(true); 方法3：设置WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON 和 setTurnScreenO...
Android6.0 动态权限机制深入讲解
08-18
Android 6.0 动态权限机制深入讲解 Android 6.0 引入了动态权限机制，这是一种新的权限管理机制，它允许用户在应用程序运行时授予或撤销权限，而不仅仅是在 AndroidManifest 文件中指定权限。这种机制的引入，使得...
PowerBuilder 6.0 Enterprise.7z
08-04
PowerBuilder 6.0 Enterprise原版光盘 pb6版本的安装文件和补丁文件，请自行选择下载(Pb6 version of the installation file and patch file)里面有6.5升级包
Android 6.0上sdcard和U盘路径获取和区分方法
08-27
Android 6.0中，获取sdcard和U盘的路径并进行区分是一项非常重要的任务。在Android 6.0中，系统会根据卡的种类和卡的挂载状态来动态生成挂载路径，因此之前写固定路径的办法不可用。通过网上查找和分析android源码，...
Android指纹识别功能深入浅出分析到实战（6.0以下系统解决方案）
01-05
Google从Android6.0（api23）开始才提供标准指纹识别支持，并对外提供指纹识别相关的接口。本文除了能适配6.0及以上系统，主要还提供6.0以下设备适配解决方案。 指纹识别用途 大概列举几个指纹识别的用途 系统解锁 ...
Android7.0 PowerManagerService亮灭屏分析(二)
宇落 生命不息，奋斗不止......
01-13 9818
    在PowerManagerService中对各种状态进行判断后，将其数值封装进DisplayPowerRequest中传入DisplayPowerController中进一步处理。在亮屏过程中DisplayPowerController会根据传过来的数值来设置新的电源状态为亮屏，然后调用DisplayPowerState来对状态进行设置，在分析DisplayPowerState时会具体讲解...
AOD相关机制
cr459464757的专栏
08-17 4152
AOD的概念： AOD,即A（lways） O（n） D（isplay）是android一种低功耗的显示模式的一种应用，他能保证屏幕某块区域一直亮，该应用开启时绘制的频率会低于正常的频率。由于AOD现实的不是和正常的亮屏之后显示的一样，只 会显示非黑色的部分，而且频率低于正常的频率 ，所以即使一直在显示功耗也比较低。 AOD进程的流程： AOD是一个应用，主要是通过DreamManagerS...
Android手机亮屏流程分析
程序员Android
01-14 1466
极力推荐Android 开发大总结文章：欢迎收藏程序员Android 力荐 ，Android 开发者需要的必备技能注：文章转于网络，点击查看原文PowerManagerS...
Android 8.1 DisplayPowerController(四) 自动调节亮度(1)——流程
FightFightFight的博客
11-04 6216
和手动调节亮度相比，自动调节亮度则稍微复杂些。其中涉及到多个算法。这里先笼统地介绍其流程，对涉及到的算法在下一篇文章中进行学习。 从前面的分析得到，不管是哪种背光调节方式，其最终都会在DisplayPowerController的updatePowerState()方法中进行决策，得到最终的背光值，自动背光的亮度也不例外： private void updatePowerState() { ...
android自动亮度流程,android5.1 自动亮度调节简析
weixin_39575737的博客
05-25 481
android亮度调节在"设置"的"显示"中,分为手动调节和自动调节。其中手动调节就是通过拖动"亮度调节"的拖动条来直接设置亮度值，自动调节则比较复杂，设置自动亮度模式后，再拖动"亮度调节"的拖动条,可以小范围改变亮度值(前提是光照条件不剧烈变化)，但这时不是直接设置的亮度值,而是需要通过一系列转变转成亮度值。现在遇到问题是：在自动亮度调节模式下，调节亮度拖动条到最小，屏幕变得很黑。设置中的亮度设...
Android 亮屏流程分析
kv110的专栏
12-09 1573
https://blog.csdn.net/FightFightFight/article/details/79808100 相关文章：[Android Framework] 8.1 PowerManagerService分析(一)——PMS的启动[Android Framework] 8.1 PowerManagerService分析(二) ——updatePowerStateLocked()方法[Android Framework] 8.1 PowerManagerService分析(三)——Wake
Android 7.1 亮度调节完整流程分析（一）
m0_52481422的博客
06-07 772
Android 7.1 亮度调节完整流程分析（一） 上一篇说到BrightnessController中设置屏幕亮度是通过调用PowerManagerService的setTemporaryScreenBrightnessSettingOverride，那么本篇就从这继续往下分析。 为了对下面的分析有一个总体的认识，我画了一个时序图，以帮助理解。本部分将会分三篇讲述，时序图标红的地方代表当前篇分析的起点。 首先从PowerManagerService.setTemporaryScreenAutoBrigh
android6.0 adbd深入分析(三)adb root重启adbd流程
07-31
在Android 6.0中，adb root重启adbd的流程如下：首先，PC端的adb server与手机端的守护进程adbd建立连接。然后，PC端的adb client通过adb server转发命令，adbd接收命令后解析运行。在adbd处理adb root的代码中，首先会检查当前的用户ID是否为0，如果是0，说明已经是root了，会返回"adbd is already running as root"的消息。如果不是0，则会获取系统属性"ro.debuggable"的值，如果该值不等于"1"，则不允许adbd以root权限运行，并返回"adbd cannot run as root in production builds"的消息。如果"ro.debuggable"的值等于"1"，则会设置属性"service.adb.root"为"1"，然后返回"restarting adbd as root"的消息，最后关闭连接。这样就完成了adb root重启adbd的流程。[1][2][3]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值