android5.1 PowerManagerService和DisplayPowerControler、DisplayPowerState关系

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

 private boolean updateDisplayPowerStateLocked(int dirty) {        final boolean oldDisplayReady = mDisplayReady;        if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY | DIRTY_WAKEFULNESS                | DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED | DIRTY_BOOT_COMPLETED                | DIRTY_SETTINGS | DIRTY_SCREEN_BRIGHTNESS_BOOST)) != 0) {            mDisplayPowerRequest.policy = getDesiredScreenPolicyLocked();            // Determine appropriate screen brightness and auto-brightness adjustments.            int screenBrightness = mScreenBrightnessSettingDefault;            float screenAutoBrightnessAdjustment = 0.0f;            boolean autoBrightness = (mScreenBrightnessModeSetting ==                    Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);            if (isValidBrightness(mScreenBrightnessOverrideFromWindowManager)) {                screenBrightness = mScreenBrightnessOverrideFromWindowManager;                autoBrightness = false;            } else if (isValidBrightness(mTemporaryScreenBrightnessSettingOverride)) {                screenBrightness = mTemporaryScreenBrightnessSettingOverride;            } else if (isValidBrightness(mScreenBrightnessSetting)) {                screenBrightness = mScreenBrightnessSetting;            }            if (autoBrightness) {                screenBrightness = mScreenBrightnessSettingDefault;                if (isValidAutoBrightnessAdjustment(                        mTemporaryScreenAutoBrightnessAdjustmentSettingOverride)) {                    screenAutoBrightnessAdjustment =                            mTemporaryScreenAutoBrightnessAdjustmentSettingOverride;                } else if (isValidAutoBrightnessAdjustment(                        mScreenAutoBrightnessAdjustmentSetting)) {                    screenAutoBrightnessAdjustment = mScreenAutoBrightnessAdjustmentSetting;                }            }            screenBrightness = Math.max(Math.min(screenBrightness,                    mScreenBrightnessSettingMaximum), mScreenBrightnessSettingMinimum);            screenAutoBrightnessAdjustment = Math.max(Math.min(                    screenAutoBrightnessAdjustment, 1.0f), -1.0f);            // Update display power request.            mDisplayPowerRequest.screenBrightness = screenBrightness;            mDisplayPowerRequest.screenAutoBrightnessAdjustment =                    screenAutoBrightnessAdjustment;            mDisplayPowerRequest.useAutoBrightness = autoBrightness;            mDisplayPowerRequest.useProximitySensor = shouldUseProximitySensorLocked();            mDisplayPowerRequest.lowPowerMode = mLowPowerModeEnabled;            mDisplayPowerRequest.boostScreenBrightness = mScreenBrightnessBoostInProgress;            if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DOZE) {                mDisplayPowerRequest.dozeScreenState = mDozeScreenStateOverrideFromDreamManager;                mDisplayPowerRequest.dozeScreenBrightness =                        mDozeScreenBrightnessOverrideFromDreamManager;            } else {                mDisplayPowerRequest.dozeScreenState = Display.STATE_UNKNOWN;                mDisplayPowerRequest.dozeScreenBrightness = PowerManager.BRIGHTNESS_DEFAULT;            }            mDisplayReady = mDisplayManagerInternal.requestPowerState(mDisplayPowerRequest,//调用DisplayPowerControler的requestPowerstate接口                    mRequestWaitForNegativeProximity);            mRequestWaitForNegativeProximity = false;        }        return mDisplayReady && !oldDisplayReady;    }

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

mDisplayManagerInternal = getLocalService(DisplayManagerInternal.class);。。。。mDisplayManagerInternal.initPowerManagement(                    mDisplayPowerCallbacks, mHandler, sensorManager);

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

    private final class LocalService extends DisplayManagerInternal {        @Override        public void initPowerManagement(final DisplayPowerCallbacks callbacks, Handler handler,                SensorManager sensorManager) {            synchronized (mSyncRoot) {                DisplayBlanker blanker = new DisplayBlanker() {                    @Override                    public void requestDisplayState(int state) {                        // The order of operations is important for legacy reasons.                        if (state == Display.STATE_OFF) {                            requestGlobalDisplayStateInternal(state);                        }                        callbacks.onDisplayStateChange(state);//注意这个接口后续会介绍                        if (state != Display.STATE_OFF) {                            requestGlobalDisplayStateInternal(state);                        }                    }                };                mDisplayPowerController = new DisplayPowerController(//new一个DisplayPowerController                        mContext, callbacks, handler, sensorManager, blanker);            }        }        @Override        public boolean requestPowerState(DisplayPowerRequest request,                boolean waitForNegativeProximity) {            return mDisplayPowerController.requestPowerState(request,                    waitForNegativeProximity);        }。。。。。

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

    public boolean requestPowerState(DisplayPowerRequest request,            boolean waitForNegativeProximity) {        synchronized (mLock) {            boolean changed = false;            if (waitForNegativeProximity                    && !mPendingWaitForNegativeProximityLocked) {                mPendingWaitForNegativeProximityLocked = true;                changed = true;            }            if (mPendingRequestLocked == null) {                mPendingRequestLocked = new DisplayPowerRequest(request);                changed = true;            } else if (!mPendingRequestLocked.equals(request)) {                mPendingRequestLocked.copyFrom(request);                changed = true;            }            if (changed) {                mDisplayReadyLocked = false;//注意有变化，返回的是false            }            if (changed && !mPendingRequestChangedLocked) {                mPendingRequestChangedLocked = true;                sendUpdatePowerStateLocked();//发送信号，到updatePowerState            }            return mDisplayReadyLocked;        }    }

下面我们就来分析下DisplayPowerControler中的updatePowerState函数：

 private void updatePowerState() {        // Update the power state request.        final boolean mustNotify;        boolean mustInitialize = false;        boolean autoBrightnessAdjustmentChanged = false;        synchronized (mLock) {            mPendingUpdatePowerStateLocked = false;            if (mPendingRequestLocked == null) {                return; // wait until first actual power request            }            if (mPowerRequest == null) {                mPowerRequest = new DisplayPowerRequest(mPendingRequestLocked);                mWaitingForNegativeProximity = mPendingWaitForNegativeProximityLocked;                mPendingWaitForNegativeProximityLocked = false;                mPendingRequestChangedLocked = false;                mustInitialize = true;            } else if (mPendingRequestChangedLocked) {                autoBrightnessAdjustmentChanged = (mPowerRequest.screenAutoBrightnessAdjustment                        != mPendingRequestLocked.screenAutoBrightnessAdjustment);                mPowerRequest.copyFrom(mPendingRequestLocked);                mWaitingForNegativeProximity |= mPendingWaitForNegativeProximityLocked;                mPendingWaitForNegativeProximityLocked = false;                mPendingRequestChangedLocked = false;                mDisplayReadyLocked = false;//这时候mDisplayReadyLocked还是false，这是requestPowerState的返回值            }            mustNotify = !mDisplayReadyLocked;        }        // Initialize things the first time the power state is changed.        if (mustInitialize) {            initialize();        }        // Compute the basic display state using the policy.        // We might override this below based on other factors.        int state;        int brightness = PowerManager.BRIGHTNESS_DEFAULT;        boolean performScreenOffTransition = false;        switch (mPowerRequest.policy) {//根据policy，得到显示的state            case DisplayPowerRequest.POLICY_OFF:                state = Display.STATE_OFF;                performScreenOffTransition = true;                break;            case DisplayPowerRequest.POLICY_DOZE:                if (mPowerRequest.dozeScreenState != Display.STATE_UNKNOWN) {                    state = mPowerRequest.dozeScreenState;                } else {                    state = Display.STATE_DOZE;                }                if (!mAllowAutoBrightnessWhileDozingConfig) {                    brightness = mPowerRequest.dozeScreenBrightness;                }                break;            case DisplayPowerRequest.POLICY_DIM:            case DisplayPowerRequest.POLICY_BRIGHT:            default:                state = Display.STATE_ON;                break;        }        assert(state != Display.STATE_UNKNOWN);        // Apply the proximity sensor.这块是距离传感器        if (mProximitySensor != null) {            if (mPowerRequest.useProximitySensor && state != Display.STATE_OFF) {                setProximitySensorEnabled(true);                if (!mScreenOffBecauseOfProximity                        && mProximity == PROXIMITY_POSITIVE) {                    mScreenOffBecauseOfProximity = true;                    sendOnProximityPositiveWithWakelock();                }            } else if (mWaitingForNegativeProximity                    && mScreenOffBecauseOfProximity                    && mProximity == PROXIMITY_POSITIVE                    && state != Display.STATE_OFF) {                setProximitySensorEnabled(true);            } else {                setProximitySensorEnabled(false);                mWaitingForNegativeProximity = false;            }            if (mScreenOffBecauseOfProximity                    && mProximity != PROXIMITY_POSITIVE) {                mScreenOffBecauseOfProximity = false;                sendOnProximityNegativeWithWakelock();            }        } else {            mWaitingForNegativeProximity = false;        }        if (mScreenOffBecauseOfProximity) {            state = Display.STATE_OFF;        }        // Animate the screen state change unless already animating.        // The transition may be deferred, so after this point we will use the        // actual state instead of the desired one.        //后面详细分析下这函数，主要设置显示的state，和displayPowerState交互。        animateScreenStateChange(state, performScreenOffTransition);        state = mPowerState.getScreenState();        // Use zero brightness when screen is off.        if (state == Display.STATE_OFF) {            brightness = PowerManager.BRIGHTNESS_OFF;        }        // Configure auto-brightness.        boolean autoBrightnessEnabled = false;        if (mAutomaticBrightnessController != null) {            final boolean autoBrightnessEnabledInDoze = mAllowAutoBrightnessWhileDozingConfig                    && (state == Display.STATE_DOZE || state == Display.STATE_DOZE_SUSPEND);            autoBrightnessEnabled = mPowerRequest.useAutoBrightness                    && (state == Display.STATE_ON || autoBrightnessEnabledInDoze)                    && brightness < 0;            mAutomaticBrightnessController.configure(autoBrightnessEnabled,                    mPowerRequest.screenAutoBrightnessAdjustment, state != Display.STATE_ON);        }        // Apply brightness boost.        // We do this here after configuring auto-brightness so that we don't        // disable the light sensor during this temporary state.  That way when        // boost ends we will be able to resume normal auto-brightness behavior        // without any delay.        if (mPowerRequest.boostScreenBrightness                && brightness != PowerManager.BRIGHTNESS_OFF) {            brightness = PowerManager.BRIGHTNESS_ON;        }        // Apply auto-brightness.        boolean slowChange = false;        if (brightness < 0) {            if (autoBrightnessEnabled) {                brightness = mAutomaticBrightnessController.getAutomaticScreenBrightness();            }            if (brightness >= 0) {                // Use current auto-brightness value and slowly adjust to changes.                brightness = clampScreenBrightness(brightness);                if (mAppliedAutoBrightness && !autoBrightnessAdjustmentChanged) {                    slowChange = true; // slowly adapt to auto-brightness                }                mAppliedAutoBrightness = true;            } else {                mAppliedAutoBrightness = false;            }        } else {            mAppliedAutoBrightness = false;        }        // Use default brightness when dozing unless overridden.        if (brightness < 0 && (state == Display.STATE_DOZE                || state == Display.STATE_DOZE_SUSPEND)) {            brightness = mScreenBrightnessDozeConfig;        }        // Apply manual brightness.        // Use the current brightness setting from the request, which is expected        // provide a nominal default value for the case where auto-brightness        // is not ready yet.        if (brightness < 0) {            brightness = clampScreenBrightness(mPowerRequest.screenBrightness);        }        // Apply dimming by at least some minimum amount when user activity        // timeout is about to expire.        if (mPowerRequest.policy == DisplayPowerRequest.POLICY_DIM) {            if (brightness > mScreenBrightnessRangeMinimum) {                brightness = Math.max(Math.min(brightness - SCREEN_DIM_MINIMUM_REDUCTION,                        mScreenBrightnessDimConfig), mScreenBrightnessRangeMinimum);            }            if (!mAppliedDimming) {                slowChange = false;            }            mAppliedDimming = true;        }        // If low power mode is enabled, cut the brightness level by half        // as long as it is above the minimum threshold.        if (mPowerRequest.lowPowerMode) {//低功耗模式            if (brightness > mScreenBrightnessRangeMinimum) {                brightness = Math.max(brightness / 2, mScreenBrightnessRangeMinimum);            }            if (!mAppliedLowPower) {                slowChange = false;            }            mAppliedLowPower = true;        }        // Animate the screen brightness when the screen is on or dozing.        // Skip the animation when the screen is off or suspended.        if (!mPendingScreenOff) {            if (state == Display.STATE_ON || state == Display.STATE_DOZE) {                animateScreenBrightness(brightness,                        slowChange ? BRIGHTNESS_RAMP_RATE_SLOW : BRIGHTNESS_RAMP_RATE_FAST);            } else {                animateScreenBrightness(brightness, 0);            }        }        // Determine whether the display is ready for use in the newly requested state.        // Note that we do not wait for the brightness ramp animation to complete before        // reporting the display is ready because we only need to ensure the screen is in the        // right power state even as it continues to converge on the desired brightness.        final boolean ready = mPendingScreenOnUnblocker == null                && !mColorFadeOnAnimator.isStarted()                && !mColorFadeOffAnimator.isStarted()                && mPowerState.waitUntilClean(mCleanListener);        final boolean finished = ready                && !mScreenBrightnessRampAnimator.isAnimating();        // Grab a wake lock if we have unfinished business.        if (!finished && !mUnfinishedBusiness) {            if (DEBUG) {                Slog.d(TAG, "Unfinished business...");            }            mCallbacks.acquireSuspendBlocker();//回调持cpu锁            mUnfinishedBusiness = true;//使用该变量，只能进一次该函数        }        // Notify the power manager when ready.        if (ready && mustNotify) {            // Send state change.            synchronized (mLock) {                if (!mPendingRequestChangedLocked) {                    mDisplayReadyLocked = true;                    if (DEBUG) {                        Slog.d(TAG, "Display ready!");                    }                }            }            sendOnStateChangedWithWakelock();//重新在PowerManagerService中调用updatePowerState函数        }        // Release the wake lock when we have no unfinished business.        if (finished && mUnfinishedBusiness) {            if (DEBUG) {                Slog.d(TAG, "Finished business...");            }            mUnfinishedBusiness = false;            mCallbacks.releaseSuspendBlocker();//释放cpu锁        }    }

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

    private final DisplayManagerInternal.DisplayPowerCallbacks mDisplayPowerCallbacks =            new DisplayManagerInternal.DisplayPowerCallbacks() {        private int mDisplayState = Display.STATE_UNKNOWN;        @Override        public void onStateChanged() {//只是重新调用下powerManagerService中的updatePowerStateLocked函数            synchronized (mLock) {                mDirty |= DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED;                updatePowerStateLocked();            }        }        @Override        public void onProximityPositive() {            synchronized (mLock) {                mProximityPositive = true;                mDirty |= DIRTY_PROXIMITY_POSITIVE;                updatePowerStateLocked();            }        }        @Override        public void onProximityNegative() {            synchronized (mLock) {                mProximityPositive = false;                mDirty |= DIRTY_PROXIMITY_POSITIVE;                userActivityNoUpdateLocked(SystemClock.uptimeMillis(),                        PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, Process.SYSTEM_UID);                updatePowerStateLocked();            }        }        @Override        public void onDisplayStateChange(int state) {            // This method is only needed to support legacy display blanking behavior            // where the display's power state is coupled to suspend or to the power HAL.            // The order of operations matters here.            synchronized (mLock) {                if (mDisplayState != state) {                    mDisplayState = state;                    if (state == Display.STATE_OFF) {                        if (!mDecoupleHalInteractiveModeFromDisplayConfig) {                            setHalInteractiveModeLocked(false);                        }                        if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) {                            setHalAutoSuspendModeLocked(true);                        }                    } else {                        if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) {                            setHalAutoSuspendModeLocked(false);                        }                        if (!mDecoupleHalInteractiveModeFromDisplayConfig) {                            setHalInteractiveModeLocked(true);                        }                    }                }            }        }        @Override        public void acquireSuspendBlocker() {            mDisplaySuspendBlocker.acquire();        }        @Override        public void releaseSuspendBlocker() {            mDisplaySuspendBlocker.release();        }

而sendOnStateChangedWithWakelock代码如下：

    private void sendOnStateChangedWithWakelock() {        mCallbacks.acquireSuspendBlocker();        mHandler.post(mOnStateChangedRunnable);    }    private final Runnable mOnStateChangedRunnable = new Runnable() {直接在两个线程中，这个handler是PowerManagerService中的        @Override        public void run() {            mCallbacks.onStateChanged();            mCallbacks.releaseSuspendBlocker();        }    };

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

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

    private void animateScreenStateChange(int target, boolean performScreenOffTransition) {        // If there is already an animation in progress, don't interfere with it.        if (mColorFadeOnAnimator.isStarted()                || mColorFadeOffAnimator.isStarted()) {            return;        }        if (mPendingScreenOff && target != Display.STATE_OFF) {            setScreenState(Display.STATE_OFF);//设置display的state            mPendingScreenOff = false;        }        if (target == Display.STATE_ON) {            if (!setScreenState(Display.STATE_ON)) {                return; // screen on blocked            }            if (USE_COLOR_FADE_ON_ANIMATION && mPowerRequest.isBrightOrDim()) {                // Perform screen on animation.                if (mPowerState.getColorFadeLevel() == 1.0f) {                    mPowerState.dismissColorFade();                } else if (mPowerState.prepareColorFade(mContext,                        mColorFadeFadesConfig ?                                ColorFade.MODE_FADE :                                        ColorFade.MODE_WARM_UP)) {                    mColorFadeOnAnimator.start();                } else {                    mColorFadeOnAnimator.end();                }            } else {                // Skip screen on animation.                mPowerState.setColorFadeLevel(1.0f);                mPowerState.dismissColorFade();            }        } else if (target == Display.STATE_DOZE) {            // Want screen dozing.            // Wait for brightness animation to complete beforehand when entering doze            // from screen on to prevent a perceptible jump because brightness may operate            // differently when the display is configured for dozing.            if (mScreenBrightnessRampAnimator.isAnimating()                    && mPowerState.getScreenState() == Display.STATE_ON) {                return;            }            // Set screen state.            if (!setScreenState(Display.STATE_DOZE)) {                return; // screen on blocked            }

。。。。。。。。。。

</pre><p>再看setScreenState函数</p><pre class="java" name="code">    private boolean setScreenState(int state) {        if (mPowerState.getScreenState() != state) {            final boolean wasOn = (mPowerState.getScreenState() != Display.STATE_OFF);            mPowerState.setScreenState(state);//调用DisplayPowerState的setScreenState            // Tell battery stats about the transition.            try {                mBatteryStats.noteScreenState(state);            } catch (RemoteException ex) {                // same process            }            // Tell the window manager what's happening.            // Temporarily block turning the screen on until the window manager is ready            // by leaving a black surface covering the screen.  This surface is essentially            // the final state of the color fade animation.            boolean isOn = (state != Display.STATE_OFF);            if (wasOn && !isOn) {                unblockScreenOn();                mWindowManagerPolicy.screenTurnedOff();//通知window Manager            } else if (!wasOn && isOn) {                if (mPowerState.getColorFadeLevel() == 0.0f) {                    blockScreenOn();                } else {                    unblockScreenOn();                }                mWindowManagerPolicy.screenTurningOn(mPendingScreenOnUnblocker);            }        }        return mPendingScreenOnUnblocker == null;    }

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

    public void setScreenState(int state) {        if (mScreenState != state) {            if (DEBUG) {                Slog.d(TAG, "setScreenState: state=" + state);            }            mScreenState = state;            mScreenReady = false;            scheduleScreenUpdate();        }    }        private void scheduleScreenUpdate() {        if (!mScreenUpdatePending) {            mScreenUpdatePending = true;            postScreenUpdateThreadSafe();        }        private void postScreenUpdateThreadSafe() {        mHandler.removeCallbacks(mScreenUpdateRunnable);        mHandler.post(mScreenUpdateRunnable);    }    private final Runnable mScreenUpdateRunnable = new Runnable() {        @Override        public void run() {            mScreenUpdatePending = false;            int brightness = mScreenState != Display.STATE_OFF                    && mColorFadeLevel > 0f ? mScreenBrightness : 0;            if (mPhotonicModulator.setState(mScreenState, brightness)) {//最后调用了线程的setState                if (DEBUG) {                    Slog.d(TAG, "Screen ready");                }                mScreenReady = true;                invokeCleanListenerIfNeeded();            } else {                if (DEBUG) {                    Slog.d(TAG, "Screen not ready");                }            }        }    };    

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

    private final class PhotonicModulator extends Thread {        private static final int INITIAL_SCREEN_STATE = Display.STATE_OFF; // unknown, assume off        private static final int INITIAL_BACKLIGHT = -1; // unknown        private final Object mLock = new Object();        private int mPendingState = INITIAL_SCREEN_STATE;        private int mPendingBacklight = INITIAL_BACKLIGHT;        private int mActualState = INITIAL_SCREEN_STATE;        private int mActualBacklight = INITIAL_BACKLIGHT;        private boolean mChangeInProgress;        public boolean setState(int state, int backlight) {            synchronized (mLock) {                if (state != mPendingState || backlight != mPendingBacklight) {                    if (DEBUG) {                        Slog.d(TAG, "Requesting new screen state: state="                                + Display.stateToString(state) + ", backlight=" + backlight);                    }                    mPendingState = state;//设置state                    mPendingBacklight = backlight;                    if (!mChangeInProgress) {                        mChangeInProgress = true;                        mLock.notifyAll();                    }                }                return !mChangeInProgress;            }        }        @Override        public void run() {            for (;;) {//线程一直跑，状态改变就去PowerManagerService中调用setHalInteractiveModeLocked设置屏幕状态                // Get pending change.                final int state;                final boolean stateChanged;                final int backlight;                final boolean backlightChanged;                synchronized (mLock) {                    state = mPendingState;                    stateChanged = (state != mActualState);//state是否改变                    backlight = mPendingBacklight;                    backlightChanged = (backlight != mActualBacklight);                    if (!stateChanged && !backlightChanged) {                        // All changed applied, notify outer class and wait for more.                        mChangeInProgress = false;                        postScreenUpdateThreadSafe();                        try {                            mLock.wait();                        } catch (InterruptedException ex) { }                        continue;                    }                    mActualState = state;                    mActualBacklight = backlight;                }                // Apply pending change.                if (DEBUG) {                    Slog.d(TAG, "Updating screen state: state="                            + Display.stateToString(state) + ", backlight=" + backlight);                }                boolean suspending = Display.isSuspendedState(state);                if (stateChanged && !suspending) {改变了就调用requestDisplayState函数                    requestDisplayState(state);                }                if (backlightChanged) {                    setBrightness(backlight);                }                if (stateChanged && suspending) {                    requestDisplayState(state);                }            }        }        private void requestDisplayState(int state) {            Trace.traceBegin(Trace.TRACE_TAG_POWER, "requestDisplayState("                    + Display.stateToString(state) + ")");            try {                mBlanker.requestDisplayState(state);//其中的调用了PowerManagerService的函数，详细看下面            } finally {                Trace.traceEnd(Trace.TRACE_TAG_POWER);            }        }        private void setBrightness(int backlight) {            Trace.traceBegin(Trace.TRACE_TAG_POWER, "setBrightness(" + backlight + ")");            try {                mBacklight.setBrightness(backlight);            } finally {                Trace.traceEnd(Trace.TRACE_TAG_POWER);            }        }    }

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

    private final class LocalService extends DisplayManagerInternal {        @Override        public void initPowerManagement(final DisplayPowerCallbacks callbacks, Handler handler,                SensorManager sensorManager) {            synchronized (mSyncRoot) {                DisplayBlanker blanker = new DisplayBlanker() {                    @Override                    public void requestDisplayState(int state) {                        // The order of operations is important for legacy reasons.                        if (state == Display.STATE_OFF) {                            requestGlobalDisplayStateInternal(state);                        }                        callbacks.onDisplayStateChange(state);//调用了PowerManagerService中的onDisplayStateChange                        if (state != Display.STATE_OFF) {                            requestGlobalDisplayStateInternal(state);                        }                    }                };                mDisplayPowerController = new DisplayPowerController(                        mContext, callbacks, handler, sensorManager, blanker);            }        }

最终还是调用了PowerManagerService中的onDisplayStateChange，

        @Override        public void onDisplayStateChange(int state) {            // This method is only needed to support legacy display blanking behavior            // where the display's power state is coupled to suspend or to the power HAL.            // The order of operations matters here.            synchronized (mLock) {                if (mDisplayState != state) {                    mDisplayState = state;                    if (state == Display.STATE_OFF) {                        if (!mDecoupleHalInteractiveModeFromDisplayConfig) {                            setHalInteractiveModeLocked(false);                        }                        if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) {                            setHalAutoSuspendModeLocked(true);                        }                    } else {                        if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) {                            setHalAutoSuspendModeLocked(false);                        }                        if (!mDecoupleHalInteractiveModeFromDisplayConfig) {                            setHalInteractiveModeLocked(true);                        }                    }                }            }        }

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

    private void setHalInteractiveModeLocked(boolean enable) {        if (enable != mHalInteractiveModeEnabled) {            if (DEBUG) {                Slog.d(TAG, "Setting HAL interactive mode to " + enable);            }            mHalInteractiveModeEnabled = enable;            Trace.traceBegin(Trace.TRACE_TAG_POWER, "setHalInteractive(" + enable + ")");            try {                nativeSetInteractive(enable);            } finally {                Trace.traceEnd(Trace.TRACE_TAG_POWER);            }        }    }

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

    private void animateScreenBrightness(int target, int rate) {        if (DEBUG) {            Slog.d(TAG, "Animating brightness: target=" + target +", rate=" + rate);        }        if (mScreenBrightnessRampAnimator.animateTo(target, rate)) {            try {                mBatteryStats.noteScreenBrightness(target);            } catch (RemoteException ex) {                // same process            }        }    }

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

    public boolean animateTo(int target, int rate) {        // Immediately jump to the target the first time.        if (mFirstTime || rate <= 0) {            if (mFirstTime || target != mCurrentValue) {                mFirstTime = false;                mRate = 0;                mTargetValue = target;                mCurrentValue = target;                mProperty.setValue(mObject, target);                if (mAnimating) {                    mAnimating = false;                    cancelAnimationCallback();                }                if (mListener != null) {                    mListener.onAnimationEnd();                }                return true;            }            return false;        }

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

    public void setScreenState(int state) {        if (mScreenState != state) {            if (DEBUG) {                Slog.d(TAG, "setScreenState: state=" + state);            }            mScreenState = state;            mScreenReady = false;            scheduleScreenUpdate();        }    }

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

        public void run() {            for (;;) {                // Get pending change.                final int state;                final boolean stateChanged;                final int backlight;                final boolean backlightChanged;                synchronized (mLock) {                    state = mPendingState;                    stateChanged = (state != mActualState);                    backlight = mPendingBacklight;                    backlightChanged = (backlight != mActualBacklight);                    if (!stateChanged && !backlightChanged) {                        // All changed applied, notify outer class and wait for more.                        mChangeInProgress = false;                        postScreenUpdateThreadSafe();                        try {                            mLock.wait();                        } catch (InterruptedException ex) { }                        continue;                    }                    mActualState = state;                    mActualBacklight = backlight;                }                // Apply pending change.                if (DEBUG) {                    Slog.d(TAG, "Updating screen state: state="                            + Display.stateToString(state) + ", backlight=" + backlight);                }                boolean suspending = Display.isSuspendedState(state);                if (stateChanged && !suspending) {                    requestDisplayState(state);                }                if (backlightChanged) {                    setBrightness(backlight);                }                if (stateChanged && suspending) {                    requestDisplayState(state);                }            }

        private void setBrightness(int backlight) {            Trace.traceBegin(Trace.TRACE_TAG_POWER, "setBrightness(" + backlight + ")");            try {                mBacklight.setBrightness(backlight);            } finally {                Trace.traceEnd(Trace.TRACE_TAG_POWER);            }        }

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

最后调到LightsService中的setLightLocked函数。

        private void setLightLocked(int color, int mode, int onMS, int offMS, int brightnessMode) {            if (color != mColor || mode != mMode || onMS != mOnMS || offMS != mOffMS) {                if (DEBUG) Slog.v(TAG, "setLight #" + mId + ": color=#"                        + Integer.toHexString(color));                mColor = color;                mMode = mode;                mOnMS = onMS;                mOffMS = offMS;                Trace.traceBegin(Trace.TRACE_TAG_POWER, "setLight(" + mId + ", " + color + ")");                try {                    setLight_native(mNativePointer, mId, color, mode, onMS, offMS, brightnessMode);//native函数设置亮度                } finally {                    Trace.traceEnd(Trace.TRACE_TAG_POWER);                }            }        }

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