and5.1PowerManagerService深入分析(四)PMS与Display模块

and5.1PowerManagerService深入分析(四)PMS与Display模块

转自:http://blog.csdn.net/kc58236582/article/details/48007945



PMS与Display模块的交互在之前的一篇博客也写过,但不是写的很详细。

在PMS的systemReady方法中,有如下两段代码:

[java] 
view plain
 copy

  1. mDisplayManagerInternal = getLocalService(DisplayManagerInternal.class);  

[java] 
view plain
 copy

  1. mDisplayManagerInternal.initPowerManagement(  
  2.         mDisplayPowerCallbacks, mHandler, sensorManager);  

在DisplayManagerService中有一个内部LocalService类,而在PMS的systemReady方法中的mDisplayManagerInternal 也正是这个内部类LocalService,其将mDisplayPowerCallbacks、mHandler、SensorManager传给了DisplayPowerController

[java] 
view plain
 copy

  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) {  
  9.                        // The order of operations is important for legacy reasons.  
  10.                        if (state == Display.STATE_OFF) {  
  11.                            requestGlobalDisplayStateInternal(state);  
  12.                        }  
  13.   
  14.                        callbacks.onDisplayStateChange(state);  
  15.   
  16.                        if (state != Display.STATE_OFF) {  
  17.                            requestGlobalDisplayStateInternal(state);  
  18.                        }  
  19.                    }  
  20.                };  
  21.                mDisplayPowerController = new DisplayPowerController(//新建了一个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.        }  
  32.   
  33.        @Override  
  34.        public boolean isProximitySensorAvailable() {  
  35.            return mDisplayPowerController.isProximitySensorAvailable();  
  36.        }  
  37.   
  38.        @Override  
  39.        public DisplayInfo getDisplayInfo(int displayId) {  
  40.            return getDisplayInfoInternal(displayId, Process.myUid());  
  41.        }  
  42.   
  43.        @Override  
  44.        public void registerDisplayTransactionListener(DisplayTransactionListener listener) {  
  45.            if (listener == null) {  
  46.                throw new IllegalArgumentException(“listener must not be null”);  
  47.            }  
  48.   
  49.            registerDisplayTransactionListenerInternal(listener);  
  50.        }  
  51.   
  52.        @Override  
  53.        public void unregisterDisplayTransactionListener(DisplayTransactionListener listener) {  
  54.            if (listener == null) {  
  55.                throw new IllegalArgumentException(“listener must not be null”);  
  56.            }  
  57.   
  58.            unregisterDisplayTransactionListenerInternal(listener);  
  59.        }  
  60.   
  61.        @Override  
  62.        public void setDisplayInfoOverrideFromWindowManager(int displayId, DisplayInfo info) {  
  63.            setDisplayInfoOverrideFromWindowManagerInternal(displayId, info);  
  64.        }  
  65.   
  66.        @Override  
  67.        public void performTraversalInTransactionFromWindowManager() {  
  68.            performTraversalInTransactionFromWindowManagerInternal();  
  69.        }  
  70.   
  71.        @Override  
  72.        public void setDisplayProperties(int displayId, boolean hasContent,  
  73.                float requestedRefreshRate, boolean inTraversal) {  
  74.            setDisplayPropertiesInternal(displayId, hasContent, requestedRefreshRate, inTraversal);  
  75.        }  

而在上一篇PMS的博客我们,我们分析到updateDisplayPowerStateLocked函数mDisplayManagerInternal.requestPowerState,这里requestPowerState就调用了上面的方法,最后调用了DisplayPowerController里的requestPowerState方法。

我们先来看下DisplayPowerController类的构造函数

[java] 
view plain
 copy

  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.      mLights = LocalServices.getService(LightsManager.class);//获取各种manager等  
  9.      mSensorManager = sensorManager;  
  10.      mWindowManagerPolicy = LocalServices.getService(WindowManagerPolicy.class);  
  11.      mBlanker = blanker;  
  12.      mContext = context;  
  13.   
  14.      mPowerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE);  
  15.   
  16.      final Resources resources = context.getResources();//获取各种资源  
  17.      final int screenBrightnessSettingMinimum = clampAbsoluteBrightness(resources.getInteger(  
  18.              com.android.internal.R.integer.config_screenBrightnessSettingMinimum));  
  19.   
  20.      mScreenBrightnessDozeConfig = clampAbsoluteBrightness(resources.getInteger(  
  21.              com.android.internal.R.integer.config_screenBrightnessDoze));  
  22.   
  23.      mScreenBrightnessDimConfig = clampAbsoluteBrightness(resources.getInteger(  
  24.              com.android.internal.R.integer.config_screenBrightnessDim));  
  25.   
  26.      mScreenBrightnessDarkConfig = clampAbsoluteBrightness(resources.getInteger(  
  27.              com.android.internal.R.integer.config_screenBrightnessDark));  
  28.      if (mScreenBrightnessDarkConfig > mScreenBrightnessDimConfig) {  
  29.          Slog.w(TAG, “Expected config_screenBrightnessDark (“  
  30.                  + mScreenBrightnessDarkConfig + “) to be less than or equal to “  
  31.                  + “config_screenBrightnessDim (“ + mScreenBrightnessDimConfig + “).”);  
  32.      }  
  33.      if (mScreenBrightnessDarkConfig > mScreenBrightnessDimConfig) {  
  34.          Slog.w(TAG, “Expected config_screenBrightnessDark (“  
  35.                  + mScreenBrightnessDarkConfig + “) to be less than or equal to “  
  36.                  + “config_screenBrightnessSettingMinimum (“  
  37.                  + screenBrightnessSettingMinimum + “).”);  
  38.      }  
  39.   
  40.      int screenBrightnessRangeMinimum = Math.min(Math.min(  
  41.              screenBrightnessSettingMinimum, mScreenBrightnessDimConfig),  
  42.              mScreenBrightnessDarkConfig);  
  43.   
  44.      mScreenBrightnessRangeMaximum = PowerManager.BRIGHTNESS_ON;  
  45.   
  46.      mUseSoftwareAutoBrightnessConfig = resources.getBoolean(  
  47.              com.android.internal.R.bool.config_automatic_brightness_available);  
  48.   
  49.      mAllowAutoBrightnessWhileDozingConfig = resources.getBoolean(  
  50.              com.android.internal.R.bool.config_allowAutoBrightnessWhileDozing);  
  51.   
  52.      if (mUseSoftwareAutoBrightnessConfig) {  
  53.          int[] lux = resources.getIntArray(  
  54.                  com.android.internal.R.array.config_autoBrightnessLevels);  
  55.          int[] screenBrightness = resources.getIntArray(  
  56.                  com.android.internal.R.array.config_autoBrightnessLcdBacklightValues);  
  57.          int lightSensorWarmUpTimeConfig = resources.getInteger(  
  58.                  com.android.internal.R.integer.config_lightSensorWarmupTime);  
  59.          final float dozeScaleFactor = resources.getFraction(  
  60.                  com.android.internal.R.fraction.config_screenAutoBrightnessDozeScaleFactor,  
  61.                  11);  
  62.   
  63.          Spline screenAutoBrightnessSpline = createAutoBrightnessSpline(lux, screenBrightness);  
  64.          if (screenAutoBrightnessSpline == null) {  
  65.              Slog.e(TAG, “Error in config.xml.  config_autoBrightnessLcdBacklightValues “  
  66.                      + “(size “ + screenBrightness.length + “) “  
  67.                      + “must be monotic and have exactly one more entry than “  
  68.                      + “config_autoBrightnessLevels (size “ + lux.length + “) “  
  69.                      + “which must be strictly increasing.  “  
  70.                      + “Auto-brightness will be disabled.”);  
  71.              mUseSoftwareAutoBrightnessConfig = false;  
  72.          } else {  
  73.              int bottom = clampAbsoluteBrightness(screenBrightness[0]);  
  74.              if (mScreenBrightnessDarkConfig > bottom) {  
  75.                  Slog.w(TAG, “config_screenBrightnessDark (“ + mScreenBrightnessDarkConfig  
  76.                          + “) should be less than or equal to the first value of “  
  77.                          + “config_autoBrightnessLcdBacklightValues (“  
  78.                          + bottom + “).”);  
  79.              }  
  80.              if (bottom < screenBrightnessRangeMinimum) {  
  81.                  screenBrightnessRangeMinimum = bottom;  
  82.              }  
  83.              mAutomaticBrightnessController = new AutomaticBrightnessController(this,  
  84.                      handler.getLooper(), sensorManager, screenAutoBrightnessSpline,  
  85.                      lightSensorWarmUpTimeConfig, screenBrightnessRangeMinimum,  
  86.                      mScreenBrightnessRangeMaximum, dozeScaleFactor);  
  87.          }  
  88.      }  
  89.   
  90.      mScreenBrightnessRangeMinimum = screenBrightnessRangeMinimum;  
  91.   
  92.      mColorFadeFadesConfig = resources.getBoolean(  
  93.              com.android.internal.R.bool.config_animateScreenLights);  
  94.   
  95.      if (!DEBUG_PRETEND_PROXIMITY_SENSOR_ABSENT) {  
  96.          mProximitySensor = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);  
  97.          if (mProximitySensor != null) {  
  98.              mProximityThreshold = Math.min(mProximitySensor.getMaximumRange(),  
  99.                      TYPICAL_PROXIMITY_THRESHOLD);  
  100.          }  
  101.      }  
  102.   
  103.  }  

下面我们就来分析下requestPowerState函数:

[java] 
view plain
 copy

  1. public boolean requestPowerState(DisplayPowerRequest request,  
  2.             boolean waitForNegativeProximity) {  
  3.         if (DEBUG) {  
  4.             Slog.d(TAG, “requestPowerState: “  
  5.                     + request + “, waitForNegativeProximity=” + waitForNegativeProximity);  
  6.         }  
  7.   
  8.         synchronized (mLock) {  
  9.             boolean changed = false;  
  10.   
  11.             if (waitForNegativeProximity//先不分析距离传感器那块  
  12.                     && !mPendingWaitForNegativeProximityLocked) {  
  13.                 mPendingWaitForNegativeProximityLocked = true;  
  14.                 changed = true;  
  15.             }  
  16.   
  17.             if (mPendingRequestLocked == null) {//第一次进来  
  18.                 mPendingRequestLocked = new DisplayPowerRequest(request);//new 一个mPendingRequestLocked 对象  
  19.                 changed = true;  
  20.             } else if (!mPendingRequestLocked.equals(request)) {  
  21.                 mPendingRequestLocked.copyFrom(request);  
  22.                 changed = true;  
  23.             }  
  24.   
  25.             if (changed) {  
  26.                 mDisplayReadyLocked = false;//第一次进来mDisplayReadyLocked 为false  
  27.             }  
  28.   
  29.             if (changed && !mPendingRequestChangedLocked) {  
  30.                 mPendingRequestChangedLocked = true;//第一次进来,肯定走进  
  31.                 sendUpdatePowerStateLocked();  
  32.             }  
  33.   
  34.             return mDisplayReadyLocked;//返回false  
  35.         }  
  36.     }  

再来看下sendUpdatePowerStateLocked函数

[java] 
view plain
 copy

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

既然这边是发送消息,那么requestPowerState就直接返回mDisplayReadyLocked了。也就是说PMS第一次调用mDisplayManagerInternal.requestPowerState,mDisplayReady 肯定为false。

[java] 
view plain
 copy

  1. mDisplayReady = mDisplayManagerInternal.requestPowerState(mDisplayPowerRequest,  
  2.         mRequestWaitForNegativeProximity);  

那我们继续分析前面的消息

[java] 
view plain
 copy

  1. @Override  
  2. public void handleMessage(Message msg) {  
  3.     switch (msg.what) {  
  4.         case MSG_UPDATE_POWER_STATE:  
  5.             updatePowerState();  
  6.             break;  

那我们接下来分析下updatePowerState函数:

[java] 
view plain
 copy

  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) {  
  10.             return// wait until first actual power request  
  11.         }  
  12.   
  13.         if (mPowerRequest == null) {//第一次调用肯定走这  
  14.             mPowerRequest = new DisplayPowerRequest(mPendingRequestLocked);//建一个mPowerRequest   
  15.             mWaitingForNegativeProximity = mPendingWaitForNegativeProximityLocked;  
  16.             mPendingWaitForNegativeProximityLocked = false;  
  17.             mPendingRequestChangedLocked = false;  
  18.             mustInitialize = true;//置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.     }  
  36.   
  37.     // Compute the basic display state using the policy.  
  38.     // We might override this below based on other factors.  
  39.     int state;  
  40.     int brightness = PowerManager.BRIGHTNESS_DEFAULT;  
  41.     boolean performScreenOffTransition = false;  
  42.     switch (mPowerRequest.policy) {// 下面分析  
  43.         case DisplayPowerRequest.POLICY_OFF:  
  44.             state = Display.STATE_OFF;  
  45.             performScreenOffTransition = true;  
  46.             break;  
  47.         case DisplayPowerRequest.POLICY_DOZE:  
  48.             if (mPowerRequest.dozeScreenState != Display.STATE_UNKNOWN) {  
  49.                 state = mPowerRequest.dozeScreenState;  
  50.             } else {  
  51.                 state = Display.STATE_DOZE;  
  52.             }  
  53.             if (!mAllowAutoBrightnessWhileDozingConfig) {  
  54.                 brightness = mPowerRequest.dozeScreenBrightness;  
  55.             }  
  56.             break;  
  57.         case DisplayPowerRequest.POLICY_DIM:  
  58.         case DisplayPowerRequest.POLICY_BRIGHT:  
  59.         default:  
  60.             state = Display.STATE_ON;  
  61.             break;  
  62.     }  
  63.     assert(state != Display.STATE_UNKNOWN);  
  64.   
  65.     // Apply the proximity sensor.  
  66.     if (mProximitySensor != null) {  
  67.         if (mPowerRequest.useProximitySensor && state != Display.STATE_OFF) {  
  68.             setProximitySensorEnabled(true);  
  69.             if (!mScreenOffBecauseOfProximity  
  70.                     && mProximity == PROXIMITY_POSITIVE) {  
  71.                 mScreenOffBecauseOfProximity = true;  
  72.                 sendOnProximityPositiveWithWakelock();  
  73.             }  
  74.         } else if (mWaitingForNegativeProximity  
  75.                 && mScreenOffBecauseOfProximity  
  76.                 && mProximity == PROXIMITY_POSITIVE  
  77.                 && state != Display.STATE_OFF) {  
  78.             setProximitySensorEnabled(true);  
  79.         } else {  
  80.             setProximitySensorEnabled(false);  
  81.             //mWaitingForNegativeProximity = false;  
  82.         }  
  83.         if (mScreenOffBecauseOfProximity  
  84.                 && mProximity != PROXIMITY_POSITIVE) {  
  85.             mScreenOffBecauseOfProximity = false;  
  86.             sendOnProximityNegativeWithWakelock();  
  87.         }  
  88.     } else {  
  89.         mWaitingForNegativeProximity = false;  
  90.     }  
  91.     if (mScreenOffBecauseOfProximity) {  
  92.         state = Display.STATE_OFF;  
  93.     }  
  94.   
  95.     // Animate the screen state change unless already animating.  
  96.     // The transition may be deferred, so after this point we will use the  
  97.     // actual state instead of the desired one.  
  98.     animateScreenStateChange(state, performScreenOffTransition);  
  99.     state = mPowerState.getScreenState();  

initialize函数

[java] 
view plain
 copy

  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,//新建DisplayPowerState,将mBlanker传入,传了一个背光的light  
  5.             mLights.getLight(LightsManager.LIGHT_ID_BACKLIGHT),  
  6.             new ColorFade(Display.DEFAULT_DISPLAY));  
  7.   
  8.     mColorFadeOnAnimator = ObjectAnimator.ofFloat(  
  9.             mPowerState, DisplayPowerState.COLOR_FADE_LEVEL, 0.0f, 1.0f);  
  10.     mColorFadeOnAnimator.setDuration(COLOR_FADE_ON_ANIMATION_DURATION_MILLIS);  
  11.     mColorFadeOnAnimator.addListener(mAnimatorListener);  
  12.   
  13.     mColorFadeOffAnimator = ObjectAnimator.ofFloat(  
  14.             mPowerState, DisplayPowerState.COLOR_FADE_LEVEL, 1.0f, 0.0f);  
  15.     mColorFadeOffAnimator.setDuration(COLOR_FADE_OFF_ANIMATION_DURATION_MILLIS);  
  16.     mColorFadeOffAnimator.addListener(mAnimatorListener);  
  17.   
  18.     mScreenBrightnessRampAnimator = new RampAnimator<DisplayPowerState>(  
  19.             mPowerState, DisplayPowerState.SCREEN_BRIGHTNESS);  
  20.     mScreenBrightnessRampAnimator.setListener(mRampAnimatorListener);  
  21.   
  22.     // Initialize screen state for battery stats.  
  23.     try {  
  24.         mBatteryStats.noteScreenState(mPowerState.getScreenState());  
  25.         mBatteryStats.noteScreenBrightness(mPowerState.getScreenBrightness());  
  26.     } catch (RemoteException ex) {  
  27.         // same process  
  28.     }  
  29. }  

继续分析,根据传进来的mPowerRequest.policy不同,给state

[java] 
view plain
 copy

  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);  

再来看看PMS这个mPowerRequest.policy值

[java] 
view plain
 copy

  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();  

而getDesiredScreenPolicyLocked函数如下:

[java] 
view plain
 copy

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

我们再来看看animateScreenStateChange这个函数

[java] 
view plain
 copy

  1. private void animateScreenStateChange(int target, boolean performScreenOffTransition) {  
  2.     // If there is already an animation in progress, don’t interfere with it.  
  3.     if (mColorFadeOnAnimator.isStarted()  
  4.             || mColorFadeOffAnimator.isStarted()) {  
  5.         return;  
  6.     }  
  7.   
  8.     // If we were in the process of turning off the screen but didn’t quite  
  9.     // finish.  Then finish up now to prevent a jarring transition back  
  10.     // to screen on if we skipped blocking screen on as usual.  
  11.     if (mPendingScreenOff && target != Display.STATE_OFF) {// 这是灭屏动画  
  12.         setScreenState(Display.STATE_OFF);  
  13.         mPendingScreenOff = false;  
  14.     }  
  15.   
  16.     if (target == Display.STATE_ON) {  
  17.         // Want screen on.  The contents of the screen may not yet  
  18.         // be visible if the color fade has not been dismissed because  
  19.         // its last frame of animation is solid black.  
  20.         if (!setScreenState(Display.STATE_ON)) {  
  21.             return// screen on blocked  
  22.         }  
  23.         if (USE_COLOR_FADE_ON_ANIMATION && mPowerRequest.isBrightOrDim()) {  
  24.             // Perform screen on animation.  
  25.             if (mPowerState.getColorFadeLevel() == 1.0f) {  
  26.                 mPowerState.dismissColorFade();  
  27.             } else if (mPowerState.prepareColorFade(mContext,  
  28.                     mColorFadeFadesConfig ?  
  29.                             ColorFade.MODE_FADE :  
  30.                                     ColorFade.MODE_WARM_UP)) {  
  31.                 mColorFadeOnAnimator.start();  
  32.             } else {  
  33.                 mColorFadeOnAnimator.end();  
  34.             }  
  35.         } else {// 这里有很多动画的东西,就不看了  
  36.             // Skip screen on animation.  
  37.             mPowerState.setColorFadeLevel(1.0f);  
  38.             mPowerState.dismissColorFade();  
  39.         }  
  40.     } else if (target == Display.STATE_DOZE) {  
  41.         // Want screen dozing.  
  42.         // Wait for brightness animation to complete beforehand when entering doze  
  43.         // from screen on to prevent a perceptible jump because brightness may operate  
  44.         // differently when the display is configured for dozing.  
  45.         if (mScreenBrightnessRampAnimator.isAnimating()  
  46.                 && mPowerState.getScreenState() == Display.STATE_ON) {  
  47.             return;  
  48.         }  
  49.   
  50.         // Set screen state.  
  51.         if (!setScreenState(Display.STATE_DOZE)) {  
  52.             return// screen on blocked  
  53.         }  
  54.   
  55.         // Dismiss the black surface without fanfare.  
  56.         mPowerState.setColorFadeLevel(1.0f);  
  57.         mPowerState.dismissColorFade();  
  58.     } else if (target == Display.STATE_DOZE_SUSPEND) {  
  59.         // Want screen dozing and suspended.  
  60.         // Wait for brightness animation to complete beforehand unless already  
  61.         // suspended because we may not be able to change it after suspension.  
  62.         if (mScreenBrightnessRampAnimator.isAnimating()  
  63.                 && mPowerState.getScreenState() != Display.STATE_DOZE_SUSPEND) {  
  64.             return;  
  65.         }  
  66.   
  67.         // If not already suspending, temporarily set the state to doze until the  
  68.         // screen on is unblocked, then suspend.  
  69.         if (mPowerState.getScreenState() != Display.STATE_DOZE_SUSPEND) {  
  70.             if (!setScreenState(Display.STATE_DOZE)) {  
  71.                 return// screen on blocked  
  72.             }  
  73.             setScreenState(Display.STATE_DOZE_SUSPEND); // already on so can’t block  
  74.         }  
  75.   
  76.         // Dismiss the black surface without fanfare.  
  77.         mPowerState.setColorFadeLevel(1.0f);  
  78.         mPowerState.dismissColorFade();  
  79.     } else {  
  80.         // Want screen off.  
  81.         mPendingScreenOff = true;  
  82.         if (mPowerState.getColorFadeLevel() == 0.0f) {  
  83.             // Turn the screen off.  
  84.             // A black surface is already hiding the contents of the screen.  
  85.             setScreenState(Display.STATE_OFF);  
  86.             mPendingScreenOff = false;  
  87.         } else if (performScreenOffTransition  
  88.                 && mPowerState.prepareColorFade(mContext,  
  89.                         mColorFadeFadesConfig ?  
  90.                                 ColorFade.MODE_FADE : ColorFade.MODE_COOL_DOWN)  
  91.                 && mPowerState.getScreenState() != Display.STATE_OFF) {  
  92.             // Perform the screen off animation.  
  93.             mColorFadeOffAnimator.start();  
  94.         } else {  
  95.             // Skip the screen off animation and add a black surface to hide the  
  96.             // contents of the screen.  
  97.             mColorFadeOffAnimator.end();  
  98.         }  
  99.     }  
  100. }  

再来看看setScreenState函数

[java] 
view plain
 copy

  1. private boolean setScreenState(int state) {  
  2.     if (mPowerState.getScreenState() != state) {  
  3.         final boolean wasOn = (mPowerState.getScreenState() != Display.STATE_OFF);  
  4.         mPowerState.setScreenState(state);//调用DisplayPowerState的setScreenState函数,后面再分析  
  5.   
  6.         // Tell battery stats about the transition.  
  7.         try {  
  8.             mBatteryStats.noteScreenState(state);//电池统计  
  9.         } catch (RemoteException ex) {  
  10.             // same process  
  11.         }  
  12.   
  13.         // Tell the window manager what’s happening.  
  14.         // Temporarily block turning the screen on until the window manager is ready  
  15.         // by leaving a black surface covering the screen.  This surface is essentially  
  16.         // the final state of the color fade animation.  
  17.         boolean isOn = (state != Display.STATE_OFF);  
  18.         if (wasOn && !isOn) {  
  19.             unblockScreenOn();  
  20.             mWindowManagerPolicy.screenTurnedOff();//通知phonewindowManager  
  21.         } else if (!wasOn && isOn) {  
  22.             if (mPowerState.getColorFadeLevel() == 0.0f) {  
  23.                 blockScreenOn();  
  24.             } else {  
  25.                 unblockScreenOn();  
  26.             }  
  27.             mWindowManagerPolicy.screenTurningOn(mPendingScreenOnUnblocker);  
  28.         }  
  29.     }  
  30.     return mPendingScreenOnUnblocker == null;  
  31. }  

继续分析updatePowerState函数

[java] 
view plain
 copy

  1. animateScreenStateChange(state, performScreenOffTransition);// 设置到mPowerState状态  
  2. state = mPowerState.getScreenState();//再获取  
  3.   
  4. // Use zero brightness when screen is off.  
  5. if (state == Display.STATE_OFF) {  
  6.     brightness = PowerManager.BRIGHTNESS_OFF;//根据状态,亮度设置  
  7. }  
  8.   
  9. // Configure auto-brightness.  
  10. boolean autoBrightnessEnabled = false;  
  11. if (mAutomaticBrightnessController != null) {  
  12.     final boolean autoBrightnessEnabledInDoze = mAllowAutoBrightnessWhileDozingConfig  
  13.             && (state == Display.STATE_DOZE || state == Display.STATE_DOZE_SUSPEND);  
  14.     autoBrightnessEnabled = mPowerRequest.useAutoBrightness  
  15.             && (state == Display.STATE_ON || autoBrightnessEnabledInDoze)  
  16.             && brightness < 0;  
  17.     mAutomaticBrightnessController.configure(autoBrightnessEnabled,  
  18.             mPowerRequest.screenAutoBrightnessAdjustment, state != Display.STATE_ON);  
  19. }  
  20.   
  21. // Apply brightness boost.  
  22. // We do this here after configuring auto-brightness so that we don’t  
  23. // disable the light sensor during this temporary state.  That way when  
  24. // boost ends we will be able to resume normal auto-brightness behavior  
  25. // without any delay.  
  26. if (mPowerRequest.boostScreenBrightness  
  27.         && brightness != PowerManager.BRIGHTNESS_OFF) {  
  28.     brightness = PowerManager.BRIGHTNESS_ON;//boostScreenBrightness为最亮255  
  29. }  
  30.   
  31. // Apply auto-brightness.  
  32. boolean slowChange = false;  
  33. if (brightness < 0) {  
  34.     if (autoBrightnessEnabled) {  
  35.         brightness = mAutomaticBrightnessController.getAutomaticScreenBrightness();  
  36.     }  
  37.     if (brightness >= 0) {  
  38.         // Use current auto-brightness value and slowly adjust to changes.  
  39.         brightness = clampScreenBrightness(brightness);  
  40.         if (mAppliedAutoBrightness && !autoBrightnessAdjustmentChanged) {  
  41.             slowChange = true// slowly adapt to auto-brightness  
  42.         }  
  43.         mAppliedAutoBrightness = true;  
  44.     } else {  
  45.         mAppliedAutoBrightness = false;  
  46.     }  
  47. else {  
  48.     mAppliedAutoBrightness = false;  
  49. }  
  50.   
  51. // Use default brightness when dozing unless overridden.  
  52. if (brightness < 0 && (state == Display.STATE_DOZE  
  53.         || state == Display.STATE_DOZE_SUSPEND)) {  
  54.     brightness = mScreenBrightnessDozeConfig;  
  55. }  
  56.   
  57. // Apply manual brightness.  
  58. // Use the current brightness setting from the request, which is expected  
  59. // provide a nominal default value for the case where auto-brightness  
  60. // is not ready yet.  
  61. if (brightness < 0) {  
  62.     brightness = clampScreenBrightness(mPowerRequest.screenBrightness);  
  63. }  
  64.   
  65. // Apply dimming by at least some minimum amount when user activity  
  66. // timeout is about to expire.  
  67. if (mPowerRequest.policy == DisplayPowerRequest.POLICY_DIM) {  
  68.     if (brightness > mScreenBrightnessRangeMinimum) {  
  69.         brightness = Math.max(Math.min(brightness – SCREEN_DIM_MINIMUM_REDUCTION,  
  70.                 mScreenBrightnessDimConfig), mScreenBrightnessRangeMinimum);  
  71.     }  
  72.     if (!mAppliedDimming) {  
  73.         slowChange = false;  
  74.     }  
  75.     mAppliedDimming = true;  
  76. }  
  77.   
  78. // If low power mode is enabled, cut the brightness level by half  
  79. // as long as it is above the minimum threshold.  
  80. if (mPowerRequest.lowPowerMode) {//低功耗模式  
  81.     if (brightness > mScreenBrightnessRangeMinimum) {//最小值或者当前值一半取大  
  82.         brightness = Math.max(brightness / 2, mScreenBrightnessRangeMinimum);  
  83.     }  
  84.     if (!mAppliedLowPower) {  
  85.         slowChange = false;  
  86.     }  
  87.     mAppliedLowPower = true;  
  88. }  
  89.   
  90. // Animate the screen brightness when the screen is on or dozing.  
  91. // Skip the animation when the screen is off or suspended.  
  92. if (!mPendingScreenOff) {//这个时候没有灭屏动画  
  93.     if (state == Display.STATE_ON || state == Display.STATE_DOZE) {  
  94.         animateScreenBrightness(brightness,// 这个函数也是在DisplayPowerState设置亮度,待会详细分析  
  95.                 slowChange ? BRIGHTNESS_RAMP_RATE_SLOW : BRIGHTNESS_RAMP_RATE_FAST);  
  96.     } else {  
  97.         animateScreenBrightness(brightness, 0);  
  98.     }  
  99. }  

继续分析updatePowerState函数

[java] 
view plain
 copy

  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. // Grab a wake lock if we have unfinished business.  
  9. if (!finished && !mUnfinishedBusiness) {//我们这工作没有完成,持锁  
  10.     if (DEBUG) {  
  11.         Slog.d(TAG, “Unfinished business…”);  
  12.     }  
  13.     mCallbacks.acquireSuspendBlocker();  
  14.     mUnfinishedBusiness = true;  
  15. }  
  16.   
  17. // Notify the power manager when ready.  
  18. if (ready && mustNotify) {  
  19.     // Send state change.  
  20.     synchronized (mLock) {  
  21.         if (!mPendingRequestChangedLocked) {  
  22.             mDisplayReadyLocked = true;  
  23.   
  24.             if (DEBUG) {  
  25.                 Slog.d(TAG, “Display ready!”);  
  26.             }  
  27.   
  28.         }  
  29.     }  
  30.     sendOnStateChangedWithWakelock();//完成工作后通知PMS  
  31. }  
  32.   
  33. // Release the wake lock when we have no unfinished business.  
  34. if (finished && mUnfinishedBusiness) {//完成释放锁  
  35.     if (DEBUG) {  
  36.         Slog.d(TAG, “Finished business…”);  
  37.     }  
  38.     mUnfinishedBusiness = false;  
  39.     mCallbacks.releaseSuspendBlocker();  
  40. }  

先看这个mCallbacks,是PMS传进来的回调。

[java] 
view plain
 copy

  1. mDisplayManagerInternal.initPowerManagement(  
  2.                     mDisplayPowerCallbacks, mHandler, sensorManager);  

[java] 
view plain
 copy

  1. @Override  
  2. public void acquireSuspendBlocker() {// 持锁  
  3.     mDisplaySuspendBlocker.acquire();  
  4. }  
  5.   
  6. @Override  
  7. public void releaseSuspendBlocker() {//释放锁  
  8.     mDisplaySuspendBlocker.release();  
  9. }  

再看看sendOnStateChangedWithWakelock函数

[java] 
view plain
 copy

  1. private void sendOnStateChangedWithWakelock() {  
  2.     mCallbacks.acquireSuspendBlocker();  
  3.     mHandler.post(mOnStateChangedRunnable);  
  4. }  

[java] 
view plain
 copy

  1. private final Runnable mOnStateChangedRunnable = new Runnable() {  
  2.     @Override  
  3.     public void run() {  
  4.         mCallbacks.onStateChanged();  
  5.         mCallbacks.releaseSuspendBlocker();  
  6.     }  
  7. };  

而PMS里的mDisplayPowerCallbacks 的onStateChanged如下

[java] 
view plain
 copy

  1. private final DisplayManagerInternal.DisplayPowerCallbacks mDisplayPowerCallbacks =  
  2.         new DisplayManagerInternal.DisplayPowerCallbacks() {  
  3.     private int mDisplayState = Display.STATE_UNKNOWN;  
  4.   
  5.     @Override  
  6.     public void onStateChanged() {  
  7.         synchronized (mLock) {  
  8.             mDirty |= DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED;  
  9.             updatePowerStateLocked();//更新状态  
  10.         }  
  11.     }  

那会重新调用到PMS的updateDisplayPowerStateLocked函数,再调用下面。

[java] 
view plain
 copy

  1. mDisplayReady = mDisplayManagerInternal.requestPowerState(mDisplayPowerRequest,  
  2.         mRequestWaitForNegativeProximity);  

现在我们再来看,由于changed没有变化,最后返回true。

[java] 
view plain
 copy

  1. public boolean requestPowerState(DisplayPowerRequest request,  
  2.         boolean waitForNegativeProximity) {  
  3.     if (DEBUG) {  
  4.         Slog.d(TAG, “requestPowerState: “  
  5.                 + request + “, waitForNegativeProximity=” + waitForNegativeProximity);  
  6.     }  
  7.   
  8.     synchronized (mLock) {  
  9.         boolean changed = false;  
  10.   
  11.         if (waitForNegativeProximity  
  12.                 && !mPendingWaitForNegativeProximityLocked) {  
  13.             mPendingWaitForNegativeProximityLocked = true;  
  14.             changed = true;  
  15.         }  
  16.   
  17.         if (mPendingRequestLocked == null) {  
  18.             mPendingRequestLocked = new DisplayPowerRequest(request);  
  19.             changed = true;  
  20.         } else if (!mPendingRequestLocked.equals(request)) {  
  21.             mPendingRequestLocked.copyFrom(request);  
  22.             changed = true;  
  23.         }  
  24.   
  25.         if (changed) {  
  26.             mDisplayReadyLocked = false;  
  27.         }  
  28.   
  29.         if (changed && !mPendingRequestChangedLocked) {  
  30.             mPendingRequestChangedLocked = true;  
  31.             sendUpdatePowerStateLocked();  
  32.         }  
  33.   
  34.         return mDisplayReadyLocked;//changed没有变化直接返回,updatePowerState函数中已经将mDisplayReadyLocked置为true  
  35.     }  
  36. }  

那我们现在分析下,DisplayPowerController与DisplayPowerState的交互:

先来看下DisplayPowerController里的setScreenState函数,其中调用了DisplayPowerState的setScreenState函数

[java] 
view plain
 copy

  1. private boolean setScreenState(int state) {  
  2.     if (mPowerState.getScreenState() != state) {  
  3.         final boolean wasOn = (mPowerState.getScreenState() != Display.STATE_OFF);  
  4.         mPowerState.setScreenState(state);  
  5.   
  6.         // Tell battery stats about the transition.  
  7.         try {  
  8.             mBatteryStats.noteScreenState(state);  
  9.         } catch (RemoteException ex) {  
  10.             // same process  
  11.         }  
  12.   
  13.         // Tell the window manager what’s happening.  
  14.         // Temporarily block turning the screen on until the window manager is ready  
  15.         // by leaving a black surface covering the screen.  This surface is essentially  
  16.         // the final state of the color fade animation.  
  17.         boolean isOn = (state != Display.STATE_OFF);  
  18.         if (wasOn && !isOn) {  
  19.             unblockScreenOn();  
  20.             mWindowManagerPolicy.screenTurnedOff();  
  21.         } else if (!wasOn && isOn) {  
  22.             if (mPowerState.getColorFadeLevel() == 0.0f) {  
  23.                 blockScreenOn();  
  24.             } else {  
  25.                 unblockScreenOn();  
  26.             }  
  27.             mWindowManagerPolicy.screenTurningOn(mPendingScreenOnUnblocker);  
  28.         }  
  29.     }  
  30.     return mPendingScreenOnUnblocker == null;  
  31. }  

DisplayPowerController中调用DisplayPowerState的setScreenBrightness函数不是直接调用的,而是通过泛型技术调用的,这里就不讲了,感兴趣可以自己去细看。

[java] 
view plain
 copy

  1. private void animateScreenBrightness(int target, int rate) {  
  2.     if (DEBUG) {  
  3.         Slog.d(TAG, “Animating brightness: target=” + target +“, rate=” + rate);  
  4.     }  
  5.     if (mScreenBrightnessRampAnimator.animateTo(target, rate)) {//泛型技术,最后调用了DisplayPowerState的setScreenBrightness函数  
  6.         try {  
  7.             mBatteryStats.noteScreenBrightness(target);  
  8.         } catch (RemoteException ex) {  
  9.             // same process  
  10.         }  
  11.     }  
  12. }  

再来看看DisplayPowerState的setScreenState函数,和setScreenBrightness

[java] 
view plain
 copy

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

setScreenState函数,两者后面都是调用了scheduleScreenUpdate函数

[java] 
view plain
 copy

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

[java] 
view plain
 copy

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

利用消息机制的post函数

[java] 
view plain
 copy

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

下面就是PhotonicModulator的setState函数,这个类是一个线程,在构造函数里面start

[java] 
view plain
 copy

  1. public boolean setState(int state, int backlight) {  
  2.     synchronized (mLock) {  
  3.         if (state != mPendingState || backlight != mPendingBacklight) {  
  4.             if (DEBUG) {  
  5.                 Slog.d(TAG, “Requesting new screen state: state=”  
  6.                         + Display.stateToString(state) + “, backlight=” + backlight);  
  7.             }  
  8.   
  9.             mPendingState = state;  
  10.             mPendingBacklight = backlight;  
  11.   
  12.             if (!mChangeInProgress) {  
  13.                 mChangeInProgress = true;  
  14.                 mLock.notifyAll();//通知  
  15.             }  
  16.         }  
  17.         return !mChangeInProgress;  
  18.     }  
  19. }  

下面是DisplayPowerState的构造函数,其实例在DisplayPowerController中新建

[java] 
view plain
 copy

  1. public DisplayPowerState(DisplayBlanker blanker, Light backlight, ColorFade electronBeam) {  
  2.     mHandler = new Handler(true /*async*/);  
  3.     mChoreographer = Choreographer.getInstance();  
  4.     mBlanker = blanker;  
  5.     mBacklight = backlight;  
  6.     mColorFade = electronBeam;  
  7.     mPhotonicModulator = new PhotonicModulator();  
  8.     mPhotonicModulator.start();//开启线程  
  9.   
  10.     // At boot time, we know that the screen is on and the electron beam  
  11.     // animation is not playing.  We don’t know the screen’s brightness though,  
  12.     // so prepare to set it to a known state when the state is next applied.  
  13.     // Although we set the brightness to full on here, the display power controller  
  14.     // will reset the brightness to a new level immediately before the changes  
  15.     // actually have a chance to be applied.  
  16.     mScreenState = Display.STATE_ON;  
  17.     mScreenBrightness = PowerManager.BRIGHTNESS_ON;  
  18.     scheduleScreenUpdate();  
  19.   
  20.     mColorFadePrepared = false;  
  21.     mColorFadeLevel = 1.0f;  
  22.     mColorFadeReady = true;  
  23. }  

我们再来分析下PhotonicModulator的run函数

[java] 
view plain
 copy

  1.   @Override  
  2.   public void run() {  
  3.       for (;;) {  
  4.           // Get pending change.  
  5.           final int state;  
  6.           final boolean stateChanged;  
  7.           final int backlight;  
  8.           final boolean backlightChanged;  
  9.           synchronized (mLock) {  
  10.               state = mPendingState;  
  11.               stateChanged = (state != mActualState);  
  12.               backlight = mPendingBacklight;  
  13.               backlightChanged = (backlight != mActualBacklight);  
  14.               if (!stateChanged && !backlightChanged) {  
  15.                   // All changed applied, notify outer class and wait for more.  
  16.                   mChangeInProgress = false;  
  17.                   postScreenUpdateThreadSafe();  
  18.                   try {  
  19.                       mLock.wait();//一直等待,直到setState有改变会notifyAll  
  20.                   } catch (InterruptedException ex) { }  
  21.                   continue;  
  22.               }  
  23.               mActualState = state;  
  24.               mActualBacklight = backlight;  
  25.           }  
  26.   
  27.           // Apply pending change.  
  28.           if (DEBUG) {  
  29.               Slog.d(TAG, “Updating screen state: state=”  
  30.                       + Display.stateToString(state) + “, backlight=” + backlight);  
  31.           }  
  32.           boolean suspending = Display.isSuspendedState(state);  
  33.           if (stateChanged && !suspending) {  
  34. Slog.d(TAG, “Updating screen state: state = “ + Display.stateToString(state));  
  35.               requestDisplayState(state);//下面详细分析  
  36.           }  
  37.           if (backlightChanged) {  
  38. Slog.d(TAG, “Updating screen backlight = “ + backlight);  
  39.               setBrightness(backlight);  
  40.           }  
  41.           if (stateChanged && suspending) {  
  42. Slog.d(TAG, “Updating screen state: state = “ + Display.stateToString(state));  
  43.               requestDisplayState(state);  
  44.           }  
  45.       }  
  46.   }  

requestDisplayState函数

[java] 
view plain
 copy

  1. private void requestDisplayState(int state) {  
  2.     Trace.traceBegin(Trace.TRACE_TAG_POWER, “requestDisplayState(“  
  3.             + Display.stateToString(state) + “)”);  
  4.     try {  
  5.         mBlanker.requestDisplayState(state);  
  6.     } finally {  
  7.         Trace.traceEnd(Trace.TRACE_TAG_POWER);  
  8.     }  
  9. }  

是DisplayManagerService中的blanker的requestDisplayState函数,然后将这个blanker传给了DisplayPowerController,再传给DisplayPowerState

[java] 
view plain
 copy

  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) {  
  9.                     // The order of operations is important for legacy reasons.  
  10.                     if (state == Display.STATE_OFF) {  
  11.                         requestGlobalDisplayStateInternal(state);  
  12.                     }  
  13.   
  14.                     callbacks.onDisplayStateChange(state);//回调到PMS中的onDisplayStateChange  
  15.   
  16.                     if (state != Display.STATE_OFF) {  
  17.                         requestGlobalDisplayStateInternal(state);  
  18.                     }  
  19.                 }  
  20.             };  
  21.             mDisplayPowerController = new DisplayPowerController(  
  22.                     mContext, callbacks, handler, sensorManager, blanker);  
  23.         }  
  24.     }  

PMS的DisplayManagerInternal.DisplayPowerCallbacks的onDisplayStateChange函数

[java] 
view plain
 copy

  1. @Override  
  2. public void onDisplayStateChange(int state) {  
  3.     // This method is only needed to support legacy display blanking behavior  
  4.     // where the display’s power state is coupled to suspend or to the power HAL.  
  5.     // The order of operations matters here.  
  6.     synchronized (mLock) {  
  7.         if (mDisplayState != state) {  
  8.             mDisplayState = state;  
  9.             if (state == Display.STATE_OFF) {  
  10.                 if (!mDecoupleHalInteractiveModeFromDisplayConfig) {  
  11.                     setHalInteractiveModeLocked(false);//JNI处理cpu频率等  
  12.                 }  
  13.                 if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) {  
  14.                     setHalAutoSuspendModeLocked(true);//设置为true,让系统自动休眠。  
  15.                 }  
  16.             } else {  
  17.                 if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) {  
  18.                     setHalAutoSuspendModeLocked(false);  
  19.                 }  
  20.                 if (!mDecoupleHalInteractiveModeFromDisplayConfig) {  
  21.                     setHalInteractiveModeLocked(true);  
  22.                 }  
  23.             }  
  24.         }  
  25.     }  

再来看看DisplayPowerState的setBrightness函数

[java] 
view plain
 copy

  1. private void setBrightness(int backlight) {  
  2.     Trace.traceBegin(Trace.TRACE_TAG_POWER, “setBrightness(“ + backlight + “)”);  
  3.     try {  
  4.         mBacklight.setBrightness(backlight);//mBckLight是DisplayPowerController传进来的  
  5.     } finally {  
  6.         Trace.traceEnd(Trace.TRACE_TAG_POWER);  
  7.     }  
  8. }  

DisplayPowerController新建DisplayPowerState对象

[java] 
view plain
 copy

  1. mPowerState = new DisplayPowerState(mBlanker,  
  2.         mLights.getLight(LightsManager.LIGHT_ID_BACKLIGHT),//传入mBacklight  
  3.         new ColorFade(Display.DEFAULT_DISPLAY));  

getLight函数是从light数组里面选一个light

[java] 
view plain
 copy

  1. private final LightsManager mService = new LightsManager() {  
  2.     @Override  
  3.     public com.android.server.lights.Light getLight(int id) {  
  4.         if (id < LIGHT_ID_COUNT) {  
  5.             return mLights[id];  
  6.         } else {  
  7.             return null;  
  8.         }  
  9.     }  
  10. };  

light类,设置亮度会把自己的一个id号,传下去

[java] 
view plain
 copy

  1. private final class LightImpl extends Light {  
  2.   
  3.     private LightImpl(int id) {  
  4.         mId = id;  
  5.     }  
  6.   
  7.     @Override  
  8.     public void setBrightness(int brightness) {  
  9.         setBrightness(brightness, BRIGHTNESS_MODE_USER);  
  10.     }  
  11.   
  12.     @Override  
  13.     public void setBrightness(int brightness, int brightnessMode) {  
  14.         synchronized (this) {  
  15.             int color = brightness & 0x000000ff;  
  16.             color = 0xff000000 | (color << 16) | (color << 8) | color;  
  17.             setLightLocked(color, LIGHT_FLASH_NONE, 00, brightnessMode);  
  18.         }  
  19.     }  

最后调用setLightLocked,会将该light的id传下去,最后调用setLight_native来完成最后的设置亮度。

[java] 
view plain
 copy

  1. private void setLightLocked(int color, int mode, int onMS, int offMS, int brightnessMode) {  
  2.     if (color != mColor || mode != mMode || onMS != mOnMS || offMS != mOffMS) {  
  3.         if (DEBUG) Slog.v(TAG, “setLight #” + mId + “: color=#”  
  4.                 + Integer.toHexString(color));  
  5.         mColor = color;  
  6.         mMode = mode;  
  7.         mOnMS = onMS;  
  8.         mOffMS = offMS;  
  9.         Trace.traceBegin(Trace.TRACE_TAG_POWER, “setLight(“ + mId + “, “ + color + “)”);  
  10.         try {  
  11.             setLight_native(mNativePointer, mId, color, mode, onMS, offMS, brightnessMode);  
  12.         } finally {  
  13.             Trace.traceEnd(Trace.TRACE_TAG_POWER);  
  14.         }  
  15.     }  
  16. }  

接下来我们继续分析上一篇博客的PMS里的updatePowerStateLocked函数

[java] 
view plain
 copy

  1. // Phase 2: Update display power state.  
  2. boolean displayBecameReady = updateDisplayPowerStateLocked(dirtyPhase2);//第一次返回为false  
  3.   
  4. // Phase 3: Update dream state (depends on display ready signal).  
  5. updateDreamLocked(dirtyPhase2, displayBecameReady);  
  6.   
  7. // Phase 4: Send notifications, if needed.  
  8. if (mDisplayReady) {  
  9.     finishWakefulnessChangeLocked();  
  10. }  
  11.   
  12. // Phase 5: Update suspend blocker.  
  13. // Because we might release the last suspend blocker here, we need to make sure  
  14. // we finished everything else first!  
  15. updateSuspendBlockerLocked();  

先看updateDreamLocked函数,mDisplayReady为false,所以跳出

[java] 
view plain
 copy

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

这样我们直接分析updateSuspendBlockerLocked

[java] 
view plain
 copy

  1. private void updateSuspendBlockerLocked() {  
  2.     final boolean needWakeLockSuspendBlocker = ((mWakeLockSummary & WAKE_LOCK_CPU) != 0);//看cpu是否要持锁  
  3.     final boolean needDisplaySuspendBlocker = needDisplaySuspendBlockerLocked();//现在Display没好,需要持Display的锁  
  4.     final boolean autoSuspend = !needDisplaySuspendBlocker;  
  5.     final boolean interactive = mDisplayPowerRequest.isBrightOrDim();  
  6.   
  7.     // Disable auto-suspend if needed.  
  8.     // FIXME We should consider just leaving auto-suspend enabled forever since  
  9.     // we already hold the necessary wakelocks.  
  10.     if (!autoSuspend && mDecoupleHalAutoSuspendModeFromDisplayConfig) {  
  11.         setHalAutoSuspendModeLocked(false);//调用JNI,具体还要分析  
  12.     }  
  13.   
  14.     // First acquire suspend blockers if needed.  
  15.     if (needWakeLockSuspendBlocker && !mHoldingWakeLockSuspendBlocker) {  
  16.         mWakeLockSuspendBlocker.acquire();//持cpu锁  
  17.         mHoldingWakeLockSuspendBlocker = true;  
  18.     }  
  19.     if (needDisplaySuspendBlocker && !mHoldingDisplaySuspendBlocker) {  
  20.         mDisplaySuspendBlocker.acquire();//持Display锁  
  21.         mHoldingDisplaySuspendBlocker = true;  
  22.     }  
  23.   
  24.     // Inform the power HAL about interactive mode.  
  25.     // Although we could set interactive strictly based on the wakefulness  
  26.     // as reported by isInteractive(), it is actually more desirable to track  
  27.     // the display policy state instead so that the interactive state observed  
  28.     // by the HAL more accurately tracks transitions between AWAKE and DOZING.  
  29.     // Refer to getDesiredScreenPolicyLocked() for details.  
  30.     if (mDecoupleHalInteractiveModeFromDisplayConfig) {  
  31.         // When becoming non-interactive, we want to defer sending this signal  
  32.         // until the display is actually ready so that all transitions have  
  33.         // completed.  This is probably a good sign that things have gotten  
  34.         // too tangled over here…  
  35.         if (interactive || mDisplayReady) {  
  36.             setHalInteractiveModeLocked(interactive);//JNI,修改cpu频率等  
  37.         }  
  38.     }  
  39.   
  40.     // Then release suspend blockers if needed.  
  41.     if (!needWakeLockSuspendBlocker && mHoldingWakeLockSuspendBlocker) {  
  42.         mWakeLockSuspendBlocker.release();//解锁  
  43.         mHoldingWakeLockSuspendBlocker = false;  
  44.     }  
  45.     if (!needDisplaySuspendBlocker && mHoldingDisplaySuspendBlocker) {  
  46.         mDisplaySuspendBlocker.release();  
  47.         mHoldingDisplaySuspendBlocker = false;  
  48.     }  
  49.   
  50.     // Enable auto-suspend if needed.  
  51.     if (autoSuspend && mDecoupleHalAutoSuspendModeFromDisplayConfig) {  
  52.         setHalAutoSuspendModeLocked(true);//设置true,让系统可以自动睡眠。  
  53.     }  
  54. }  

needDisplaySuspendBlockerLocked函数mDisplayReady为false,直接返回true

[java] 
view plain
 copy

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

这样PMS刚调mDisplayManagerInternal.requestPowerState的时候,返回mDisplayReady为false,最后也就会持Display的锁,其它也没有别的了。

直到Display准备好,回调函数直接又调用updatePowerStateLocked函数,再调用updateDisplayPowerStateLocked函数,返回mDisplayReady为true。

那我们继续分析updatePowerStateLocked函数:

[java] 
view plain
 copy

  1. updateDreamLocked(dirtyPhase2, displayBecameReady);  
  2.   
  3. // Phase 4: Send notifications, if needed.  
  4. if (mDisplayReady) {  
  5.     finishWakefulnessChangeLocked();  
  6. }  
  7.   
  8. // Phase 5: Update suspend blocker.  
  9. // Because we might release the last suspend blocker here, we need to make sure  
  10. // we finished everything else first!  
  11. updateSuspendBlockerLocked();  

updateDreamLocked函数发送消息

[java] 
view plain
 copy

  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. }  
  16.   
  17. private void scheduleSandmanLocked() {  
  18.     if (!mSandmanScheduled) {  
  19.         mSandmanScheduled = true;  
  20.         Message msg = mHandler.obtainMessage(MSG_SANDMAN);  
  21.         msg.setAsynchronous(true);  
  22.         mHandler.sendMessage(msg);  
  23.     }  
  24. }  

消息最后处理的函数是handleSandman,goToSleepNoUpdateLocked和napNoUpdateLocked函数才会把mSandmanSummoned = true;

[java] 
view plain
 copy

  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) {//mSandmanSummoned为donzing状态和dreaming状态的时候才为true  
  9.             startDreaming = canDreamLocked() || canDozeLocked();//canDozeLocked函数只要wakefulness == WAKEFULNESS_DOZING就true  
  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) {//为true才开始做梦  
  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(), Process.SYSTEM_UID);  
  76.                 updatePowerStateLocked();  
  77.             }  
  78.         } else if (wakefulness == WAKEFULNESS_DOZING) {//WAKEFULNESS_DOZING和WAKEFULNESS_DREAMING都可以做梦  
  79.             if (isDreaming) {  
  80.                 return// continue dozing  
  81.             }  
  82.   
  83.             // Doze has ended or will be stopped.  Update the power state.  
  84.             reallyGoToSleepNoUpdateLocked(SystemClock.uptimeMillis(), Process.SYSTEM_UID);//直接到sleep状态  
  85.             updatePowerStateLocked();  
  86.         }  
  87.     }  
  88.   
  89.     // Stop dream.  
  90.     if (isDreaming) {  
  91.         mDreamManager.stopDream(false /*immediate*/);  
  92.     }  
  93. }  

继续分析updatePowerStateLocked函数

[java] 
view plain
 copy

  1. if (mDisplayReady) {  
  2.     finishWakefulnessChangeLocked();  
  3. }  
  4.   
  5. // Phase 5: Update suspend blocker.  
  6. // Because we might release the last suspend blocker here, we need to make sure  
  7. // we finished everything else first!  
  8. updateSuspendBlockerLocked();  

Display完成后,可以finishWakefulnessChangeLocked函数,在之前的PMS的博客分析过了。这里是屏幕灭屏之前通知PhoneWindowManager,电池统计等。

updateSuspendBlockerLocked函数之前分析过了,就不再分析了就是一个持锁,和调JNI设置cpu频率,还有一个autoSuspend是自动让系统睡眠,如果开启就设true。

    原文作者:慢慢的燃烧
    原文地址: https://blog.csdn.net/u010164190/article/details/51187033
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞