首页 > 编程开发 > Android

PowerManagerService之亮屏流程示例分析

来自：网络
时间：2022-12-26
阅读：
目录

前言

亮屏的方式有很多，其中最常用的是 Power 键亮屏，这个流程比较简单，本文希望通过分析这个流程，从而理清操作屏幕的能用流程，为后面的文章打下基础。

Power键亮屏

本文以 Power 键亮屏为例进行分析，它会调用 PowerManagerService#wakeUp()

// PowerManagerService.java
@Override // Binder call
public void wakeUp(long eventTime, @WakeReason int reason, String details,
        String opPackageName) {
    // ...
    try {
        // 只能唤醒 default display group 下的显示屏
        wakeDisplayGroup(Display.DEFAULT_DISPLAY_GROUP, eventTime, reason, details, uid,
                opPackageName, uid);
    } finally {
        Binder.restoreCallingIdentity(ident);
    }
}  
private void wakeDisplayGroup(int groupId, long eventTime, @WakeReason int reason,
        String details, int uid, String opPackageName, int opUid) {
    synchronized (mLock) {
        // 1. 更新 wakefulness 为 WAKEFULNESS_AWAKE
        // 包括更新 PowerManagerService 和 DisplayGroupPowerStateMapper 的 wakefulness
        if (wakeDisplayGroupNoUpdateLocked(groupId, eventTime, reason, details, uid,
                opPackageName, opUid)) {
            // 2. 更新电源状态
            updatePowerStateLocked();
        }
    }
}

注意，PowerManagerService#wakeUp() 只能操作默认分组下的屏幕。

Android 不知何时起，对多屏幕添加了一个分组功能，手机通常只有一个屏幕，它属于默认分组。

亮屏的过程有两步

  • 更新 wakefulness 为 WAKEFULNESS_AWAKE。主要是更新 PowerManagerService 和 DisplayGroupPowerStateMapper 的 wakefulness。
  • 更新电源状态。亮屏的过程就是在这里处理的。

1. 更新 wakefulness

private boolean wakeDisplayGroupNoUpdateLocked(int groupId, long eventTime,
        @WakeReason int reason, String details, int uid, String opPackageName, int opUid) {
    // ...
    try {
        // ...
        // 设置 wakefulness 为 WAKEFULNESS_AWAKE
        setWakefulnessLocked(groupId, WAKEFULNESS_AWAKE, eventTime, uid, reason, opUid,
                opPackageName, details);
        // 更新分组显示屏的信息
        mDisplayGroupPowerStateMapper.setLastPowerOnTimeLocked(groupId, eventTime);
        mDisplayGroupPowerStateMapper.setPoweringOnLocked(groupId, true);
    } 
    return true;
}
void setWakefulnessLocked(int groupId, int wakefulness, long eventTime, int uid, int reason,
        int opUid, String opPackageName, String details) {
    // 1. 更新 DisplayGroupPowerStateMapper 的 wakefulness
    if (mDisplayGroupPowerStateMapper.setWakefulnessLocked(groupId, wakefulness)) {
        // display group wakefulness 改变了
        mDirty |= DIRTY_DISPLAY_GROUP_WAKEFULNESS;
        // 2. 更新 PMS 的 wakefulness
        // 注意第一个参数取所有 display group 的最大的 wakefulness，优先级如下
        //  PowerManagerInternal#WAKEFULNESS_AWAKE
        //  PowerManagerInternal#WAKEFULNESS_DREAMING
        //  PowerManagerInternal#WAKEFULNESS_DOZING
        //  PowerManagerInternal#WAKEFULNESS_ASLEEP
        // TODO: 为何 PMS 的 wakefulness 要设置为所有 display group 的最大的 wakefulness ?
        setGlobalWakefulnessLocked(mDisplayGroupPowerStateMapper.getGlobalWakefulnessLocked(),
                eventTime, reason, uid, opUid, opPackageName, details);
        if (wakefulness == WAKEFULNESS_AWAKE) {
            // Kick user activity to prevent newly awake group from timing out instantly.
            // 3. 保存用户行为的时间
            userActivityNoUpdateLocked(
                    groupId, eventTime, PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, uid);
        }
    }
}

更新 wakefulness 为 WAKEFULNESS_AWAKE 过程如下

  • 更新 DisplayGroupPowerStateMapper 的 wakefulness 为 WAKEFULNESS_AWAKE。
  • 更新 PMS 的 wakefulness 为 WAKEFULNESS_AWAKE。这里还会通知其它系统组件，wakefulness/交互状态 改变了。详见【1.1 更新 PMS 的 wakefulness】
  • 保存用户行为的时间。这个时间用来决定自动灭屏的时间。详见【1.2 保存用户行为时间】

1.1 更新 PMS 的 wakefulness

// PowerManagerService.java
private void setGlobalWakefulnessLocked(int wakefulness, long eventTime, int reason, int uid,
        int opUid, String opPackageName, String details) {
    if (getWakefulnessLocked() == wakefulness) {
        return;
    }
    // Phase 1: Handle pre-wakefulness change bookkeeping.
    final String traceMethodName;
    switch (wakefulness) {
        // ...
        case WAKEFULNESS_AWAKE:
            // 保存唤醒设备的时间
            // 这个时间，后面在更新用户行为的时候会用到
            mLastWakeTime = eventTime;
            mLastWakeReason = reason;
            break;
        // ...
    }
    try {
        // Phase 2: Handle wakefulness change and bookkeeping.
        // Under lock, invalidate before set ensures caches won't return stale values.
        mInjector.invalidateIsInteractiveCaches();
        // 更新 PMS 的 wakefulness 相关变量
        mWakefulnessRaw = wakefulness;
        mWakefulnessChanging = true;
        // mDirty 设置 DIRTY_WAKEFULNESS，表示 PMS 的 wakefulness 改变了
        mDirty |= DIRTY_WAKEFULNESS;
        mDozeStartInProgress &= (getWakefulnessLocked() == WAKEFULNESS_DOZING);
        // 通知其它组件，wakefulness改变 或者 交互状态改变
        if (mNotifier != null) {
            mNotifier.onWakefulnessChangeStarted(wakefulness, reason, eventTime);
        }
        mAttentionDetector.onWakefulnessChangeStarted(wakefulness);
        // Phase 3: Handle post-wakefulness change bookkeeping.
        switch (wakefulness) {
            case WAKEFULNESS_AWAKE:
                // 记录并检测是否有权限
                mNotifier.onWakeUp(reason, details, uid, opPackageName, opUid);
                if (sQuiescent) {
                    mDirty |= DIRTY_QUIESCENT;
                }
                break;
            // ...
        }
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_POWER);
    }
}

根据英文注释，更新 PMS 的 wakefulness 过程分为三个阶段，最主要的是在第二个阶段，更新 wakefulness 相关变量，然后 Notifier 通知其它组件并发送亮屏通知，过程如下，大家看一下就行，这不是重点。

// Notifier.java
public void onWakefulnessChangeStarted(final int wakefulness, int reason, long eventTime) {
    // 判断新的 wakefulness 是否是交互状态
    // WAKEFULNESS_AWAKE 是可交互状态
    final boolean interactive = PowerManagerInternal.isInteractive(wakefulness);
    // 1. 通知 AMS wakefulness 改变了
    mHandler.post(new Runnable() {
        @Override
        public void run() {
            mActivityManagerInternal.onWakefulnessChanged(wakefulness);
        }
    });
    // 2. 处理交互状态改变
    // Handle any early interactive state changes.
    // Finish pending incomplete ones from a previous cycle.
    // 处理早期交互状态改变
    if (mInteractive != interactive) {
        // Finish up late behaviors if needed.
        // mInteractiveChanging 为 true，表示上一次的处理流程还没有执行完
        // 这里会先执行上一次的流程
        if (mInteractiveChanging) {
            handleLateInteractiveChange();
        }
        // 2.1 更新系统组件的交互状态
        // Start input as soon as we start waking up or going to sleep.
        mInputManagerInternal.setInteractive(interactive);
        mInputMethodManagerInternal.setInteractive(interactive);
        // ...
        // Handle early behaviors.
        // 2.2 更新关于交互状态的变量
        mInteractive = interactive;
        mInteractiveChangeReason = reason;
        mInteractiveChangeStartTime = eventTime;
        // 交互状态正在改变
        mInteractiveChanging = true;
        // 2.3 处理早期的交互状态改变任务
        handleEarlyInteractiveChange();
    }
}
private void handleEarlyInteractiveChange() {
    synchronized (mLock) {
        if (mInteractive) {
            // 通知 PhoneWindowManager，PhoneWindowManager再通知 SystemUI keyguard
            mHandler.post(() -> mPolicy.startedWakingUp(mInteractiveChangeReason));
            // 发送亮屏广播
            mPendingInteractiveState = INTERACTIVE_STATE_AWAKE;
            mPendingWakeUpBroadcast = true;
            updatePendingBroadcastLocked();
        } else {
            // ...
        }
    }
}

1.2 保存用户行为时间

// PowerManagerService.java
private boolean userActivityNoUpdateLocked(int groupId, long eventTime, int event, int flags,
        int uid) {
    if (eventTime < mLastSleepTime || eventTime < mLastWakeTime || !mSystemReady) {
        return false;
    }
    Trace.traceBegin(Trace.TRACE_TAG_POWER, "userActivity");
    try {
        if (eventTime > mLastInteractivePowerHintTime) {
            setPowerBoostInternal(Boost.INTERACTION, 0);
            mLastInteractivePowerHintTime = eventTime;
        }
        // 1. 通知系统组件，有用户行为发生
        mNotifier.onUserActivity(event, uid);
        mAttentionDetector.onUserActivity(eventTime, event);
        if (mUserInactiveOverrideFromWindowManager) {
            mUserInactiveOverrideFromWindowManager = false;
            mOverriddenTimeout = -1;
        }
        final int wakefulness = mDisplayGroupPowerStateMapper.getWakefulnessLocked(groupId);
        if (wakefulness == WAKEFULNESS_ASLEEP
                || wakefulness == WAKEFULNESS_DOZING
                || (flags & PowerManager.USER_ACTIVITY_FLAG_INDIRECT) != 0) {
            return false;
        }
        maybeUpdateForegroundProfileLastActivityLocked(eventTime);
        if ((flags & PowerManager.USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS) != 0) {
            // 这里处理延长亮屏的时间的逻辑 ...
        } else {
            if (eventTime > mDisplayGroupPowerStateMapper.getLastUserActivityTimeLocked(
                    groupId)) {
                // 2. 保存用户活动时间
                mDisplayGroupPowerStateMapper.setLastUserActivityTimeLocked(groupId, eventTime);
                // 3. mDirty 设置 DIRTY_USER_ACTIVITY 标志位，
                // 表示用户活动有更新
                mDirty |= DIRTY_USER_ACTIVITY;
                if (event == PowerManager.USER_ACTIVITY_EVENT_BUTTON) {
                    mDirty |= DIRTY_QUIESCENT;
                }
                return true;
            }
        }
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_POWER);
    }
    return false;
}

PMS 更新用户行为的过程

  • 通过 Notifier 通知其它组件有用户行为。
  • DisplayGroupPowerStateMapper 保存用户行为的时间。这个时间会用于决定自动灭屏的时间。
  • mDirty 设置 DIRTY_USER_ACTIVITY 标志位，表示用户活动有更新，后面更新电源状态会用到。

简单看下第一步的过程，如下

    private void sendUserActivity(int event) {
        synchronized (mLock) {
            if (!mUserActivityPending) {
                return;
            }
            mUserActivityPending = false;
        }
        // 这里暂时不知道做了什么
        TelephonyManager tm = mContext.getSystemService(TelephonyManager.class);
        tm.notifyUserActivity();
        // PhoneWindowManger 会通知 SystemUI
        mPolicy.userActivity();
        // 如果 FaceDownDetector 正在执行翻转灭屏任务，此时有用户行为，取消这个任务
        mFaceDownDetector.userActivity(event);
    }

1.3 更新 wakefulness 小结

通过上面的分析，我们应该看到一个本质，更新 wakefulness 流程大致如下

  • 更新 DisplayGroupPowerStateMapper 的 wakefulness，mDirty 设置标志位 DIRTY_DISPLAY_GROUP_WAKEFULNESS。
  • 更新 PowerManagerService 的 wakefulness，mDirty 设置标志位 DIRTY_WAKEFULNESS.
  • Notifier 通知其它组件 wakefulness/交互状态 改变了，并发送亮屏/灭屏的广播。

2. 更新电源状态

// PowerManagerService.java
private void updatePowerStateLocked() {
    if (!mSystemReady || mDirty == 0) {
        return;
    }
    // 注意这里的技术，线程可以判断是否获取了某个锁
    if (!Thread.holdsLock(mLock)) {
        Slog.wtf(TAG, "Power manager lock was not held when calling updatePowerStateLocked");
    }
    Trace.traceBegin(Trace.TRACE_TAG_POWER, "updatePowerState");
    try {
        // Phase 0: Basic state updates.
        // 省电模式功能
        updateIsPoweredLocked(mDirty);
        // 设置中"充电常亮功能"
        updateStayOnLocked(mDirty);
        // 亮度增加功能
        updateScreenBrightnessBoostLocked(mDirty);
        // Phase 1: Update wakefulness.
        // Loop because the wake lock and user activity computations are influenced
        // by changes in wakefulness.
        final long now = mClock.uptimeMillis();
        int dirtyPhase2 = 0;
        for (;;) {
            int dirtyPhase1 = mDirty;
            dirtyPhase2 |= dirtyPhase1;
            mDirty = 0;
            // 把所有的唤醒锁归纳到 mWakeLockSummary
            updateWakeLockSummaryLocked(dirtyPhase1);
            // 1. 更新用户行为
            updateUserActivitySummaryLocked(now, dirtyPhase1);
            updateAttentiveStateLocked(now, dirtyPhase1);
            // 决定是否进入休眠/dream/doze状态
            // 如果进入某一种状态，会更新 wakefulness，因此这里要通过循环再来更新上面的东西
            if (!updateWakefulnessLocked(dirtyPhase1)) {
                break;
            }
        }
        // Phase 2: Lock profiles that became inactive/not kept awake.
        updateProfilesLocked(now);
        // Phase 3: Update display power state.
        // 2. 更新显示屏的电源状态
        final boolean displayBecameReady = updateDisplayPowerStateLocked(dirtyPhase2);
        // Phase 4: Update dream state (depends on display ready signal).
        updateDreamLocked(dirtyPhase2, displayBecameReady);
        // Phase 5: Send notifications, if needed.
        finishWakefulnessChangeIfNeededLocked();
        // Phase 6: Update suspend blocker.
        // Because we might release the last suspend blocker here, we need to make sure
        // we finished everything else first!
        updateSuspendBlockerLocked();
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_POWER);
    }
}

PowerManagerService 的所有功能都集中在这个函数中，但是与亮屏相关的主要有两步

  • updateUserActivitySummaryLocked() 更新用户行为。这个用户行为会决定屏幕的最终亮度。详见【2.1 更新用户行为】
  • updateDisplayPowerStateLocked() 更新显示屏的电源状态，它会对 DisplayManagerService 发起电源请求，从而决定屏幕屏的亮度。详见【2.2 更新显示屏的电源状态】

2.1 更新用户行为

// PowerManagerService.java
private void updateUserActivitySummaryLocked(long now, int dirty) {
    // Update the status of the user activity timeout timer.
    if ((dirty & (DIRTY_DISPLAY_GROUP_WAKEFULNESS | DIRTY_WAKE_LOCKS
            | DIRTY_USER_ACTIVITY | DIRTY_WAKEFULNESS | DIRTY_SETTINGS)) == 0) {
        return;
    }
    mHandler.removeMessages(MSG_USER_ACTIVITY_TIMEOUT);
    // 默认为 -1
    final long attentiveTimeout = getAttentiveTimeoutLocked();
    // 休眠超时时间，默认为 -1
    final long sleepTimeout = getSleepTimeoutLocked(attentiveTimeout);
    // 屏幕超时时间
    long screenOffTimeout = getScreenOffTimeoutLocked(sleepTimeout,
            attentiveTimeout);
    // dim duration = 20 % screen off timeout
    final long screenDimDuration = getScreenDimDurationLocked(screenOffTimeout);
    screenOffTimeout =
            getScreenOffTimeoutWithFaceDownLocked(screenOffTimeout, screenDimDuration);
    final boolean userInactiveOverride = mUserInactiveOverrideFromWindowManager;
    long nextTimeout = -1;
    boolean hasUserActivitySummary = false;
    // 遍历 display group id
    for (int groupId : mDisplayGroupPowerStateMapper.getDisplayGroupIdsLocked()) {
        int groupUserActivitySummary = 0;
        long groupNextTimeout = 0;
        // 注意，休眠状态是无法决定用户行为的
        if (mDisplayGroupPowerStateMapper.getWakefulnessLocked(groupId) != WAKEFULNESS_ASLEEP) {
            final long lastUserActivityTime =
                    mDisplayGroupPowerStateMapper.getLastUserActivityTimeLocked(groupId);
            final long lastUserActivityTimeNoChangeLights =
                    mDisplayGroupPowerStateMapper.getLastUserActivityTimeNoChangeLightsLocked(
                            groupId);
            // 1. 获取用户行为与超时时间
            // 上一次用户行为的时间 >= 上一次唤醒屏幕的时间
            if (lastUserActivityTime >= mLastWakeTime) {
                groupNextTimeout = lastUserActivityTime + screenOffTimeout - screenDimDuration;
                if (now < groupNextTimeout) { // 没有到 dim 时间
                    groupUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;
                } else {
                    groupNextTimeout = lastUserActivityTime + screenOffTimeout;
                    if (now < groupNextTimeout) { // 处于 dim 时间段
                        groupUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;
                    }
                }
            }
            // 超时了，但是由于释放了某一个锁，需要延长亮屏时间
            if (groupUserActivitySummary == 0
                    && lastUserActivityTimeNoChangeLights >= mLastWakeTime) {
                // ...
            }
            // 一般的超时情况，
            if (groupUserActivitySummary == 0) {
                // ...
            }
            // PhoneWindowManager 处理 KeyEvent.KEYCODE_SOFT_SLEEP 时，userInactiveOverride 为 true
            // KeyEvent.KEYCODE_SOFT_SLEEP 这个软件的休眠按键 ？
            if (groupUserActivitySummary != USER_ACTIVITY_SCREEN_DREAM
                    && userInactiveOverride) {
                // ...
            }
            // 用户行为是点亮屏幕，并且WakeLock没有保持屏幕常亮，用AttentionDetector再次计算屏幕超时时间
            if ((groupUserActivitySummary & USER_ACTIVITY_SCREEN_BRIGHT) != 0
                    && (mDisplayGroupPowerStateMapper.getWakeLockSummaryLocked(groupId)
                    & WAKE_LOCK_STAY_AWAKE) == 0) {
                // ...
            }
            hasUserActivitySummary |= groupUserActivitySummary != 0;
            if (nextTimeout == -1) {
                nextTimeout = groupNextTimeout;
            } else if (groupNextTimeout != -1) {
                // 这里表示 nextTimeout != -1 的情况，也说明有多个 display group 的情况
                // 从这里可以看出，多个 display group 的超时时间是相同的
                nextTimeout = Math.min(nextTimeout, groupNextTimeout);
            }
        }
        // 2. DisplayGroupPowerStateMapper 保存用户行为
        mDisplayGroupPowerStateMapper.setUserActivitySummaryLocked(groupId,
                groupUserActivitySummary);
        }
    } // 遍历 display group id 结束
    final long nextProfileTimeout = getNextProfileTimeoutLocked(now);
    if (nextProfileTimeout > 0) {
        nextTimeout = Math.min(nextTimeout, nextProfileTimeout);
    }
    // 3. 定时更新电源状态
    // 这一步决定自动灭屏
    if (hasUserActivitySummary && nextTimeout >= 0) {
        scheduleUserInactivityTimeout(nextTimeout);
    }
}

这个函数不单单是用于更新用户行为，还更新了屏幕超时时间，并且以这个时间来定时更新电源状态，以实现自动灭屏的功能。

更新用户行为在第1步，前面分析更新 wakefulness 时，PMS 保存了唤醒的时间 mLastWakeTime，以及 DisplayGroupPowerStateMapper 保存了用户行为时间。因此，对于从灭屏状态到亮屏状态这一过程来说，用户行为的值现在是 USER_ACTIVITY_SCREEN_BRIGHT，表示用户行为是亮屏。

2.2 更新显示屏的电源状态

// PowerManagerService.java
private boolean updateDisplayPowerStateLocked(int dirty) {
    final boolean oldDisplayReady = mDisplayGroupPowerStateMapper.areAllDisplaysReadyLocked();
    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 | DIRTY_VR_MODE_CHANGED |
            DIRTY_QUIESCENT | DIRTY_DISPLAY_GROUP_WAKEFULNESS)) != 0) {
        if ((dirty & DIRTY_QUIESCENT) != 0) {
            // ...
        }
        // 遍历 display group
        for (final int groupId : mDisplayGroupPowerStateMapper.getDisplayGroupIdsLocked()) {
            // 1. 获取 display group 的请求
            final DisplayPowerRequest displayPowerRequest =
                    mDisplayGroupPowerStateMapper.getPowerRequestLocked(groupId);
            // 2. 更新请求的各种参数
            // 更新请求的策略参数，所谓的策略，就是亮屏，还是灭屏，或者使屏幕变暗，等等
            displayPowerRequest.policy = getDesiredScreenPolicyLocked(groupId);
            // ...省略更新其它请求参数的过程...
            // 3. 向 DisplayManagerService 发起请求
            // 如果此次请求与上一次的请求不同，那么这个请求的处理是一个异步处理过程，此时返回 false。
            // 否则，不用处理，直接返回 true。
            final boolean ready = mDisplayManagerInternal.requestPowerState(groupId,
                    displayPowerRequest, mRequestWaitForNegativeProximity);
            // 更新 DisplayGroupPowerStateMapper 的 ready 状态
            final boolean displayReadyStateChanged =
                    mDisplayGroupPowerStateMapper.setDisplayGroupReadyLocked(groupId, ready);
            // 如果异步请求处理完毕，DMS 会回调通知 PMS，PMS 再更新状态走到这里
            // 如果点亮屏幕时间过长，那么用log记录下来
            final boolean poweringOn =
                    mDisplayGroupPowerStateMapper.isPoweringOnLocked(groupId);
            if (ready && displayReadyStateChanged && poweringOn
                    && mDisplayGroupPowerStateMapper.getWakefulnessLocked(
                    groupId) == WAKEFULNESS_AWAKE) {
                mDisplayGroupPowerStateMapper.setPoweringOnLocked(groupId, false);
                Trace.asyncTraceEnd(Trace.TRACE_TAG_POWER, TRACE_SCREEN_ON, groupId);
                final int latencyMs = (int) (mClock.uptimeMillis()
                        - mDisplayGroupPowerStateMapper.getLastPowerOnTimeLocked(groupId));
                if (latencyMs >= SCREEN_ON_LATENCY_WARNING_MS) {
                    Slog.w(TAG, "Screen on took " + latencyMs + " ms");
                }
            }
        }
        mRequestWaitForNegativeProximity = false;
    }
    // 返回值表示是否从非ready状态变为ready状态
    return mDisplayGroupPowerStateMapper.areAllDisplaysReadyLocked() && !oldDisplayReady;
}

更新屏幕电源状态的很清晰，如下

  • 首先获取请求，并更新请求参数。请求参数中，主要关心的是策略参数，它决定了屏幕的状态，也就是到底是亮屏还是灭屏。
  • 向 DisplayManagerService 发起请求。注意，如果当前的请求与上一次请求不同，那么处理过程是异步的，并且返回的 ready 状态为 false。否则，处理过程是同步的，返回的 ready 为 true。

我们来看下如何更新请求的策略

// PowerManagerService.java
 int getDesiredScreenPolicyLocked(int groupId) {
    final int wakefulness = mDisplayGroupPowerStateMapper.getWakefulnessLocked(groupId);
    final int wakeLockSummary = mDisplayGroupPowerStateMapper.getWakeLockSummaryLocked(groupId);
    if (wakefulness == WAKEFULNESS_ASLEEP || sQuiescent) {
        return DisplayPowerRequest.POLICY_OFF;
    } else if (wakefulness == WAKEFULNESS_DOZING) {
        // ...
    }
    if (mIsVrModeEnabled) {
        return DisplayPowerRequest.POLICY_VR;
    }
    // 由于此时的 UserActivity 为 USER_ACTIVITY_SCREEN_BRIGHT，因此策略为 DisplayPowerRequest.POLICY_BRIGHT
    if ((wakeLockSummary & WAKE_LOCK_SCREEN_BRIGHT) != 0
            || !mBootCompleted
            || (mDisplayGroupPowerStateMapper.getUserActivitySummaryLocked(groupId)
            & USER_ACTIVITY_SCREEN_BRIGHT) != 0
            || mScreenBrightnessBoostInProgress) {
        return DisplayPowerRequest.POLICY_BRIGHT;
    }
    return DisplayPowerRequest.POLICY_DIM;
}

我们刚才分析的用户行为是 USER_ACTIVITY_SCREEN_BRIGHT，因此策略最终为 DisplayPowerRequest.POLICY_BRIGHT。当向 DisplayManagerService 发起请求时，最终会导致屏幕点亮。

2.3 处理屏幕状态的更新

前面我们刚提到过，处理屏幕请求的过程可能是一个异步，也可能是一个同步。如果从灭屏到亮屏，这个过程一定是一个异步的，那么 PowerManagerService 是如何得知 DisplayManagerService 已经处理完成了呢？ 其实 PowerManagerService 向 DisplayManagerService 注册过回调

// PowerManagerService.java
public void systemReady(IAppOpsService appOps) {
    synchronized (mLock) {
        mDisplayManagerInternal.initPowerManagement(
                mDisplayPowerCallbacks, mHandler, sensorManager);                 
    }
}
private final DisplayManagerInternal.DisplayPowerCallbacks mDisplayPowerCallbacks =
        new DisplayManagerInternal.DisplayPowerCallbacks() {
    @Override
    public void onStateChanged() {
        synchronized (mLock) {
            // 表示屏幕状态更新了
            mDirty |= DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED;
            updatePowerStateLocked();
        }
    }
}

当 PowerManagerService 通过回调得知 DisplayManagerService 已经处理完屏幕请求，于是再次更新电源状态。

此时，updateDisplayPowerStateLocked() 再向 DisplayManagerService 发起请求，由于与上一次请求相同，因此 DisplayManagerService 不做处理，返回的 ready 状态为 true。

更新电源状态剩下的过程，就是收尾，我们大致看下

// PowerManagerService.java
private void finishWakefulnessChangeIfNeededLocked() {
    // 注意，其中一个条件就是所有 display group 要 ready
    if (mWakefulnessChanging && mDisplayGroupPowerStateMapper.areAllDisplaysReadyLocked()) {
        // ...
        // 显示屏 ready 了， PMS 的 wakefulness 改变的工作才算处理完
        mWakefulnessChanging = false;
        // Notier 通知 wakefulness 的改变已经完成
        mNotifier.onWakefulnessChangeFinished();
    }
}

// Notifier.java
public void onWakefulnessChangeFinished() {
    if (mInteractiveChanging) {
        mInteractiveChanging = false;
        // 处理交互状态的后期任务
        handleLateInteractiveChange();
    }
}
private void handleLateInteractiveChange() {
    synchronized (mLock) {
        final int interactiveChangeLatency =
                (int) (SystemClock.uptimeMillis() - mInteractiveChangeStartTime);
        if (mInteractive) {
            // Finished waking up...
            mHandler.post(() -> {
                // 通知 PhoneWindowManager 完成设备唤醒工作
                mPolicy.finishedWakingUp(mInteractiveChangeReason);
            });
        } else {
            // ...
        }
    }
}

2.4 小结

我们分析的是从灭屏到亮屏的过程，但是我们应该看到一个本质的问题，它其实就是向 DislayManagerService 发起请求，来更新屏幕状态(例如 亮屏，灭屏)。

请求的策略最终决定了屏幕在状态，但是影响请求策略的因素有很多，例如系统状态(指的是PMS的wakefulness)，用户行为，唤醒锁，等等。我们将在后面的文章中看到更多决定请求策略的情况。

总结

本文虽然分析的是从灭屏到亮屏的流程，但是我们要看到一个本质的过程，其实只有两步

  • 更新 wakefulness.
  • 向 DisplayManagerService 发起请求，更新屏幕状态。

以上就是PowerManagerService之亮屏流程示例分析的详细内容，更多关于PowerManagerService 亮屏流程的资料请关注其它相关文章！

最新文章 相关文章

adb push命令向设备传输文件的操作步骤

目录一、向设备传输文件命令二、操作步骤2.1 连接设备2.2 启动windows的cmd2.3 输入adb push指令三、总结一、向设备传输文件命令用于在windows系统下，向设备传输文件。二、

2024-06-09 01:14:15

Android自定义实现转盘菜单

目录一、前言二、绘制原理三、总结一、前言旋转菜单是一种占用空间较大，实用性稍弱的UI，一方面由于展示空间的问题，其展示的数据有限，但另一方面真由于这个原因，对用户而言趣味性

2024-06-09 01:14:12

Android使用SqLite实现登录注册功能流程详解

目录一、了解什么是Android Studio二、了解什么是sqlite三、创建项目文件四、创建活动文件和布局文件五、创建数据库连接数据库六、创建实体类实现注册功能七、实现登录功能

2024-06-09 01:14:09

Android大图监测系统的三种实现方式

目录原理解析主动监测被动监测在第三方图片加载库回调中进行大图监测在网络加载图片时进行大图监测使用ASM插桩进行大图监控注意事项与优化技巧总结原理解析内存占用计算首

2024-06-09 01:14:05

详细讲解AsyncTask使用说明(值得收藏)

目录概念类简介简单例子执行流程一、在执行完 AsyncTask.excute() 后二、方法分析源码分析一、主分支二、次分支主分支部分一、分析mWorker二、分析mFuture三、回过头来看一

2024-06-09 01:14:03

Kotlin 协程的异常处理准则

目录Kotlin 协程的异常处理概述异常处理六大准则准则一：协程的取消需要内部配合问题：cancel不被响应解决：使用 isActive 判断是否处于活跃状态准则二：不要打破协程的父子结构问

2024-06-09 01:14:00

Android 双屏异显自适应Dialog的实现

目录一、前言需求问题二、方案方案：自定义Presentation原理WindowType问题解决WindowManagerImpl 问题方案：Delagate方式：兼容总结一、前言Android 多屏互联的时代，必然会出现多

2024-06-09 01:13:57

Android实现录音监听动画的示例代码

目录一、前言二、实现方法三、全部代码四、总结一、前言在很多app种内置了语音助手，也存在各种动画，主要原因是处理2个阶段问题，第一个是监听声音的等待效果，第二个是语意解析存

2024-06-09 01:13:55

Flutter路由的几种用法小结

目录Flutter路由跳转基本路由跳转 返回上一页路由基本路由跳转传参命名路由跳转命名路由跳转需要先配置路由命名路由跳转传参命名路由替换跳转移除所有页面返回到根页面Flut

2024-06-09 01:13:52

Android图片描边效果的实现

目录前言提取蒙版蒙版绘制扩大蒙版（影子）闪烁效果总结全部代码前言先看下我们阔爱滴海绵宝宝，其原图是一张PNG图片，我们给宝宝加上描边效果，今天我们使用的是图片蒙版技术。说到

2024-06-09 01:13:50

Android EditText设置边框的操作方法

目录Android EditText设置边框简介快速开始Android EditText设置边框简介Android应用程序中给EditText设置边框。效果图：快速开始1.在res/drawable目录下新建样式文件 edit_b

2024-06-09 01:13:47

Qt6.5.3 Android环境配置的实现

目录前言安装Qt安装JDK配置环境问题解决SDK配置报错：&times; Android SDK Command-line Tools runsQt版本出现错误：无法检测 Qt 版本所使用的 ABI。安卓构建套件警告：no device

2024-06-09 01:13:44

Flutter使用stack实现悬浮UI的示例代码

目录stack特性示例stack特性在Flutter中，你可以使用Stack和Positioned来创建悬浮 UI。Stack允许你将多个小部件叠放在一起，而Positioned则用于定位小部件在Stack中的位置。示

2024-06-09 01:13:42

OkHttp原理分析小结

目录Okhttp 介绍Okhttp 中几个重要类的介绍OkHttpClientOkHttpClient使用注意OkHttpClient的创建不需要了可以关闭Call 类Request 类RequestBody总结一下OKHTTP架构图OKHttp

2024-06-09 01:13:39

Android车载空调系统（HVAC）开发方法分析

目录1. HVAC 功能介绍1.1 双区温度调节1.2 空调开关1.3 内/外循环1.4 风量调节1.5 风向调节1.6 A/C开关1.7 主副驾座椅加热1.8 除霜1.9 自动模式2. HVAC 源码结构3. HVAC 核

2024-06-09 01:13:36

基于Android实现自动滚动布局

目录前言1. 布局自动滚动的思路2. 最终效果3. 代码实现4. 总结前言在平时的开发中，有时会碰到这样的场景，设计上布局的内容会比较紧凑，导致部分机型上某些布局中的内容显示不完

2024-06-09 01:13:34

Flutter BuildContext功能使用详解

目录BuildContext 简介BuildContext的主要作用BuildContext 简介BuildContext是Flutter中的一个重要概念，表示当前Widget在树中的位置上下文。它是一个对Widget树的一个位置

2024-06-09 01:13:26

Android apk完整性检测的实现思路和代码实现

目录需求和背景实现安全管理类相关工具类需求和背景行业相关，对安全性较高的程序一般都需要添加完整性检测的功能，以防止程序被篡改，从而导致安全问题的发生。
相关的支付应用

2024-06-09 01:13:24

Android Studio开发中Gradle各种常见报错问题解决方案

目录Android开发各种Gradle错误缺少依赖项版本冲突配置错误Android开发各种Gradle错误在开发Android应用程序时，我们可能会遇到各种Gradle错误。这些错误可能来自不同的原因，

2024-06-09 01:13:22

Flutter框架实现Android拖动到垃圾桶删除效果

目录Draggable介绍构造函数参数说明使用示例DragTarget介绍构造函数参数说明使用示例DragTarget如何接收Draggable传递过来的数据结束语Draggable介绍Draggable是Flutter框

2024-06-09 01:13:20

Android 中的 XRecyclerview的使用案例

目录前言：步骤：引用库实战过程我的案例前言：我们在上一篇文章中学到了Recyclerview但是在现实中往往需求不是那么的简单，可能需要多种需求合并起来，例如常见的上下拉刷新，删除 ite

2024-06-09 01:13:18

Android滑动冲突的解决技巧

目录滑动冲突的原理解决方法外部拦截法内部拦截法注意事项和优化技巧总结滑动冲突的原理Android的事件分发机制是基于ViewGroup的。当用户在屏幕上触摸时，事件会首先传递给最

2024-06-09 01:13:16

Android自定义View实现两种二维码的扫描效果

目录背景横线效果网格效果基础属性绘制背景色绘制边框线绘制四个边角线扫描线绘制及移动特点背景最近在开发新项目时，使用了扫描二维码的功能，一般扫描二维码的效果是一条横线

2024-06-09 01:12:49

Android中的HTextView库实现TextView动画效果

目录HTextView前言HTextView的简单使用方法HTextView引入line使用以及效果fade使用以及效果typer使用以及效果rainbow使用以及效果scale使用以及效果evaporate使用以及效果f

2024-06-09 01:12:45

Android应用设置独立的多语言实战技巧详解

目录应用设置一个不同于全局的多语言系统设置中支持为应用设置单独多语言入口在哪里自动添加手动添加在应用内部设置多语言应用设置一个不同于全局的多语言通常情况下多语言

2024-06-09 01:12:43

Flutter fluro时报错type &apos;String&apos; is not a subtype of type &ap

目录报错错误原因解决方法序列化和反序列化结语报错使用fluro时报错type &lsquo;String&rsquo; is not a subtype of type &lsquo;Queue<Task>&rsquo;报错如下：错误原因在使

2024-06-09 01:12:41

Kotlin 协程 supervisorScope {} 运行崩溃解决方法

目录Kotlin 协程 supervisorScope {} 运行崩溃解决前言解决方法kotlin 协程异常处理Kotlin 协程 supervisorScope {} 运行崩溃解决前言简单介绍supervisorScope函数，它用于创

2024-06-09 01:12:38

Android ADB简介、安装及使用详解

目录一、ADB简介1、什么是adb2、为什么要用adb二、准备工具1、下载adb2、配置环境变量3、连接 4、电脑打开cmd窗口三、ADB命令详解1、基本命令2、权限命令 3、建立连接4、ap

2024-06-09 01:12:36

解决Android SELinux权限问题记录分析

目录引言解决上下文问题上下文类型引言我在恢复安卓Termux数据时遇到了权限问题，我将数据恢复到/data/data目录中，并用chown设置了正确的用户和组，但是Termux在访问时还是遇到

2024-06-09 01:12:32

Android中注解处理器APT用法示例

目录APT作用Android基本编译流程APT基本使用1、 自定义注解2、注解处理器注解处理器注解处理器注册java代码生成3. 对外调用4. 调用总结APT，Annotation Processing Tool，即注

2024-06-09 01:12:30

热点内容

Flutter项目在 iOS14 启动崩溃的解决方法
2020-09-23
Android解决getExternalStorageDirectory在29后废弃问题(推荐)
2021-02-18
Android Studio连接MySql实现登录注册(附源代码)
2021-05-16
Android串口通信apk源码详解(附完整源码)
2021-01-19
解决flutter 错误: 程序包androidx.lifecycle不存在问题
2020-10-14
Flutter 实现进度条效果
2020-05-18
解决Android调用系统分享给微信,出现分享失败,分享多文件必须为图片格式的问题
2020-10-14
Android Tablayout 自定义Tab布局的使用案例
2020-10-14
Android studio listview实现列表数据显示 数据循环显示效果
2020-10-14
关于android studio升级4.1 某些插件使用不了的问题(Mac)
2020-10-23
返回顶部
顶部