前语

PowerManagerService之亮屏流程剖析 归纳了亮屏/灭屏的通用流程,PowerManagerService之手动灭屏 对手动灭屏流程进行了整体的剖析。 本文以前两篇文章为基础,来剖析主动灭屏,请读者必须仔细阅读前两篇文章。

主动灭屏

要想剖析主动灭屏,需得回顾下 PowerManagerService之亮屏流程剖析 的亮屏逻辑的一些细节。

在亮屏的时候,会保存亮屏的时刻,以及用户行为的时刻,这两个时刻用于决议用户行为,如下

// PowerManagerService.java
private void updateUserActivitySummaryLocked(long now, int dirty) {
    // ...
    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);
            // mLastWakeTime 表明前次亮屏的时刻
            // lastUserActivityTime 表明前次用户行为的时刻
            if (lastUserActivityTime >= mLastWakeTime) {
                // 核算使屏幕变暗的超时时刻
                groupNextTimeout = lastUserActivityTime + screenOffTimeout - screenDimDuration;
                if (now < groupNextTimeout) {
                    groupUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;
                } else {
                    // ...
                }
            }
            // ...
    }
    // ...
}

此刻得到的用户行为是 USER_ACTIVITY_SCREEN_BRIGHT,表明用户行为是要点亮屏幕。

之后会向 DisplayManagerService 建议恳求,而终究决议屏幕状况(亮、灭、暗,等等)的恳求战略,它的更新进程如下

int getDesiredScreenPolicyLocked(int groupId) {
    final int wakefulness = mDisplayGroupPowerStateMapper.getWakefulnessLocked(groupId);
    final int wakeLockSummary = mDisplayGroupPowerStateMapper.getWakeLockSummaryLocked(groupId);
    if (wakefulness == WAKEFULNESS_ASLEEP || sQuiescent) {
        // ...
    } else if (wakefulness == WAKEFULNESS_DOZING) {
        // ...
    }
    if (mIsVrModeEnabled) {
        // ...
    }
    if ((wakeLockSummary & WAKE_LOCK_SCREEN_BRIGHT) != 0
            || !mBootCompleted
            || (mDisplayGroupPowerStateMapper.getUserActivitySummaryLocked(groupId)
            & USER_ACTIVITY_SCREEN_BRIGHT) != 0
            || mScreenBrightnessBoostInProgress) {
        return DisplayPowerRequest.POLICY_BRIGHT;
    }
    // ...
}

由于用户行为是 USER_ACTIVITY_SCREEN_BRIGHT,因而战略为 DisplayPowerRequest.POLICY_BRIGHT,它终究导致屏幕变亮。

那么亮屏后,是怎么主动灭屏呢?

// PowerManagerService.java
private void updateUserActivitySummaryLocked(long now, int dirty) {
    // ...
    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);
            if (lastUserActivityTime >= mLastWakeTime) {
                // 使屏幕变暗的超时时刻
                groupNextTimeout = lastUserActivityTime + screenOffTimeout - screenDimDuration;
                if (now < groupNextTimeout) {
                    groupUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;
                } else {
                    // ...
                }
            }
            // ...
    }
    // 运用屏幕变暗的超时时刻,发送一个守时音讯来更新用户行为
    if (hasUserActivitySummary && nextTimeout >= 0) {
        scheduleUserInactivityTimeout(nextTimeout);
    }
}
private void scheduleUserInactivityTimeout(long timeMs) {
    final Message msg = mHandler.obtainMessage(MSG_USER_ACTIVITY_TIMEOUT);
    msg.setAsynchronous(true);
    // 使用超时时刻,发送一个守时音讯,更新用户行为
    // 终究调用 handleUserActivityTimeout
    mHandler.sendMessageAtTime(msg, timeMs);
}
private void handleUserActivityTimeout() { // runs on handler thread
    synchronized (mLock) {
        // 标记用户行为需求更新
        mDirty |= DIRTY_USER_ACTIVITY;
        // 从头更新电源状况,其实便是为了更新用户行为
        updatePowerStateLocked();
    }
}

从上面的代码逻辑能够看出,当 Power 键亮屏后,会核算出使屏幕变暗的超时时刻,然后使用这个超时时刻,发送了一个守时音讯,当屏幕变暗的超时时刻到了,就会再次更新用户行为,如下

// PowerManagerService.java
private void updateUserActivitySummaryLocked(long now, int dirty) {
    // ...
    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);
            if (lastUserActivityTime >= mLastWakeTime) {
                groupNextTimeout = lastUserActivityTime + screenOffTimeout - screenDimDuration;
                if (now < groupNextTimeout) {
                    // ...
                } else {
                    // 核算灭屏的超时时刻
                    groupNextTimeout = lastUserActivityTime + screenOffTimeout;
                    if (now < groupNextTimeout) { // 进入 DIM 时刻段
                        // 更新用户行为
                        groupUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;
                    }
                }
            }
            // ...
    }
    // ...
    // 运用灭屏的超时时刻,发送一个守时音讯来更新用户行为
    if (hasUserActivitySummary && nextTimeout >= 0) {
        scheduleUserInactivityTimeout(nextTimeout);
    }    
}

此次用户行为的更新,核算的是灭屏的超时时刻,然后用户行为更新为 USER_ACTIVITY_SCREEN_DIM,表明用户行为要使屏幕变暗。终究使用灭屏的超时时刻,发送了一个守时音讯来再次更新用户行为。

现在用户行为是使屏幕变暗,再看看恳求战略是怎么更新的

int getDesiredScreenPolicyLocked(int groupId) {
    final int wakefulness = mDisplayGroupPowerStateMapper.getWakefulnessLocked(groupId);
    final int wakeLockSummary = mDisplayGroupPowerStateMapper.getWakeLockSummaryLocked(groupId);
    if (wakefulness == WAKEFULNESS_ASLEEP || sQuiescent) {
        // ...
    } else if (wakefulness == WAKEFULNESS_DOZING) {
        // ...
    }
    if (mIsVrModeEnabled) {
        // ...
    }
    if ((wakeLockSummary & WAKE_LOCK_SCREEN_BRIGHT) != 0
            || !mBootCompleted
            || (mDisplayGroupPowerStateMapper.getUserActivitySummaryLocked(groupId)
            & USER_ACTIVITY_SCREEN_BRIGHT) != 0
            || mScreenBrightnessBoostInProgress) {
        // ...
    }
    return DisplayPowerRequest.POLICY_DIM;
}

恳求战略更新为 DisplayPowerRequest.POLICY_DIM,终究它会使屏幕变暗。

当灭屏的超时时刻到了,咱们看下再次更新用户行为时,会产生什么

// PowerManagerService.java
private void updateUserActivitySummaryLocked(long now, int dirty) {
    // ...
    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);
            if (lastUserActivityTime >= mLastWakeTime) {
                groupNextTimeout = lastUserActivityTime + screenOffTimeout - screenDimDuration;
                if (now < groupNextTimeout) {
                    groupUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;
                } else {
                    groupNextTimeout = lastUserActivityTime + screenOffTimeout;
                    if (now < groupNextTimeout) {
                        groupUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;
                    }
                }
            }
            // 灭屏超时前,带有 PowerManager.ON_AFTER_RELEASE 这个flag的唤醒锁开释,延伸屏幕的亮/暗的时刻
            if (groupUserActivitySummary == 0
                    && lastUserActivityTimeNoChangeLights >= mLastWakeTime) {
                // ...
            }
            // 灭屏超时,答应进入屏保
            if (groupUserActivitySummary == 0) {
                // ...
            }
            // 按键 KeyEvent.KEYCODE_SOFT_SLEEP 进入屏保
            if (groupUserActivitySummary != USER_ACTIVITY_SCREEN_DREAM
                    && userInactiveOverride) {
                // ...
            }
            // 用 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 = Math.min(nextTimeout, groupNextTimeout);
            }
        }
        // DisplayGroupPowerStateMapper 保存用户行为
        mDisplayGroupPowerStateMapper.setUserActivitySummaryLocked(groupId,
                groupUserActivitySummary);
    }
    final long nextProfileTimeout = getNextProfileTimeoutLocked(now);
    if (nextProfileTimeout > 0) {
        nextTimeout = Math.min(nextTimeout, nextProfileTimeout);
    }
    // 使用超时时刻,发送一个守时音讯
    if (hasUserActivitySummary && nextTimeout >= 0) {
        scheduleUserInactivityTimeout(nextTimeout);
    }
}

能够看到灭屏超时时刻到了时,有许多要素会再次影响用户行为和超时时刻,咱们疏忽这些要素,因而超时时刻和用户行为都为0。 已然没有了用户行为和超时时刻,那么天然不会发送守时音讯来更新用户行为了,由于立刻就要灭屏的嘛,就没必要去守时更新用户行为了。

此刻,我要提醒咱们,从亮屏到主动灭屏的进程中,此刻 wakefulness 仍是 WAKEFULNESS_AWAKE,现在立刻要灭屏了,因而需求再次更新 wakefulness,这便是更新电源状况进程中,updateWakefulnessLocked() 做的

// PowerManagerService.java
private boolean updateWakefulnessLocked(int dirty) {
    boolean changed = false;
    if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY | DIRTY_BOOT_COMPLETED
            | DIRTY_WAKEFULNESS | DIRTY_STAY_ON | DIRTY_PROXIMITY_POSITIVE
            | DIRTY_DOCK_STATE | DIRTY_ATTENTIVE | DIRTY_SETTINGS
            | DIRTY_SCREEN_BRIGHTNESS_BOOST)) != 0) {
        final long time = mClock.uptimeMillis();
        for (int id : mDisplayGroupPowerStateMapper.getDisplayGroupIdsLocked()) {
            if (mDisplayGroupPowerStateMapper.getWakefulnessLocked(id) == WAKEFULNESS_AWAKE
                    && isItBedTimeYetLocked(id)) {
                if (isAttentiveTimeoutExpired(id, time)) {
                    // ... 不考虑 attentive timeout,大部分项目不支持 ...
                } else if (shouldNapAtBedTimeLocked()) {
                    // ... 假如敞开了屏保,屏幕超时也会进入屏保 ...
                } else {
                    // 更新 wakefulness 为 WAKEFULNESS_DOZING
                    changed = sleepDisplayGroupNoUpdateLocked(id, time,
                            PowerManager.GO_TO_SLEEP_REASON_TIMEOUT, 0, Process.SYSTEM_UID);
                }
            }
        }
    }
    return changed;
}
private boolean isItBedTimeYetLocked(int groupId) {
    if (!mBootCompleted) {
        return false;
    }
    long now = mClock.uptimeMillis();
    // 不考虑 attentive timeout,大部分项目不支持
    if (isAttentiveTimeoutExpired(groupId, now)) {
        return !isBeingKeptFromInattentiveSleepLocked(groupId);
    } else {
        return !isBeingKeptAwakeLocked(groupId);
    }
}
private boolean isBeingKeptAwakeLocked(int groupId) {
    return mStayOn // 开发者模式中是否翻开"充电常亮"功用
            || mProximityPositive // 是否间隔传感器坚持亮屏
            || (mDisplayGroupPowerStateMapper.getWakeLockSummaryLocked(groupId)
            & WAKE_LOCK_STAY_AWAKE) != 0 // 是否有唤醒锁坚持亮屏
            || (mDisplayGroupPowerStateMapper.getUserActivitySummaryLocked(groupId) & (
            USER_ACTIVITY_SCREEN_BRIGHT | USER_ACTIVITY_SCREEN_DIM)) != 0 // 是否有亮屏的用户行为
            || mScreenBrightnessBoostInProgress; // 屏幕是否在亮度增强的进程中
}

现在要进入灭屏,只要没有要素坚持屏幕长亮,那么就会更新 wakefulness 为 WAKEFULNESS_DOZING。

现在设备进入了打盹状况,打盹状况的流程不便是 PowerManagerService之手动灭屏 剖析过了吗? 假如设备进入打盹状况,而且能成功启动 doze dream,就会真实进入打盹状况,不然进入休眠状况。无论是设备进入打盹状况,仍是休眠状况,屏幕终究会灭。

主动灭屏小结

主动灭屏的原理便是使用核算出的超时时刻,发送一个守时音讯来更新用户行为,必要时更新 wakefulness,也便是更新体系状况,然后改变恳求的战略,终究改变了屏幕的状况(亮、灭、暗,等等)。

延伸亮屏时刻

现在咱们讨论一个与主动灭屏有关的论题,那便是延伸亮屏时刻

    private void updateUserActivitySummaryLocked(long now, int dirty) {
        // ...
        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. 主动灭屏前,用户接触TP,会导致用户行为时刻更新,然后延伸亮屏时刻
                if (lastUserActivityTime >= mLastWakeTime) {
                    groupNextTimeout = lastUserActivityTime + screenOffTimeout - screenDimDuration;
                    if (now < groupNextTimeout) {
                        groupUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;
                    } else {
                        groupNextTimeout = lastUserActivityTime + screenOffTimeout;
                        if (now < groupNextTimeout) {
                            groupUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;
                        }
                    }
                }
                // 2. 假如有更新用户行为时带有  PowerManager.USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS,那么也会延伸亮屏
                if (groupUserActivitySummary == 0
                        && lastUserActivityTimeNoChangeLights >= mLastWakeTime) {
                    // 依据  lastUserActivityTimeNoChangeLights 时刻点从头核算灭屏时刻
                    groupNextTimeout = lastUserActivityTimeNoChangeLights + screenOffTimeout;
                    if (now < groupNextTimeout) {
                        final DisplayPowerRequest displayPowerRequest =
                                mDisplayGroupPowerStateMapper.getPowerRequestLocked(groupId);
                        if (displayPowerRequest.policy == DisplayPowerRequest.POLICY_BRIGHT
                                || displayPowerRequest.policy == DisplayPowerRequest.POLICY_VR) {
                            // 理论上讲,屏幕超时,屏幕会先变暗,但是这儿处理的为何是亮屏的恳求战略
                            // 这是由于,假如没有暗屏的时刻呢?
                            groupUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;
                        } else if (displayPowerRequest.policy == DisplayPowerRequest.POLICY_DIM) {
                            groupUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;
                        }
                    }
                }
            }
            mDisplayGroupPowerStateMapper.setUserActivitySummaryLocked(groupId,
                    groupUserActivitySummary);
        }
        // ...
        if (hasUserActivitySummary && nextTimeout >= 0) {
            scheduleUserInactivityTimeout(nextTimeout);
        }
    }

能够看到,有两种状况能够延伸亮屏的时刻

  • 屏幕处于亮/暗时,假如用户接触TP,那么会更新更新用户行为时刻,然后导致延伸亮屏的时刻。特别地,假如屏幕处于暗屏状况,那么点击接触屏,会导致屏幕变亮。
  • 假如有更新用户行为时带有 PowerManager.USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS,那么也会延伸亮屏。

本文剖析用户接触TP导致的延伸亮屏进程,别的一个请读者自行剖析。

当用户接触TP时,底层Input体系会经过JNI调用 PowerManagerService#userActivityFromNative()

// frameworks/base/services/core/jni/com_android_server_input_InputManagerService.cpp
void NativeInputManager::pokeUserActivity(nsecs_t eventTime, int32_t eventType) {
    android_server_PowerManagerService_userActivity(eventTime, eventType);
}
// frameworks/base/services/core/jni/com_android_server_power_PowerManagerService.cpp
void android_server_PowerManagerService_userActivity(nsecs_t eventTime, int32_t eventType) {
    if (gPowerManagerServiceObj) {
        // 调用 Java 层的 PowerManagerService#userActivityFromNative()
        env->CallVoidMethod(gPowerManagerServiceObj,
                gPowerManagerServiceClassInfo.userActivityFromNative,
                nanoseconds_to_milliseconds(eventTime), eventType, 0);
    }
}
// PowerManagerService.java
private void userActivityFromNative(long eventTime, int event, int displayId, int flags) {
    userActivityInternal(displayId, eventTime, event, flags, Process.SYSTEM_UID);
}
private void userActivityInternal(int displayId, long eventTime, int event, int flags,
        int uid) {
    synchronized (mLock) {
        // ...
        // 更新用户活动时刻
        if (userActivityNoUpdateLocked(groupId, eventTime, event, flags, uid)) {
            // 更新电源状况
            updatePowerStateLocked();
        }
    }
}

原来用户接触TP,会更新用户行为的时刻,那么用户行为也会产生改变

private void updateUserActivitySummaryLocked(long now, int dirty) {
    // ...
    // 先移除更新用户行为的守时音讯
    mHandler.removeMessages(MSG_USER_ACTIVITY_TIMEOUT);
    // ...
    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);
            // 用户接触TP,更新了用户行为时刻 lastUserActivityTime,因而这儿从头核算超时时刻
            // 也便是说,延伸了亮屏的时刻
            if (lastUserActivityTime >= mLastWakeTime) {
                // 从头核算暗屏的超时时刻
                groupNextTimeout = lastUserActivityTime + screenOffTimeout - screenDimDuration;
                if (now < groupNextTimeout) {
                    // 用户行为是亮屏
                    groupUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;
                } else {
                    // ...
                }
            }
    }
    // ...
    // 再次发送守时音讯,更新用户行为
    if (hasUserActivitySummary && nextTimeout >= 0) {
        scheduleUserInactivityTimeout(nextTimeout);
    }        
}

由于用户行为时刻的更新,导致从头核算了暗屏的超时时刻,而且用户行为会更新为 USER_ACTIVITY_SCREEN_BRIGHT。

用户行为的更新,也导致了恳求战略的更新,如下

int getDesiredScreenPolicyLocked(int groupId) {
    final int wakefulness = mDisplayGroupPowerStateMapper.getWakefulnessLocked(groupId);
    final int wakeLockSummary = mDisplayGroupPowerStateMapper.getWakeLockSummaryLocked(groupId);
    if (wakefulness == WAKEFULNESS_ASLEEP || sQuiescent) {
        // ...
    } else if (wakefulness == WAKEFULNESS_DOZING) {
        // ...
    }
    if (mIsVrModeEnabled) {
        // ...
    }
    if ((wakeLockSummary & WAKE_LOCK_SCREEN_BRIGHT) != 0
            || !mBootCompleted
            || (mDisplayGroupPowerStateMapper.getUserActivitySummaryLocked(groupId)
            & USER_ACTIVITY_SCREEN_BRIGHT) != 0
            || mScreenBrightnessBoostInProgress) {
        return DisplayPowerRequest.POLICY_BRIGHT;
    }
    // ...
}

能够看到,假如屏幕处于亮/暗状况,用户接触TP,恳求战略更新为 DisplayPowerRequest.POLICY_BRIGHT, 终究导致屏幕为亮屏状况。

别的,从头核算出的暗屏超时时刻,会被用来发送守时音讯来更新用户行为,因而就相当于重置了屏幕超时时刻。

因而,接触TP导致屏幕处于亮屏状况,而且重置了屏幕超时时刻,那么就相当于延伸了亮屏的时刻。

结束

假如明白了亮屏与灭屏的进程,主动灭屏的原理就没有那么复杂,假如读者在阅读本文时,发现许多东西讲的很简单,那是由于前面的文章已经剖析过,所以读者必须仔细阅读前面两篇文章。

以现在的三篇文章为根基,下一篇文章,咱们将讨论 PowerManagerService 的终究一个论题,唤醒锁。