and5.1PowerManagerService深入分析（二）PowerManager中各函数

上一篇博客把PMS里的构造函数和sytemReady分析了下：

今天主要从PowerManager中的接口入手去分析PowerManagerService.

先分析PowerManager中的一个内部类WakeLock，可以使用这个类持睡眠锁。

下面是PowerManager中WakeLock内部类来里面的代码：

       public void acquire() {            synchronized (mToken) {                acquireLocked();            }        }        /**         * Acquires the wake lock with a timeout.         * <p>         * Ensures that the device is on at the level requested when         * the wake lock was created.  The lock will be released after the given timeout         * expires.         * </p>         *         * @param timeout The timeout after which to release the wake lock, in milliseconds.         */        public void acquire(long timeout) {            synchronized (mToken) {                acquireLocked();                mHandler.postDelayed(mReleaser, timeout);//利用消息机制做一个timeout的持锁，mReleaser中是对该锁释放了            }        }        private void acquireLocked() {            if (!mRefCounted || mCount++ == 0) {                // Do this even if the wake lock is already thought to be held (mHeld == true)                // because non-reference counted wake locks are not always properly released.                // For example, the keyguard's wake lock might be forcibly released by the                // power manager without the keyguard knowing.  A subsequent call to acquire                // should immediately acquire the wake lock once again despite never having                // been explicitly released by the keyguard.                mHandler.removeCallbacks(mReleaser);                Trace.asyncTraceBegin(Trace.TRACE_TAG_POWER, mTraceName, 0);                try {                    mService.acquireWakeLock(mToken, mFlags, mTag, mPackageName, mWorkSource,//调用PMS的acquireWakeLock                            mHistoryTag);                } catch (RemoteException e) {                }                mHeld = true;            }        }

先看PMS里的acquireWakeLock函数，先做一些权限的检查，然后就调用acquireWakeLockInternal函数。

        @Override // Binder call        public void acquireWakeLock(IBinder lock, int flags, String tag, String packageName,                WorkSource ws, String historyTag) {            if (lock == null) {                throw new IllegalArgumentException("lock must not be null");            }            if (packageName == null) {                throw new IllegalArgumentException("packageName must not be null");            }            PowerManager.validateWakeLockParameters(flags, tag);            mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null);            if ((flags & PowerManager.DOZE_WAKE_LOCK) != 0) {                mContext.enforceCallingOrSelfPermission(                        android.Manifest.permission.DEVICE_POWER, null);            }            if (ws != null && ws.size() != 0) {                mContext.enforceCallingOrSelfPermission(                        android.Manifest.permission.UPDATE_DEVICE_STATS, null);            } else {                ws = null;            }            final int uid = Binder.getCallingUid();            final int pid = Binder.getCallingPid();            final long ident = Binder.clearCallingIdentity();            try {                acquireWakeLockInternal(lock, flags, tag, packageName, ws, historyTag, uid, pid);            } finally {                Binder.restoreCallingIdentity(ident);            }        }

acquireWakeLockInternal函数

    private void acquireWakeLockInternal(IBinder lock, int flags, String tag, String packageName,            WorkSource ws, String historyTag, int uid, int pid) {        synchronized (mLock) {            if (DEBUG_SPEW) {                Slog.d(TAG, "acquireWakeLockInternal: lock=" + Objects.hashCode(lock)                        + ", flags=0x" + Integer.toHexString(flags)                        + ", tag=\"" + tag + "\", ws=" + ws + ", uid=" + uid + ", pid=" + pid);            }            WakeLock wakeLock;            int index = findWakeLockIndexLocked(lock);//查找这个IBinder的锁。因为每个应用都是一个进程，通过binder通信与PMS交互。IBinder是唯一的            boolean notifyAcquire;            if (index >= 0) {//找到                wakeLock = mWakeLocks.get(index);                if (!wakeLock.hasSameProperties(flags, tag, ws, uid, pid)) {//如果属性不一样就更新                    // Update existing wake lock.  This shouldn't happen but is harmless.                    notifyWakeLockChangingLocked(wakeLock, flags, tag, packageName,//通知电池统计                            uid, pid, ws, historyTag);                    wakeLock.updateProperties(flags, tag, packageName, ws, historyTag, uid, pid);                }                notifyAcquire = false;            } else {//没找到                wakeLock = new WakeLock(lock, flags, tag, packageName, ws, historyTag, uid, pid);//新建一个WakeLock加入列表                try {                    lock.linkToDeath(wakeLock, 0);                } catch (RemoteException ex) {                    throw new IllegalArgumentException("Wake lock is already dead.");                }                mWakeLocks.add(wakeLock);                notifyAcquire = true;            }            applyWakeLockFlagsOnAcquireLocked(wakeLock, uid);//下面详细分析            mDirty |= DIRTY_WAKE_LOCKS;//mDirty 标志位置位            updatePowerStateLocked();//更新power状态            if (notifyAcquire) {                // This needs to be done last so we are sure we have acquired the                // kernel wake lock.  Otherwise we have a race where the system may                // go to sleep between the time we start the accounting in battery                // stats and when we actually get around to telling the kernel to                // stay awake.                notifyWakeLockAcquiredLocked(wakeLock);//通知电池统计那块            }        }    }

findWakeLockIndexLocked函数

    private int findWakeLockIndexLocked(IBinder lock) {        final int count = mWakeLocks.size();        for (int i = 0; i < count; i++) {            if (mWakeLocks.get(i).mLock == lock) {                return i;            }        }        return -1;    }

applyWakeLockFlagsOnAcquireLocked函数

    private void applyWakeLockFlagsOnAcquireLocked(WakeLock wakeLock, int uid) {        if ((wakeLock.mFlags & PowerManager.ACQUIRE_CAUSES_WAKEUP) != 0//如果持的锁有ACQUIRE_CAUSES_WAKEUP，还有屏幕锁的话，会wakeup设备                && isScreenLock(wakeLock)) {            wakeUpNoUpdateLocked(SystemClock.uptimeMillis(), uid);        }    }

    @SuppressWarnings("deprecation")    private static boolean isScreenLock(final WakeLock wakeLock) {        switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) {            case PowerManager.FULL_WAKE_LOCK:            case PowerManager.SCREEN_BRIGHT_WAKE_LOCK:            case PowerManager.SCREEN_DIM_WAKE_LOCK:                return true;        }        return false;    }

updatePowerStateLocked这个函数是所有的地方都会调用，因此我们最后分析。

下面看下释放锁，releaseWakeLockInternal函数：

    private void releaseWakeLockInternal(IBinder lock, int flags) {        synchronized (mLock) {            int index = findWakeLockIndexLocked(lock);            if (index < 0) {//没找到，直接退出                if (DEBUG_SPEW) {                    Slog.d(TAG, "releaseWakeLockInternal: lock=" + Objects.hashCode(lock)                            + " [not found], flags=0x" + Integer.toHexString(flags));                }                return;            }            WakeLock wakeLock = mWakeLocks.get(index);            if (DEBUG_SPEW) {                Slog.d(TAG, "releaseWakeLockInternal: lock=" + Objects.hashCode(lock)                        + " [" + wakeLock.mTag + "], flags=0x" + Integer.toHexString(flags));            }            if ((flags & PowerManager.RELEASE_FLAG_WAIT_FOR_NO_PROXIMITY) != 0) {                mRequestWaitForNegativeProximity = true;//和距离传感器有关            }            wakeLock.mLock.unlinkToDeath(wakeLock, 0);            removeWakeLockLocked(wakeLock, index);        }    }

removeWakeLockLocked函数

    private void removeWakeLockLocked(WakeLock wakeLock, int index) {        mWakeLocks.remove(index);//列表中去除        notifyWakeLockReleasedLocked(wakeLock);//通知电池统计        applyWakeLockFlagsOnReleaseLocked(wakeLock);        mDirty |= DIRTY_WAKE_LOCKS;//mDirty置标志位        updatePowerStateLocked();    }

applyWakeLockFlagsOnReleaseLocked函数

    private void applyWakeLockFlagsOnReleaseLocked(WakeLock wakeLock) {        if ((wakeLock.mFlags & PowerManager.ON_AFTER_RELEASE) != 0//当有这个标志位的锁，释放的时候。需要触发useractivity，因此会延长亮屏时间                && isScreenLock(wakeLock)) {//是否是屏幕锁            userActivityNoUpdateLocked(SystemClock.uptimeMillis(),//触发userActivity事件，后面详细分析                    PowerManager.USER_ACTIVITY_EVENT_OTHER,                    PowerManager.USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS,                    wakeLock.mOwnerUid);        }    }

接下来我们来分析下gotoSleep函数：

调用PowerManger的gotoSleep函数，最后会到PMS的goToSleepInternal函数

    private void goToSleepInternal(long eventTime, int reason, int flags, int uid) {        synchronized (mLock) {            if (goToSleepNoUpdateLocked(eventTime, reason, flags, uid)) {                updatePowerStateLocked();            }        }    }

goToSleepNoUpdateLocked函数

    private boolean goToSleepNoUpdateLocked(long eventTime, int reason, int flags, int uid) {        if (DEBUG_SPEW) {            Slog.d(TAG, "goToSleepNoUpdateLocked: eventTime=" + eventTime                    + ", reason=" + reason + ", flags=" + flags + ", uid=" + uid);        }        if (eventTime < mLastWakeTime//如果时间不对，状态已经是WAKEFULNESS_ASLEEP或者WAKEFULNESS_DOZING，或者系统没准备好直接出去                || mWakefulness == WAKEFULNESS_ASLEEP                || mWakefulness == WAKEFULNESS_DOZING                || !mBootCompleted || !mSystemReady) {            return false;        }        Trace.traceBegin(Trace.TRACE_TAG_POWER, "goToSleep");        try {            switch (reason) {//打印下原因                case PowerManager.GO_TO_SLEEP_REASON_DEVICE_ADMIN:                    Slog.i(TAG, "Going to sleep due to device administration policy "                            + "(uid " + uid +")...");                    break;                case PowerManager.GO_TO_SLEEP_REASON_TIMEOUT:                    Slog.i(TAG, "Going to sleep due to screen timeout (uid " + uid +")...");                    break;                case PowerManager.GO_TO_SLEEP_REASON_LID_SWITCH:                    Slog.i(TAG, "Going to sleep due to lid switch (uid " + uid +")...");                    break;                case PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON:                    Slog.i(TAG, "Going to sleep due to power button (uid " + uid +")...");                    break;                case PowerManager.GO_TO_SLEEP_REASON_HDMI:                    Slog.i(TAG, "Going to sleep due to HDMI standby (uid " + uid +")...");                    break;                default:                    Slog.i(TAG, "Going to sleep by application request (uid " + uid +")...");                    reason = PowerManager.GO_TO_SLEEP_REASON_APPLICATION;                    break;            }            mLastSleepTime = eventTime;            mSandmanSummoned = true;//和做梦有关            setWakefulnessLocked(WAKEFULNESS_DOZING, reason);//设置mWakefulness的状态            // Report the number of wake locks that will be cleared by going to sleep.            int numWakeLocksCleared = 0;            final int numWakeLocks = mWakeLocks.size();            for (int i = 0; i < numWakeLocks; i++) {                final WakeLock wakeLock = mWakeLocks.get(i);                switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) {                    case PowerManager.FULL_WAKE_LOCK:                    case PowerManager.SCREEN_BRIGHT_WAKE_LOCK:                    case PowerManager.SCREEN_DIM_WAKE_LOCK:                        numWakeLocksCleared += 1;                        break;                }            }            EventLog.writeEvent(EventLogTags.POWER_SLEEP_REQUESTED, numWakeLocksCleared);//打印当前屏幕锁的个数            // Skip dozing if requested.            if ((flags & PowerManager.GO_TO_SLEEP_FLAG_NO_DOZE) != 0) {//如果flags有这个状态，直接睡眠                reallyGoToSleepNoUpdateLocked(eventTime, uid);            }        } finally {            Trace.traceEnd(Trace.TRACE_TAG_POWER);        }        return true;    }

我们先看下setWakefulnessLocked函数：

    private void setWakefulnessLocked(int wakefulness, int reason) {        if (mWakefulness != wakefulness) {            finishWakefulnessChangeLocked();            mWakefulness = wakefulness;//将mWakefulness赋值            mWakefulnessChanging = true;            mDirty |= DIRTY_WAKEFULNESS;//mDirty置位            mNotifier.onWakefulnessChangeStarted(wakefulness, reason);//第一次的时候先调onWakefulnessChangeStarted        }    }    private void finishWakefulnessChangeLocked() {        if (mWakefulnessChanging) {            mNotifier.onWakefulnessChangeFinished(mWakefulness);            mWakefulnessChanging = false;        }    }

然后我们看下notifier的onWakefulnessChangeStarted函数

    public void onWakefulnessChangeStarted(int wakefulness, int reason) {        if (DEBUG) {            Slog.d(TAG, "onWakefulnessChangeStarted: wakefulness=" + wakefulness                    + ", reason=" + reason);        }        // We handle interactive state changes once they start so that the system can        // set everything up or the user to begin interacting with applications.        final boolean interactive = PowerManagerInternal.isInteractive(wakefulness);        if (interactive) {            handleWakefulnessChange(wakefulness, interactive, reason);//如果当前是要点亮屏幕        } else {            mLastReason = reason;        }        // Start input as soon as we start waking up or going to sleep.        mInputManagerInternal.setInteractive(interactive);//在InputmanagerService中去调用JNI，没细跟    }

而onWakefulnessChangeFinished函数都是调用handleWakefulnessChange只是interactive参数相反

    public void onWakefulnessChangeFinished(int wakefulness) {        if (DEBUG) {            Slog.d(TAG, "onWakefulnessChangeFinished: wakefulness=" + wakefulness);        }        // Handle interactive state changes once they are finished so that the system can        // finish pending transitions (such as turning the screen off) before causing        // applications to change state visibly.        final boolean interactive = PowerManagerInternal.isInteractive(wakefulness);        if (!interactive) {            handleWakefulnessChange(wakefulness, interactive, mLastReason);        }    }

handleWakefulnessChange函数

 private void handleWakefulnessChange(final int wakefulness, boolean interactive,            final int reason) {        // Tell the activity manager about changes in wakefulness, not just interactivity.        // It needs more granularity than other components.        mHandler.post(new Runnable() {            @Override            public void run() {                mActivityManagerInternal.onWakefulnessChanged(wakefulness);//调用AMS的onWakefulnessChanged函数            }        });        // Handle changes in the overall interactive state.        boolean interactiveChanged = false;        synchronized (mLock) {            // Broadcast interactive state changes.            if (interactive) {                // Waking up...                interactiveChanged = (mActualInteractiveState != INTERACTIVE_STATE_AWAKE);                if (interactiveChanged) {                    mActualInteractiveState = INTERACTIVE_STATE_AWAKE;                    mPendingWakeUpBroadcast = true;                    mHandler.post(new Runnable() {                        @Override                        public void run() {                            EventLog.writeEvent(EventLogTags.POWER_SCREEN_STATE, 1, 0, 0, 0);                            mPolicy.wakingUp();//开启线程phoneWindowManager处理keyguard等                        }                    });                    updatePendingBroadcastLocked();//发送ACTION_SCREEN_ON广播                }            } else {                // Going to sleep...                // This is a good time to make transitions that we don't want the user to see,                // such as bringing the key guard to focus.  There's no guarantee for this,                // however because the user could turn the device on again at any time.                // Some things may need to be protected by other mechanisms that defer screen on.                interactiveChanged = (mActualInteractiveState != INTERACTIVE_STATE_ASLEEP);                if (interactiveChanged) {                    mActualInteractiveState = INTERACTIVE_STATE_ASLEEP;                    mPendingGoToSleepBroadcast = true;                    if (mUserActivityPending) {                        mUserActivityPending = false;                        mHandler.removeMessages(MSG_USER_ACTIVITY);                    }                    mHandler.post(new Runnable() {                        @Override                        public void run() {                            int why = WindowManagerPolicy.OFF_BECAUSE_OF_USER;                            switch (reason) {                                case PowerManager.GO_TO_SLEEP_REASON_DEVICE_ADMIN:                                    why = WindowManagerPolicy.OFF_BECAUSE_OF_ADMIN;                                    break;                                case PowerManager.GO_TO_SLEEP_REASON_TIMEOUT:                                    why = WindowManagerPolicy.OFF_BECAUSE_OF_TIMEOUT;                                    break;                            }                            EventLog.writeEvent(EventLogTags.POWER_SCREEN_STATE, 0, why, 0, 0);                            mPolicy.goingToSleep(why);//开启线程phoneWindowManager处理keyguard等                        }                    });                    updatePendingBroadcastLocked();//发送ACTION_SCREEN_OFF广播                }            }        }        // Notify battery stats.        if (interactiveChanged) {            try {                mBatteryStats.noteInteractive(interactive);//统计电池电量            } catch (RemoteException ex) { }        }    }

AMS的onWakefulnessChanged函数

    void onWakefulnessChanged(int wakefulness) {        synchronized(this) {            mWakefulness = wakefulness;            updateSleepIfNeededLocked();        }    }

AMS的updateSleepIfNeededLocked函数

    void updateSleepIfNeededLocked() {        if (mSleeping && !shouldSleepLocked()) {//唤醒            mSleeping = false;            mStackSupervisor.comeOutOfSleepIfNeededLocked();//显示activity        } else if (!mSleeping && shouldSleepLocked()) {//睡眠            mSleeping = true;            mStackSupervisor.goingToSleepLocked();//销毁LaunchingActivity等            // Initialize the wake times of all processes.            checkExcessivePowerUsageLocked(false);            mHandler.removeMessages(CHECK_EXCESSIVE_WAKE_LOCKS_MSG);            Message nmsg = mHandler.obtainMessage(CHECK_EXCESSIVE_WAKE_LOCKS_MSG);            mHandler.sendMessageDelayed(nmsg, POWER_CHECK_DELAY);        }    }

继续分析gotoSleep函数：

如果flag是直接睡眠的，就调用reallyGoToSleepNoUpdateLocked函数，将mWakefulness的状态改成WAKEFULNESS_ASLEEP。

    private boolean reallyGoToSleepNoUpdateLocked(long eventTime, int uid) {        if (DEBUG_SPEW) {            Slog.d(TAG, "reallyGoToSleepNoUpdateLocked: eventTime=" + eventTime                    + ", uid=" + uid);        }        if (eventTime < mLastWakeTime || mWakefulness == WAKEFULNESS_ASLEEP                || !mBootCompleted || !mSystemReady) {            return false;        }        Trace.traceBegin(Trace.TRACE_TAG_POWER, "reallyGoToSleep");        try {            Slog.i(TAG, "Sleeping (uid " + uid +")...");            setWakefulnessLocked(WAKEFULNESS_ASLEEP, PowerManager.GO_TO_SLEEP_REASON_TIMEOUT);        } finally {            Trace.traceEnd(Trace.TRACE_TAG_POWER);        }        return true;    }

下面我们来看下wakeup：

会调用PMS的wakeUpInternal函数：

    private void wakeUpInternal(long eventTime, int uid) {        synchronized (mLock) {            if (wakeUpNoUpdateLocked(eventTime, uid)) {                updatePowerStateLocked();            }        }    }

wakeUpNoUpdateLocked函数

    private boolean wakeUpNoUpdateLocked(long eventTime, int uid) {        if (true) {            Slog.d(TAG, "kang wakeUpNoUpdateLocked: eventTime=" + eventTime + ", uid=" + uid);        }        if (eventTime < mLastSleepTime || mWakefulness == WAKEFULNESS_AWAKE//时间不对，当前状态已经是WAKEFULNESS_AWAKE，系统没起来就直接return                || !mBootCompleted || !mSystemReady) {            return false;        }        Trace.traceBegin(Trace.TRACE_TAG_POWER, "wakeUp");        try {            switch (mWakefulness) {//打印当前的mWakefulness                case WAKEFULNESS_ASLEEP:                    Slog.i(TAG, "Waking up from sleep (uid " + uid +")...");                    //boost for quick screen on                    //boostForPerformance(2, 600);                    break;                case WAKEFULNESS_DREAMING:                    Slog.i(TAG, "Waking up from dream (uid " + uid +")...");                    break;                case WAKEFULNESS_DOZING:                    Slog.i(TAG, "Waking up from dozing (uid " + uid +")...");                    break;            }            mLastWakeTime = eventTime;//记录时间            setWakefulnessLocked(WAKEFULNESS_AWAKE, 0);//改变状态            userActivityNoUpdateLocked(//触发useractivity事件                    eventTime, PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, uid);        } finally {            Trace.traceEnd(Trace.TRACE_TAG_POWER);        }        return true;    }

下面我们来看下userActivity事件，当点击屏幕的时候，就会触发这事件：

最终到PMS的userActivityInternal

    private void userActivityInternal(long eventTime, int event, int flags, int uid) {        synchronized (mLock) {            if (userActivityNoUpdateLocked(eventTime, event, flags, uid)) {                updatePowerStateLocked();            }        }    }

userActivityNoUpdateLocked函数：

    private boolean userActivityNoUpdateLocked(long eventTime, int event, int flags, int uid) {        if (DEBUG_SPEW) {            Slog.d(TAG, "userActivityNoUpdateLocked: eventTime=" + eventTime                    + ", event=" + event + ", flags=0x" + Integer.toHexString(flags)                    + ", uid=" + uid);        }        if (eventTime < mLastSleepTime || eventTime < mLastWakeTime                || !mBootCompleted || !mSystemReady) {            return false;        }        Trace.traceBegin(Trace.TRACE_TAG_POWER, "userActivity");        try {            if (eventTime > mLastInteractivePowerHintTime) {                powerHintInternal(POWER_HINT_INTERACTION, 0);//powerHintInternal是通过JNI，底层是将cpu的频率提高等等，这里还有一个低功耗模式，在上一篇博客分析过。                mLastInteractivePowerHintTime = eventTime;//记录下时间            }            mNotifier.onUserActivity(event, uid);//通知keyguard的锁屏时间            if (mWakefulness == WAKEFULNESS_ASLEEP                    || mWakefulness == WAKEFULNESS_DOZING                    || (flags & PowerManager.USER_ACTIVITY_FLAG_INDIRECT) != 0) {                return false;            }            if ((flags & PowerManager.USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS) != 0) {//延长dim的时间，不会变亮                if (eventTime > mLastUserActivityTimeNoChangeLights                        && eventTime > mLastUserActivityTime) {                    mLastUserActivityTimeNoChangeLights = eventTime;//记录时间                    mDirty |= DIRTY_USER_ACTIVITY;                    return true;                }            } else {                if (eventTime > mLastUserActivityTime) {                    mLastUserActivityTime = eventTime;//记录时间                    mDirty |= DIRTY_USER_ACTIVITY;                    return true;                }            }        } finally {            Trace.traceEnd(Trace.TRACE_TAG_POWER);        }        return false;    }

nap事件

调用PMS的napNoUpdateLocked函数：

    private boolean napNoUpdateLocked(long eventTime, int uid) {        if (DEBUG_SPEW) {            Slog.d(TAG, "napNoUpdateLocked: eventTime=" + eventTime + ", uid=" + uid);        }        if (eventTime < mLastWakeTime || mWakefulness != WAKEFULNESS_AWAKE//当前的状态必须是醒的才有效                || !mBootCompleted || !mSystemReady) {            return false;        }        Trace.traceBegin(Trace.TRACE_TAG_POWER, "nap");        try {            Slog.i(TAG, "Nap time (uid " + uid +")...");            mSandmanSummoned = true;//这个变量和做梦有关            setWakefulnessLocked(WAKEFULNESS_DREAMING, 0);//mWakefulness置为WAKEFULNESS_DREAMING        } finally {            Trace.traceEnd(Trace.TRACE_TAG_POWER);        }        return true;    }

boostScreenBrightness就是将屏幕变到最亮，持续一段时间：

最终会调到PMS的函数boostScreenBrightnessInternal

    private void boostScreenBrightnessInternal(long eventTime, int uid) {        synchronized (mLock) {            if (!mSystemReady || mWakefulness == WAKEFULNESS_ASLEEP//状态是WAKEFULNESS_ASLEEP直接退出                    || eventTime < mLastScreenBrightnessBoostTime) {                return;            }            Slog.i(TAG, "Brightness boost activated (uid " + uid +")...");            mLastScreenBrightnessBoostTime = eventTime;//记录时间            mScreenBrightnessBoostInProgress = true;            mDirty |= DIRTY_SCREEN_BRIGHTNESS_BOOST;            userActivityNoUpdateLocked(eventTime,//触发userActivity事件                    PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, uid);            updatePowerStateLocked();        }    }

setBacklightBrightness函数

最终调奥PMS的setTemporaryScreenBrightnessSettingOverrideInternal函数

    private void setTemporaryScreenBrightnessSettingOverrideInternal(int brightness) {        synchronized (mLock) {            if (mTemporaryScreenBrightnessSettingOverride != brightness) {                mTemporaryScreenBrightnessSettingOverride = brightness;//变量值修改了下                mDirty |= DIRTY_SETTINGS;                updatePowerStateLocked();            }        }    }

isScreenOn函数：最后就调用下面这个函数，主要看是否是下面这两个状态

    public static boolean isInteractive(int wakefulness) {        return wakefulness == WAKEFULNESS_AWAKE || wakefulness == WAKEFULNESS_DREAMING;    }

setLowPowerMode和isPowerSaveMode在上一篇PMS的博客里分析过了，这里就不看了。

下篇主要分析updatePowerStateLocked函数。