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.                  1, 1);  
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, 0, 0, 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。