程序博客网 > 淘宝联盟站长

android5.1 PowerManagerService和DisplayPowerControler、DisplayPowerState关系

来源：互联网 发布：淘宝联盟站长 编辑：程序博客网 时间：2024/05/19 23:52

android5.1 PowerManagerService和DisplayPowerControler、DisplayPowerState关系

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

PowerManagerService在updateDisplayPowerStateLocked中与DisplayPowerControler交互，详细看代码：

[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();  
  7.   
  8.            // Determine appropriate screen brightness and auto-brightness adjustments.  
  9.            int screenBrightness = mScreenBrightnessSettingDefault;  
  10.            float screenAutoBrightnessAdjustment = 0.0f;  
  11.            boolean autoBrightness = (mScreenBrightnessModeSetting ==  
  12.                    Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);  
  13.            if (isValidBrightness(mScreenBrightnessOverrideFromWindowManager)) {  
  14.                screenBrightness = mScreenBrightnessOverrideFromWindowManager;  
  15.                autoBrightness = false;  
  16.            } else if (isValidBrightness(mTemporaryScreenBrightnessSettingOverride)) {  
  17.                screenBrightness = mTemporaryScreenBrightnessSettingOverride;  
  18.            } else if (isValidBrightness(mScreenBrightnessSetting)) {  
  19.                screenBrightness = mScreenBrightnessSetting;  
  20.            }  
  21.            if (autoBrightness) {  
  22.                screenBrightness = mScreenBrightnessSettingDefault;  
  23.                if (isValidAutoBrightnessAdjustment(  
  24.                        mTemporaryScreenAutoBrightnessAdjustmentSettingOverride)) {  
  25.                    screenAutoBrightnessAdjustment =  
  26.                            mTemporaryScreenAutoBrightnessAdjustmentSettingOverride;  
  27.                } else if (isValidAutoBrightnessAdjustment(  
  28.                        mScreenAutoBrightnessAdjustmentSetting)) {  
  29.                    screenAutoBrightnessAdjustment = mScreenAutoBrightnessAdjustmentSetting;  
  30.                }  
  31.            }  
  32.            screenBrightness = Math.max(Math.min(screenBrightness,  
  33.                    mScreenBrightnessSettingMaximum), mScreenBrightnessSettingMinimum);  
  34.            screenAutoBrightnessAdjustment = Math.max(Math.min(  
  35.                    screenAutoBrightnessAdjustment, 1.0f), -1.0f);  
  36.   
  37.            // Update display power request.  
  38.            mDisplayPowerRequest.screenBrightness = screenBrightness;  
  39.            mDisplayPowerRequest.screenAutoBrightnessAdjustment =  
  40.                    screenAutoBrightnessAdjustment;  
  41.            mDisplayPowerRequest.useAutoBrightness = autoBrightness;  
  42.            mDisplayPowerRequest.useProximitySensor = shouldUseProximitySensorLocked();  
  43.            mDisplayPowerRequest.lowPowerMode = mLowPowerModeEnabled;  
  44.            mDisplayPowerRequest.boostScreenBrightness = mScreenBrightnessBoostInProgress;  
  45.   
  46.            if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DOZE) {  
  47.                mDisplayPowerRequest.dozeScreenState = mDozeScreenStateOverrideFromDreamManager;  
  48.                mDisplayPowerRequest.dozeScreenBrightness =  
  49.                        mDozeScreenBrightnessOverrideFromDreamManager;  
  50.            } else {  
  51.                mDisplayPowerRequest.dozeScreenState = Display.STATE_UNKNOWN;  
  52.                mDisplayPowerRequest.dozeScreenBrightness = PowerManager.BRIGHTNESS_DEFAULT;  
  53.            }  
  54.   
  55.            mDisplayReady = mDisplayManagerInternal.requestPowerState(mDisplayPowerRequest,//调用DisplayPowerControler的requestPowerstate接口  
  56.                    mRequestWaitForNegativeProximity);  
  57.            mRequestWaitForNegativeProximity = false;  
  58.   
  59.        }  
  60.        return mDisplayReady && !oldDisplayReady;  
  61.    }  

接下来我们再看看mDisplayManagerInternal这个成员变量：在systemready中

[java] view plain copy
  1. mDisplayManagerInternal = getLocalService(DisplayManagerInternal.class);  
  2. 。。。。  
  3. mDisplayManagerInternal.initPowerManagement(  
  4.                     mDisplayPowerCallbacks, mHandler, sensorManager);  


而DisplayPowerControler是在DisplayManagerService中定义，并且放在localservice中，publish出来。

[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(//new一个DisplayPowerController  
  22.                         mContext, callbacks, handler, sensorManager, blanker);  
  23.             }  
  24.         }  
  25.   
  26.         @Override  
  27.         public boolean requestPowerState(DisplayPowerRequest request,  
  28.                 boolean waitForNegativeProximity) {  
  29.             return mDisplayPowerController.requestPowerState(request,  
  30.                     waitForNegativeProximity);  
  31.         }  
  32. 。。。。。  

好接下来我们先分析DisplayPowerControler中的requestPowerState函数：

[java] view plain copy
  1. public boolean requestPowerState(DisplayPowerRequest request,  
  2.         boolean waitForNegativeProximity) {  
  3.     synchronized (mLock) {  
  4.         boolean changed = false;  
  5.   
  6.         if (waitForNegativeProximity  
  7.                 && !mPendingWaitForNegativeProximityLocked) {  
  8.             mPendingWaitForNegativeProximityLocked = true;  
  9.             changed = true;  
  10.         }  
  11.   
  12.         if (mPendingRequestLocked == null) {  
  13.             mPendingRequestLocked = new DisplayPowerRequest(request);  
  14.             changed = true;  
  15.         } else if (!mPendingRequestLocked.equals(request)) {  
  16.             mPendingRequestLocked.copyFrom(request);  
  17.             changed = true;  
  18.         }  
  19.   
  20.         if (changed) {  
  21.             mDisplayReadyLocked = false;//注意有变化，返回的是false  
  22.         }  
  23.   
  24.         if (changed && !mPendingRequestChangedLocked) {  
  25.             mPendingRequestChangedLocked = true;  
  26.             sendUpdatePowerStateLocked();//发送信号，到updatePowerState  
  27.         }  
  28.   
  29.         return mDisplayReadyLocked;  
  30.     }  
  31. }  
下面我们就来分析下DisplayPowerControler中的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);  
  15.                mWaitingForNegativeProximity = mPendingWaitForNegativeProximityLocked;  
  16.                mPendingWaitForNegativeProximityLocked = false;  
  17.                mPendingRequestChangedLocked = false;  
  18.                mustInitialize = true;  
  19.            } else if (mPendingRequestChangedLocked) {  
  20.                autoBrightnessAdjustmentChanged = (mPowerRequest.screenAutoBrightnessAdjustment  
  21.                        != mPendingRequestLocked.screenAutoBrightnessAdjustment);  
  22.                mPowerRequest.copyFrom(mPendingRequestLocked);  
  23.                mWaitingForNegativeProximity |= mPendingWaitForNegativeProximityLocked;  
  24.                mPendingWaitForNegativeProximityLocked = false;  
  25.                mPendingRequestChangedLocked = false;  
  26.                mDisplayReadyLocked = false;//这时候mDisplayReadyLocked还是false，这是requestPowerState的返回值  
  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) {//根据policy，得到显示的state  
  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.        //后面详细分析下这函数，主要设置显示的state，和displayPowerState交互。  
  99.        animateScreenStateChange(state, performScreenOffTransition);  
  100.        state = mPowerState.getScreenState();  
  101.   
  102.        // Use zero brightness when screen is off.  
  103.        if (state == Display.STATE_OFF) {  
  104.            brightness = PowerManager.BRIGHTNESS_OFF;  
  105.        }  
  106.   
  107.        // Configure auto-brightness.  
  108.        boolean autoBrightnessEnabled = false;  
  109.        if (mAutomaticBrightnessController != null) {  
  110.            final boolean autoBrightnessEnabledInDoze = mAllowAutoBrightnessWhileDozingConfig  
  111.                    && (state == Display.STATE_DOZE || state == Display.STATE_DOZE_SUSPEND);  
  112.            autoBrightnessEnabled = mPowerRequest.useAutoBrightness  
  113.                    && (state == Display.STATE_ON || autoBrightnessEnabledInDoze)  
  114.                    && brightness < 0;  
  115.            mAutomaticBrightnessController.configure(autoBrightnessEnabled,  
  116.                    mPowerRequest.screenAutoBrightnessAdjustment, state != Display.STATE_ON);  
  117.        }  
  118.   
  119.        // Apply brightness boost.  
  120.        // We do this here after configuring auto-brightness so that we don't  
  121.        // disable the light sensor during this temporary state.  That way when  
  122.        // boost ends we will be able to resume normal auto-brightness behavior  
  123.        // without any delay.  
  124.        if (mPowerRequest.boostScreenBrightness  
  125.                && brightness != PowerManager.BRIGHTNESS_OFF) {  
  126.            brightness = PowerManager.BRIGHTNESS_ON;  
  127.        }  
  128.   
  129.        // Apply auto-brightness.  
  130.        boolean slowChange = false;  
  131.        if (brightness < 0) {  
  132.            if (autoBrightnessEnabled) {  
  133.                brightness = mAutomaticBrightnessController.getAutomaticScreenBrightness();  
  134.            }  
  135.            if (brightness >= 0) {  
  136.                // Use current auto-brightness value and slowly adjust to changes.  
  137.                brightness = clampScreenBrightness(brightness);  
  138.                if (mAppliedAutoBrightness && !autoBrightnessAdjustmentChanged) {  
  139.                    slowChange = true; // slowly adapt to auto-brightness  
  140.                }  
  141.                mAppliedAutoBrightness = true;  
  142.            } else {  
  143.                mAppliedAutoBrightness = false;  
  144.            }  
  145.        } else {  
  146.            mAppliedAutoBrightness = false;  
  147.        }  
  148.   
  149.        // Use default brightness when dozing unless overridden.  
  150.        if (brightness < 0 && (state == Display.STATE_DOZE  
  151.                || state == Display.STATE_DOZE_SUSPEND)) {  
  152.            brightness = mScreenBrightnessDozeConfig;  
  153.        }  
  154.   
  155.        // Apply manual brightness.  
  156.        // Use the current brightness setting from the request, which is expected  
  157.        // provide a nominal default value for the case where auto-brightness  
  158.        // is not ready yet.  
  159.        if (brightness < 0) {  
  160.            brightness = clampScreenBrightness(mPowerRequest.screenBrightness);  
  161.        }  
  162.   
  163.        // Apply dimming by at least some minimum amount when user activity  
  164.        // timeout is about to expire.  
  165.        if (mPowerRequest.policy == DisplayPowerRequest.POLICY_DIM) {  
  166.            if (brightness > mScreenBrightnessRangeMinimum) {  
  167.                brightness = Math.max(Math.min(brightness - SCREEN_DIM_MINIMUM_REDUCTION,  
  168.                        mScreenBrightnessDimConfig), mScreenBrightnessRangeMinimum);  
  169.            }  
  170.            if (!mAppliedDimming) {  
  171.                slowChange = false;  
  172.            }  
  173.            mAppliedDimming = true;  
  174.        }  
  175.   
  176.        // If low power mode is enabled, cut the brightness level by half  
  177.        // as long as it is above the minimum threshold.  
  178.        if (mPowerRequest.lowPowerMode) {//低功耗模式  
  179.            if (brightness > mScreenBrightnessRangeMinimum) {  
  180.                brightness = Math.max(brightness / 2, mScreenBrightnessRangeMinimum);  
  181.            }  
  182.            if (!mAppliedLowPower) {  
  183.                slowChange = false;  
  184.            }  
  185.            mAppliedLowPower = true;  
  186.        }  
  187.   
  188.        // Animate the screen brightness when the screen is on or dozing.  
  189.        // Skip the animation when the screen is off or suspended.  
  190.        if (!mPendingScreenOff) {  
  191.            if (state == Display.STATE_ON || state == Display.STATE_DOZE) {  
  192.                animateScreenBrightness(brightness,  
  193.                        slowChange ? BRIGHTNESS_RAMP_RATE_SLOW : BRIGHTNESS_RAMP_RATE_FAST);  
  194.            } else {  
  195.                animateScreenBrightness(brightness, 0);  
  196.            }  
  197.        }  
  198.   
  199.        // Determine whether the display is ready for use in the newly requested state.  
  200.        // Note that we do not wait for the brightness ramp animation to complete before  
  201.        // reporting the display is ready because we only need to ensure the screen is in the  
  202.        // right power state even as it continues to converge on the desired brightness.  
  203.        final boolean ready = mPendingScreenOnUnblocker == null  
  204.                && !mColorFadeOnAnimator.isStarted()  
  205.                && !mColorFadeOffAnimator.isStarted()  
  206.                && mPowerState.waitUntilClean(mCleanListener);  
  207.        final boolean finished = ready  
  208.                && !mScreenBrightnessRampAnimator.isAnimating();  
  209.   
  210.        // Grab a wake lock if we have unfinished business.  
  211.        if (!finished && !mUnfinishedBusiness) {  
  212.            if (DEBUG) {  
  213.                Slog.d(TAG, "Unfinished business...");  
  214.            }  
  215.            mCallbacks.acquireSuspendBlocker();//回调持cpu锁  
  216.            mUnfinishedBusiness = true;//使用该变量，只能进一次该函数  
  217.        }  
  218.   
  219.        // Notify the power manager when ready.  
  220.        if (ready && mustNotify) {  
  221.            // Send state change.  
  222.            synchronized (mLock) {  
  223.                if (!mPendingRequestChangedLocked) {  
  224.                    mDisplayReadyLocked = true;  
  225.   
  226.                    if (DEBUG) {  
  227.                        Slog.d(TAG, "Display ready!");  
  228.                    }  
  229.                }  
  230.            }  
  231.            sendOnStateChangedWithWakelock();//重新在PowerManagerService中调用updatePowerState函数  
  232.        }  
  233.   
  234.        // Release the wake lock when we have no unfinished business.  
  235.        if (finished && mUnfinishedBusiness) {  
  236.            if (DEBUG) {  
  237.                Slog.d(TAG, "Finished business...");  
  238.            }  
  239.            mUnfinishedBusiness = false;  
  240.            mCallbacks.releaseSuspendBlocker();//释放cpu锁  
  241.        }  
  242.    }  

我们先来看下在上面函数中调用的几个mCallbacks函数：

[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() {//只是重新调用下powerManagerService中的updatePowerStateLocked函数  
  7.         synchronized (mLock) {  
  8.             mDirty |= DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED;  
  9.             updatePowerStateLocked();  
  10.         }  
  11.     }  
  12.   
  13.     @Override  
  14.     public void onProximityPositive() {  
  15.         synchronized (mLock) {  
  16.             mProximityPositive = true;  
  17.             mDirty |= DIRTY_PROXIMITY_POSITIVE;  
  18.             updatePowerStateLocked();  
  19.         }  
  20.     }  
  21.   
  22.     @Override  
  23.     public void onProximityNegative() {  
  24.         synchronized (mLock) {  
  25.             mProximityPositive = false;  
  26.             mDirty |= DIRTY_PROXIMITY_POSITIVE;  
  27.             userActivityNoUpdateLocked(SystemClock.uptimeMillis(),  
  28.                     PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, Process.SYSTEM_UID);  
  29.             updatePowerStateLocked();  
  30.         }  
  31.     }  
  32.   
  33.     @Override  
  34.     public void onDisplayStateChange(int state) {  
  35.         // This method is only needed to support legacy display blanking behavior  
  36.         // where the display's power state is coupled to suspend or to the power HAL.  
  37.         // The order of operations matters here.  
  38.         synchronized (mLock) {  
  39.             if (mDisplayState != state) {  
  40.                 mDisplayState = state;  
  41.                 if (state == Display.STATE_OFF) {  
  42.                     if (!mDecoupleHalInteractiveModeFromDisplayConfig) {  
  43.                         setHalInteractiveModeLocked(false);  
  44.                     }  
  45.                     if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) {  
  46.                         setHalAutoSuspendModeLocked(true);  
  47.                     }  
  48.                 } else {  
  49.                     if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) {  
  50.                         setHalAutoSuspendModeLocked(false);  
  51.                     }  
  52.                     if (!mDecoupleHalInteractiveModeFromDisplayConfig) {  
  53.                         setHalInteractiveModeLocked(true);  
  54.                     }  
  55.                 }  
  56.             }  
  57.         }  
  58.     }  
  59.   
  60.     @Override  
  61.     public void acquireSuspendBlocker() {  
  62.         mDisplaySuspendBlocker.acquire();  
  63.     }  
  64.   
  65.     @Override  
  66.     public void releaseSuspendBlocker() {  
  67.         mDisplaySuspendBlocker.release();  
  68.     }  

而sendOnStateChangedWithWakelock代码如下：

[java] view plain copy
  1. private void sendOnStateChangedWithWakelock() {  
  2.     mCallbacks.acquireSuspendBlocker();  
  3.     mHandler.post(mOnStateChangedRunnable);  
  4. }  
  5.   
  6. private final Runnable mOnStateChangedRunnable = new Runnable() {直接在两个线程中，这个handler是PowerManagerService中的  
  7.     @Override  
  8.     public void run() {  
  9.         mCallbacks.onStateChanged();  
  10.         mCallbacks.releaseSuspendBlocker();  
  11.     }  
  12. };  

第一次调用requestPowerState时返回的mDisplayReadyLocked = false，然后在DisplayPowerControler中的updatePowerState函数全都好了，把变量mDisplayReadyLocked = true ，再调用PowerManagerService中的updatePowerLocked，再调的话mDisplayReadyLocked 就返回true了。


接下来我们来看animateScreenStateChange函数，主要是设置display的state。

[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 (mPendingScreenOff && target != Display.STATE_OFF) {  
  9.         setScreenState(Display.STATE_OFF);//设置display的state  
  10.         mPendingScreenOff = false;  
  11.     }  
  12.   
  13.     if (target == Display.STATE_ON) {  
  14.         if (!setScreenState(Display.STATE_ON)) {  
  15.             return; // screen on blocked  
  16.         }  
  17.         if (USE_COLOR_FADE_ON_ANIMATION && mPowerRequest.isBrightOrDim()) {  
  18.             // Perform screen on animation.  
  19.             if (mPowerState.getColorFadeLevel() == 1.0f) {  
  20.                 mPowerState.dismissColorFade();  
  21.             } else if (mPowerState.prepareColorFade(mContext,  
  22.                     mColorFadeFadesConfig ?  
  23.                             ColorFade.MODE_FADE :  
  24.                                     ColorFade.MODE_WARM_UP)) {  
  25.                 mColorFadeOnAnimator.start();  
  26.             } else {  
  27.                 mColorFadeOnAnimator.end();  
  28.             }  
  29.         } else {  
  30.             // Skip screen on animation.  
  31.             mPowerState.setColorFadeLevel(1.0f);  
  32.             mPowerState.dismissColorFade();  
  33.         }  
  34.     } else if (target == Display.STATE_DOZE) {  
  35.         // Want screen dozing.  
  36.         // Wait for brightness animation to complete beforehand when entering doze  
  37.         // from screen on to prevent a perceptible jump because brightness may operate  
  38.         // differently when the display is configured for dozing.  
  39.         if (mScreenBrightnessRampAnimator.isAnimating()  
  40.                 && mPowerState.getScreenState() == Display.STATE_ON) {  
  41.             return;  
  42.         }  
  43.   
  44.         // Set screen state.  
  45.         if (!setScreenState(Display.STATE_DOZE)) {  
  46.             return; // screen on blocked  
  47.         }  
[java] view plain copy
  1. 。。。。。。。。。。  
[java] view plain copy
  1. </pre><p>再看setScreenState函数</p><pre class="java" name="code">    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();//通知window Manager  
  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.     }  

好，接下来我们就主要分析DisPlayPowerRequest，先看setScreenState

[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. }  
  12.   
  13. private void scheduleScreenUpdate() {  
  14.     if (!mScreenUpdatePending) {  
  15.         mScreenUpdatePending = true;  
  16.         postScreenUpdateThreadSafe();  
  17.     }  
  18.   
  19. private void postScreenUpdateThreadSafe() {  
  20.     mHandler.removeCallbacks(mScreenUpdateRunnable);  
  21.     mHandler.post(mScreenUpdateRunnable);  
  22. }  
  23.   
  24. private final Runnable mScreenUpdateRunnable = new Runnable() {  
  25.     @Override  
  26.     public void run() {  
  27.         mScreenUpdatePending = false;  
  28.   
  29.         int brightness = mScreenState != Display.STATE_OFF  
  30.                 && mColorFadeLevel > 0f ? mScreenBrightness : 0;  
  31.         if (mPhotonicModulator.setState(mScreenState, brightness)) {//最后调用了线程的setState  
  32.             if (DEBUG) {  
  33.                 Slog.d(TAG, "Screen ready");  
  34.             }  
  35.             mScreenReady = true;  
  36.             invokeCleanListenerIfNeeded();  
  37.         } else {  
  38.             if (DEBUG) {  
  39.                 Slog.d(TAG, "Screen not ready");  
  40.             }  
  41.         }  
  42.     }  
  43. };      

下面我们分析下PhotonicModulator这个线程类：

[java] view plain copy
  1. private final class PhotonicModulator extends Thread {  
  2.     private static final int INITIAL_SCREEN_STATE = Display.STATE_OFF; // unknown, assume off  
  3.     private static final int INITIAL_BACKLIGHT = -1; // unknown  
  4.   
  5.     private final Object mLock = new Object();  
  6.   
  7.     private int mPendingState = INITIAL_SCREEN_STATE;  
  8.     private int mPendingBacklight = INITIAL_BACKLIGHT;  
  9.     private int mActualState = INITIAL_SCREEN_STATE;  
  10.     private int mActualBacklight = INITIAL_BACKLIGHT;  
  11.     private boolean mChangeInProgress;  
  12.   
  13.     public boolean setState(int state, int backlight) {  
  14.         synchronized (mLock) {  
  15.             if (state != mPendingState || backlight != mPendingBacklight) {  
  16.                 if (DEBUG) {  
  17.                     Slog.d(TAG, "Requesting new screen state: state="  
  18.                             + Display.stateToString(state) + ", backlight=" + backlight);  
  19.                 }  
  20.   
  21.                 mPendingState = state;//设置state  
  22.                 mPendingBacklight = backlight;  
  23.   
  24.                 if (!mChangeInProgress) {  
  25.                     mChangeInProgress = true;  
  26.                     mLock.notifyAll();  
  27.                 }  
  28.             }  
  29.             return !mChangeInProgress;  
  30.         }  
  31.     }  
  32.   
  33.     @Override  
  34.     public void run() {  
  35.         for (;;) {//线程一直跑，状态改变就去PowerManagerService中调用setHalInteractiveModeLocked设置屏幕状态  
  36.             // Get pending change.  
  37.             final int state;  
  38.             final boolean stateChanged;  
  39.             final int backlight;  
  40.             final boolean backlightChanged;  
  41.             synchronized (mLock) {  
  42.                 state = mPendingState;  
  43.                 stateChanged = (state != mActualState);//state是否改变  
  44.                 backlight = mPendingBacklight;  
  45.                 backlightChanged = (backlight != mActualBacklight);  
  46.                 if (!stateChanged && !backlightChanged) {  
  47.                     // All changed applied, notify outer class and wait for more.  
  48.                     mChangeInProgress = false;  
  49.                     postScreenUpdateThreadSafe();  
  50.                     try {  
  51.                         mLock.wait();  
  52.                     } catch (InterruptedException ex) { }  
  53.                     continue;  
  54.                 }  
  55.                 mActualState = state;  
  56.                 mActualBacklight = backlight;  
  57.             }  
  58.   
  59.             // Apply pending change.  
  60.             if (DEBUG) {  
  61.                 Slog.d(TAG, "Updating screen state: state="  
  62.                         + Display.stateToString(state) + ", backlight=" + backlight);  
  63.             }  
  64.             boolean suspending = Display.isSuspendedState(state);  
  65.             if (stateChanged && !suspending) {改变了就调用requestDisplayState函数  
  66.                 requestDisplayState(state);  
  67.             }  
  68.             if (backlightChanged) {  
  69.                 setBrightness(backlight);  
  70.             }  
  71.             if (stateChanged && suspending) {  
  72.                 requestDisplayState(state);  
  73.             }  
  74.         }  
  75.     }  
  76.   
  77.     private void requestDisplayState(int state) {  
  78.         Trace.traceBegin(Trace.TRACE_TAG_POWER, "requestDisplayState("  
  79.                 + Display.stateToString(state) + ")");  
  80.         try {  
  81.             mBlanker.requestDisplayState(state);//其中的调用了PowerManagerService的函数，详细看下面  
  82.         } finally {  
  83.             Trace.traceEnd(Trace.TRACE_TAG_POWER);  
  84.         }  
  85.     }  
  86.   
  87.     private void setBrightness(int backlight) {  
  88.         Trace.traceBegin(Trace.TRACE_TAG_POWER, "setBrightness(" + backlight + ")");  
  89.         try {  
  90.             mBacklight.setBrightness(backlight);  
  91.         } finally {  
  92.             Trace.traceEnd(Trace.TRACE_TAG_POWER);  
  93.         }  
  94.     }  
  95. }  

当display的state改变的时候调用了mBlanker的requestDisplayState函数，而这个blanker如下：

[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);//调用了PowerManagerService中的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.     }  

最终还是调用了PowerManagerService中的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);  
  12.                 }  
  13.                 if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) {  
  14.                     setHalAutoSuspendModeLocked(true);  
  15.                 }  
  16.             } else {  
  17.                 if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) {  
  18.                     setHalAutoSuspendModeLocked(false);  
  19.                 }  
  20.                 if (!mDecoupleHalInteractiveModeFromDisplayConfig) {  
  21.                     setHalInteractiveModeLocked(true);  
  22.                 }  
  23.             }  
  24.         }  
  25.     }  
  26. }  

其中setHalInteractiveModeLocked是一个native函数，设置屏幕是否亮。

[java] view plain copy
  1. private void setHalInteractiveModeLocked(boolean enable) {  
  2.     if (enable != mHalInteractiveModeEnabled) {  
  3.         if (DEBUG) {  
  4.             Slog.d(TAG, "Setting HAL interactive mode to " + enable);  
  5.         }  
  6.         mHalInteractiveModeEnabled = enable;  
  7.         Trace.traceBegin(Trace.TRACE_TAG_POWER, "setHalInteractive(" + enable + ")");  
  8.         try {  
  9.             nativeSetInteractive(enable);  
  10.         } finally {  
  11.             Trace.traceEnd(Trace.TRACE_TAG_POWER);  
  12.         }  
  13.     }  
  14. }  

我们再看下DisPlayPowerControler如何设置ScreenBrightness,是调用animateScreenBrightness函数：

[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)) {  
  6.         try {  
  7.             mBatteryStats.noteScreenBrightness(target);  
  8.         } catch (RemoteException ex) {  
  9.             // same process  
  10.         }  
  11.     }  
  12. }  

直接看类RampAnimator<T> 的animateTo函数，其中调用了mProperty.setValue(mObject, target);

[java] view plain copy
  1. public boolean animateTo(int target, int rate) {  
  2.     // Immediately jump to the target the first time.  
  3.     if (mFirstTime || rate <= 0) {  
  4.         if (mFirstTime || target != mCurrentValue) {  
  5.             mFirstTime = false;  
  6.             mRate = 0;  
  7.             mTargetValue = target;  
  8.             mCurrentValue = target;  
  9.             mProperty.setValue(mObject, target);  
  10.             if (mAnimating) {  
  11.                 mAnimating = false;  
  12.                 cancelAnimationCallback();  
  13.             }  
  14.             if (mListener != null) {  
  15.                 mListener.onAnimationEnd();  
  16.             }  
  17.             return true;  
  18.         }  
  19.         return false;  
  20.     }  

最后还是调用了DisplayPowerState的setScreenState函数

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

这个函数分析大体和上面的setState差不多，最后也是在线程中调用setBrightness函数

[java] view plain copy
  1. public void run() {  
  2.     for (;;) {  
  3.         // Get pending change.  
  4.         final int state;  
  5.         final boolean stateChanged;  
  6.         final int backlight;  
  7.         final boolean backlightChanged;  
  8.         synchronized (mLock) {  
  9.             state = mPendingState;  
  10.             stateChanged = (state != mActualState);  
  11.             backlight = mPendingBacklight;  
  12.             backlightChanged = (backlight != mActualBacklight);  
  13.             if (!stateChanged && !backlightChanged) {  
  14.                 // All changed applied, notify outer class and wait for more.  
  15.                 mChangeInProgress = false;  
  16.                 postScreenUpdateThreadSafe();  
  17.                 try {  
  18.                     mLock.wait();  
  19.                 } catch (InterruptedException ex) { }  
  20.                 continue;  
  21.             }  
  22.             mActualState = state;  
  23.             mActualBacklight = backlight;  
  24.         }  
  25.   
  26.         // Apply pending change.  
  27.         if (DEBUG) {  
  28.             Slog.d(TAG, "Updating screen state: state="  
  29.                     + Display.stateToString(state) + ", backlight=" + backlight);  
  30.         }  
  31.         boolean suspending = Display.isSuspendedState(state);  
  32.         if (stateChanged && !suspending) {  
  33.             requestDisplayState(state);  
  34.         }  
  35.         if (backlightChanged) {  
  36.             setBrightness(backlight);  
  37.         }  
  38.         if (stateChanged && suspending) {  
  39.             requestDisplayState(state);  
  40.         }  
  41.     }  


[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);  
  5.     } finally {  
  6.         Trace.traceEnd(Trace.TRACE_TAG_POWER);  
  7.     }  
  8. }  

而mBackLigth是LocalServices.getService(LightsManager.class);

最后调到LightsService中的setLightLocked函数。

[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);//native函数设置亮度  
  12.         } finally {  
  13.             Trace.traceEnd(Trace.TRACE_TAG_POWER);  
  14.         }  
  15.     }  
  16. }  

总结下：PowerManagerService中updateDisplayPowerStateLocked函数调用DisplayPowerControler中的requestPowerState函数，直接返回一个false，然后再发送一个信号，调用DisplayPowerControler中的updatePowerstate，然后和DisplayPowerState进行交互，结束后将mDisplayReadyLocked = true ，再调用PowerManagerService的updatePowerStateLocked，重新调用DisplayPowerControler中的requestPowerState函数然后再返回true。


0 0
淘宝联盟站长 淘宝联盟站长
原创粉丝点击
热门IT博客
矩阵按列归一化矩阵按列归一化
自动发卡程序源码自动发卡程序源码
淘宝如何收藏店铺
淘宝售后客服怎么应聘
淘宝网装修的工作流程
blink sunshine 知乎
软件测试计划书模板
443端口漏洞
淘宝上怎么发布广告
视频音量放大软件
股票买入卖出实时数据
知乎 恶魔的奶爸
matlab导入多个txt数据
java 日期加三个月
卷积神经网络知乎
两个mac之间屏幕共享
声音放大器软件
五笔拼音混合输入 mac
学电脑编程怎么样
徐志雷夺冠知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 大唐幻游 幻游大唐 幻游卡盟 幻灭 童话幻灭 网游之幻灭江湖 幻灭是什么意思 童话幻灭王乐乐 兽人之异世幻灭 安琪拉新皮肤幻灭灾女 幻灯 幻肢痛 幻痛 合金装备幻痛攻略 合金装备5幻痛静静 合金装备5幻痛下载 合金装备5幻痛手机版下载 合金装备5幻痛剧情 合金装备5 幻痛 幻痛攻略 合金装备5幻痛骷髅兵回收方法 幻神 三幻神 幻神云天空 幻神劫 黑颜 幻神下载 幻神战记 幻神奇迹 网王之幻神空释 明日方舟幻神 明日方舟三幻神 碧蓝航线三幻神 幻神什么意思 网王之东方幻神 幻神是什么梗 幻神txt全集下载 秦时之修罗 幻神天罚 网王之幻神空释第八区 95版本幻神职业 九星幻神劫 马生菜 末世帝渊之巫魂狂令 幻神胧燚

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里