本文基于Android 11.0源码分析
1.概述
在分析PMS灭屏流程和亮屏流程时，侧重于PMS部分的流程，DMS中涉及到的流程没有进行分析，只说到请求DMS去设置屏幕亮度和Display状态就略过了。
在DMS模块分析中，会将侧重点放在Display相关的流程上，这篇文章中将会对亮灭屏过程中PMS向DMS发起请求后的流程做详细分析，从而了解设置亮度、Display状态的整个逻辑。
在DMS模块中，和PMS交互的工作由DisplayPowerController进行处理，如控制屏幕亮度、Display状态、PSensor的灭屏。DisplayPowerController属于DMS模块，但它当中的核心逻辑是运行在PMS线程的，保证了和PMS的独立性。它和PMS不共享任何状态，PMS向DMS发起请求，DisplayPowerController接收请求，并在请求处理完毕后，通过回调的方式通知PMS完成改变。
DisplayPowerController对象是在PMS启动过程中进行创建：
// frameworks/base/services/core/java/com/android/server/power/PowerManagerService.java
public void systemReady(IAppOpsService appOps) {
......
// Initialize display power management.
mDisplayManagerInternal.initPowerManagement(
mDisplayPowerCallbacks, mHandler, sensorManager);
......
}
DMS中在Local Service中进行创建：
// frameworks/base/services/core/java/com/android/server/display/DisplayManagerService.java
@Override
public void initPowerManagement(final DisplayPowerCallbacks callbacks, Handler handler,
SensorManager sensorManager) {
synchronized (mSyncRoot) {
DisplayBlanker blanker = new DisplayBlanker() {
......
// 创建DisplayPowerController对象
mDisplayPowerController = new DisplayPowerController(
mContext, callbacks, handler, sensorManager, blanker,
mDisplayDevices.get(Display.DEFAULT_DISPLAY));
mSensorManager = sensorManager;
}
mHandler.sendEmptyMessage(MSG_LOAD_BRIGHTNESS_CONFIGURATION);
}
DisplayPowerController在控制状态和亮度的设置时，主要通过另外两个类对象：
-
DisplayPowerState：代表当前Display整体状态，状态和亮度的更新都会交给它，让它做进一步处理；
-
LocalDisplayAdapter：代表默认屏幕的适配器，DisplayPowerState会将Display状态和亮度交给它，由它将状态和亮度设置给连接的物理屏。
下面继续从亮灭屏流程开始。
2.requestPowerState()发起请求
PMS中调用updateDisplayPowerStateLocked()方法请求Display进行更新，这个方法最终调用DisplayPowerController#requesetPowerState()方法：
// frameworks/base/services/core/java/com/android/server/display/DisplayPowerController.java
/**
* @param request PMS中封装的请求参数
* @param waitForNegativeProximity和Proximity wakelock释放后PSensor锁的动作有关
* @return true表示请求处理完成，false表示请求没有处理完成
*/
public boolean requestPowerState(DisplayPowerRequest request,
boolean waitForNegativeProximity) {
synchronized (mLock) {
boolean changed = false;
// 是否在PSensor WakeLock锁释放后，延迟解除Psensor监听
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;
}
// 表示需要处理新请求，先给PMS返回false，表示没有完成
if (changed) {
mDisplayReadyLocked = false;
}
// 开始处理新请求
if (changed && !mPendingRequestChangedLocked) {
// 表示request发生变化，即将更新全局request
mPendingRequestChangedLocked = true;
sendUpdatePowerStateLocked();
}
return mDisplayReadyLocked;
}
}
以上方法中，能否将此次请求作为一个新请求处理，由以下三个条件确定：
-
waitForNegativeProximity是否为true；
-
如果开机第一次进入该函数，则mPendingRequestLocked的值为null，则实例化代表将要请求的DisplayPowerRequest对象；
-
本次请求对象和上次请求对象是否相同。
如果waitForNegativeProximity为true，则表示在释放PROXIMITY_SCREEN_OFF_WAKE_LOCK类型WakeLock时，如果PSenor上报靠近事件而处于灭屏状态，那么必须等待PSensor上报远离事件并亮屏后，才会解除对PSensor的监听。在释放wakelock时使用PowerManager.RELEASE_FLAG_WAIT_FOR_NO_PROXIMITY的标记时，该值为true。
可以尝试下，申请PROXIMITY_SCREEN_OFF_WAKE_LOCK锁后，在遮挡灭屏情况下，分别用release()和release(RELEASE_FLAG_WAIT_FOR_NO_PROXIMITY)释放锁，会看到不一样的效果。
mPendingRequestChangedLocked变量用于表示上次请求已经处理完毕。DisplayPowerRequest对象代表一个请求对象，封装了许多的请求参数：
// frameworks/base/core/java/android/hardware/display/DisplayManagerInternal.java
public static final class DisplayPowerRequest {
public int policy; // 请求的Display状态
public boolean useProximitySensor; // 是否持有PROXIMITY_SCREEN_OFF_WAKE_LOCK锁
public int screenBrightnessOverride; // 是否要覆盖亮度，尤其是来自WindowMananger的亮度
public boolean useAutoBrightness; // 是否使用自动亮度
public boolean lowPowerMode; // 是否进入了低电量模式
public float screenLowPowerBrightnessFactor; // 低电量模式下调整亮度因子
public boolean boostScreenBrightness; // 是否使用了亮度增强
public int dozeScreenBrightness; // 进入Doze状态后的屏幕亮度
public int dozeScreenState; // 进入Doze状态后的Display状态
之后将在sendUpdatePowerStateLocked()方法中，通过Handler进入到PMS线程中开始处理请求：
private void sendUpdatePowerStateLocked() {
if (!mPendingUpdatePowerStateLocked) {
// 表示需要更新power state
mPendingUpdatePowerStateLocked = true;
Message msg = mHandler.obtainMessage(MSG_UPDATE_POWER_STATE);
mHandler.sendMessage(msg);
}
}
之后将进入updatePowerState()方法中，这个方法是DisplayPowerController中的核心方法，对请求的解析和处理就是它来完成。
3.updatePowerState()更新状态
updatePowerState()方法非常庞大，处理亮灭屏、调节亮度、Display状态的更新，都会在这里进行处理。该方法的完整代码如下：
// frameworks/base/services/core/java/com/android/server/display/DisplayPowerController.java
private void updatePowerState() {
// Update the power state request.
final boolean mustNotify; // 是否要通知PMS完成请求处理
final int previousPolicy;
boolean mustInitialize = false; //是否要进行初始化
int brightnessAdjustmentFlags = 0; // 自动亮度调整因子标记
mBrightnessReasonTemp.set(null); // 记录亮度变化原因
// ####################################################Part 1####################################################
synchronized (mLock) {
mPendingUpdatePowerStateLocked = false;// 代表"即将开始更新"，这里已经开始了，所以重置为true
if (mPendingRequestLocked == null) {
return; // wait until first actual power request
}
if (mPowerRequest == null) {// 只有系统开机后第一次会进入该if代码块
mPowerRequest = new DisplayPowerRequest(mPendingRequestLocked);
mWaitingForNegativeProximity = mPendingWaitForNegativeProximityLocked;
mPendingWaitForNegativeProximityLocked = false;
mPendingRequestChangedLocked = false;
mustInitialize = true;
previousPolicy = DisplayPowerRequest.POLICY_BRIGHT;
} else if (mPendingRequestChangedLocked) {// 更新全局DisplayPowerRequest
previousPolicy = mPowerRequest.policy;
mPowerRequest.copyFrom(mPendingRequestLocked);// 更新mPowerRequest
mWaitingForNegativeProximity |= mPendingWaitForNegativeProximityLocked;
mPendingWaitForNegativeProximityLocked = false;
mPendingRequestChangedLocked = false; // 重置
mDisplayReadyLocked = false;
} else {
previousPolicy = mPowerRequest.policy;
}
mustNotify = !mDisplayReadyLocked;
}
if (mustInitialize) {
initialize(); //初始化亮灭屏动画、DisplayPowerState对象...
}
// ####################################################Part 2####################################################
int state;
float brightnessState = PowerManager.BRIGHTNESS_INVALID_FLOAT;
boolean performScreenOffTransition = false; // 是否执行灭屏动画
switch (mPowerRequest.policy) { // 将根据policy确定Display要设置的状态
case DisplayPowerRequest.POLICY_OFF:// policy为off，会将Display状态设置为OFF
state = Display.STATE_OFF;
performScreenOffTransition = true;
break;
case DisplayPowerRequest.POLICY_DOZE: // policy为doze，则会根据mPowerRequest.dozeScreenState确定Display的状态，默认为DOZE状态
if (mPowerRequest.dozeScreenState != Display.STATE_UNKNOWN) {
state = mPowerRequest.dozeScreenState;
} else {
state = Display.STATE_DOZE;
}
if (!mAllowAutoBrightnessWhileDozingConfig) {// 是否支持在Doze状态时使用自动亮度，默认false
brightnessState = mPowerRequest.dozeScreenBrightness;// 将亮度设置为PMS中指定的Doze状态亮度
mBrightnessReasonTemp.setReason(BrightnessReason.REASON_DOZE);// 记录亮度变化原因——doze状态的亮度
}
break;
case DisplayPowerRequest.POLICY_VR: // policy为VR时，设置Display状态为VR
state = Display.STATE_VR;
break;
case DisplayPowerRequest.POLICY_DIM: // policy为DIM或者BRIGHT时，都表示亮屏，所以将Display状态设置为ON
case DisplayPowerRequest.POLICY_BRIGHT:
default:
state = Display.STATE_ON;
break;
}
assert(state != Display.STATE_UNKNOWN);
// #################################################### Part 3 ####################################################
if (mProximitySensor != null) {
// 如果持有Proximity WakeLock锁，且请求Display状态不为OFF
if (mPowerRequest.useProximitySensor && state != Display.STATE_OFF) {
// 注册PSensor监听
setProximitySensorEnabled(true);
// 上报了靠近事件
if (!mScreenOffBecauseOfProximity
&& mProximity == PROXIMITY_POSITIVE) {
// 代表“是否由于PSensor收到靠近时间而灭屏”
mScreenOffBecauseOfProximity = true;
// 回调通知PMS PSensor收到靠近事件
sendOnProximityPositiveWithWakelock();
}
// 如果释放Proximity WakeLock锁时带有1标记，发现由于PSensor灭屏且还未收到远离事件，则继续等待，并保持PSensor监听
} else if (mWaitingForNegativeProximity
&& mScreenOffBecauseOfProximity
&& mProximity == PROXIMITY_POSITIVE
&& state != Display.STATE_OFF) {
setProximitySensorEnabled(true);
} else {
// 在灭屏时或者释放Proximity WakeLock锁后，解除PSensor监听
setProximitySensorEnabled(false);
mWaitingForNegativeProximity = false;
}
// 收到远离事件后，重置mScreenOffBecauseOfProximity
if (mScreenOffBecauseOfProximity
&& mProximity != PROXIMITY_POSITIVE) {
mScreenOffBecauseOfProximity = false;
// 通知PMS PSensor收到远离事件
sendOnProximityNegativeWithWakelock();
}
} else {
// 说明PSensor不可用，那下慢这个值也没用，直接置为false
mWaitingForNegativeProximity = false;
}
// 如果PSensor收到上报靠近时间了，需要灭屏，于是将Display状态设置为OFF
if (mScreenOffBecauseOfProximity) {
state = Display.STATE_OFF;
}
// #################################################### Part 4 ####################################################
final int oldState = mPowerState.getScreenState();
// 设置Display状态
animateScreenStateChange(state, performScreenOffTransition);
state = mPowerState.getScreenState();
// #################################################### Part 5 ####################################################
// 如果Display状态设置为OFF，说明要灭屏，则将亮度设置为-1.0f
if (state == Display.STATE_OFF) {
brightnessState = PowerManager.BRIGHTNESS_OFF_FLOAT;
// 记录亮度变化原因
mBrightnessReasonTemp.setReason(BrightnessReason.REASON_SCREEN_OFF);
}
// 如果Display状态设置为VR，不常用
if (state == Display.STATE_VR) {
brightnessState = mScreenBrightnessForVr;
mBrightnessReasonTemp.setReason(BrightnessReason.REASON_VR);
}
// 使用PMS中的亮度覆盖，来自WindowManager如视频界面的亮度
if ((Float.isNaN(brightnessState))
&& isValidBrightnessValue(mPowerRequest.screenBrightnessOverride)) {
brightnessState = mPowerRequest.screenBrightnessOverride;
// 记录亮度变化原因
mBrightnessReasonTemp.setReason(BrightnessReason.REASON_OVERRIDE);
// 表示使用了覆盖亮度
mAppliedScreenBrightnessOverride = true;
} else {
mAppliedScreenBrightnessOverride = false;
}
// 判断是否在Doze状态下使用自动亮度，一般为false
final boolean autoBrightnessEnabledInDoze =
mAllowAutoBrightnessWhileDozingConfig && Display.isDozeState(state);
// 判断自动亮度是否可用： 开始了自动亮度&亮屏状态&未使用前几类亮度&配置了自动亮度曲线映射
final boolean autoBrightnessEnabled = mPowerRequest.useAutoBrightness
&& (state == Display.STATE_ON || autoBrightnessEnabledInDoze)
&& Float.isNaN(brightnessState)
&& mAutomaticBrightnessController != null;
// 用来更新用户状态栏、设置中手动设置的亮度值的状态，如果用户设置亮度发生变化，返回true
final boolean userSetBrightnessChanged = updateUserSetScreenBrightness();
// 该亮度表示用户拖动亮度条调节且未放手时的亮度，所以是一个"临时"亮度，如果存在这个值，则必须使用这个值
if (isValidBrightnessValue(mTemporaryScreenBrightness)) {
brightnessState = mTemporaryScreenBrightness;
// 表示使用了临时用户亮度
mAppliedTemporaryBrightness = true;
mBrightnessReasonTemp.setReason(BrightnessReason.REASON_TEMPORARY);
} else {
mAppliedTemporaryBrightness = false;
}
// 更新自动亮度曲线调整值，如果调整值发生变化，返回true
final boolean autoBrightnessAdjustmentChanged = updateAutoBrightnessAdjustment();
// 由于发生变化已经更新到全局变量上，所以不需要"临时"自动变量调整值，重置
if (autoBrightnessAdjustmentChanged) {
mTemporaryAutoBrightnessAdjustment = Float.NaN;
}
final float autoBrightnessAdjustment;
// 如果临时自动变量调整值存在，则使用它作为全局自动变量调整值，随后它的值将更新到全局自动变量调整值上，并将它重置，如前五行看到的
if (!Float.isNaN(mTemporaryAutoBrightnessAdjustment)) {
autoBrightnessAdjustment = mTemporaryAutoBrightnessAdjustment;
brightnessAdjustmentFlags = BrightnessReason.ADJUSTMENT_AUTO_TEMP;
// 表示使用了临时自动亮度调整值
mAppliedTemporaryAutoBrightnessAdjustment = true;
// 否则使用全局自动亮度调整值
} else {
autoBrightnessAdjustment = mAutoBrightnessAdjustment;
brightnessAdjustmentFlags = BrightnessReason.ADJUSTMENT_AUTO;
mAppliedTemporaryAutoBrightnessAdjustment = false;
}
// 如果使用了亮度增强，Display状态不处于灭屏，会将亮度设置到最大
if (mPowerRequest.boostScreenBrightness
&& brightness != PowerManager.BRIGHTNESS_OFF) {
brightnessState = PowerManager.BRIGHTNESS_ON;
mBrightnessReasonTemp.setReason(BrightnessReason.REASON_BOOST);
// 表示使用了亮度增强
mAppliedBrightnessBoost = true;
} else {
mAppliedBrightnessBoost = false;
}
// 表示是否用户发起了亮度的改变：没有使用以上几类亮度&(自动亮度调整值发生变化||用户设置了亮度)
// 这个值若为true，说明亮度被用户拖动发生改变了
boolean userInitiatedChange = (Float.isNaN(brightnessState))
&& (autoBrightnessAdjustmentChanged || userSetBrightnessChanged);
// 是否用户手动调节过自动亮度
boolean hadUserBrightnessPoint = false;
if (mAutomaticBrightnessController != null) {
hadUserBrightnessPoint = mAutomaticBrightnessController.hasUserDataPoints();
// 配置自动亮度相关参数
mAutomaticBrightnessController.configure(autoBrightnessEnabled,
mBrightnessConfiguration,
mLastUserSetScreenBrightness,
userSetBrightnessChanged, autoBrightnessAdjustment,
autoBrightnessAdjustmentChanged, mPowerRequest.policy); }
// #################################################### Part 6 ####################################################
boolean slowChange = false;
if (brightness < 0) { // 如果前面几类亮度未使用，则使用自动亮度
float newAutoBrightnessAdjustment = autoBrightnessAdjustment;
if (autoBrightnessEnabled) {
// 获取自动亮度
brightnessState = mAutomaticBrightnessController.getAutomaticScreenBrightness();
// 获取新的自动亮度调整值
newAutoBrightnessAdjustment =
mAutomaticBrightnessController.getAutomaticScreenBrightnessAdjustment();
}
// 说明使用了自动亮度
if (isValidBrightnessValue(brightnessState)) {
// 对得到的自动亮度限制范围
brightnessState = clampScreenBrightness(brightness);
// 这俩条件说明是由自动亮度的调节
if (mAppliedAutoBrightness && !autoBrightnessAdjustmentChanged) {
// 用来控制亮度调节速率
slowChange = true;
}
// 将亮度值更新到settings中
putScreenBrightnessSetting(brightnessState);
// 表示使用了自动亮度
mAppliedAutoBrightness = true;
mBrightnessReasonTemp.setReason(BrightnessReason.REASON_AUTOMATIC);
} else {
mAppliedAutoBrightness = false;
}
// 如果自动亮度调整值发生变化，更新自动亮度调整值到settings中
if (autoBrightnessAdjustment != newAutoBrightnessAdjustment) {
putAutoBrightnessAdjustmentSetting(newAutoBrightnessAdjustment);
} else {
// 说明是纯自动亮度，并没有调整
brightnessAdjustmentFlags = 0;
}
} else {
mAppliedAutoBrightness = false;
brightnessAdjustmentFlags = 0;
}
// #################################################### Part 7 ####################################################
// 如果进入Doze状态后，PMS中未指定Doze状态亮度，使用默认的doze亮度
if ((Float.isNaN(brightnessState))
&& Display.isDozeState(state)) {
brightnessState = mScreenBrightnessDozeConfig;
mBrightnessReasonTemp.setReason(BrightnessReason.REASON_DOZE_DEFAULT);
}
// #################################################### Part 8 ####################################################
// 如果这里还没有亮度，那么将使用用户设置的亮度
if (Float.isNaN(brightnessState)) {
brightnessState = clampScreenBrightness(mCurrentScreenBrightnessSetting);
mBrightnessReasonTemp.setReason(BrightnessReason.REASON_MANUAL);
}
// #################################################### Part 9 ####################################################
// 设置进入Dim后的亮度
if (mPowerRequest.policy == DisplayPowerRequest.POLICY_DIM) {
if (brightnessState > mScreenBrightnessRangeMinimum) {
brightnessState = Math.max(Math.min(brightness - SCREEN_DIM_MINIMUM_REDUCTION,
mScreenBrightnessDimConfig), mScreenBrightnessRangeMinimum);
mBrightnessReasonTemp.addModifier(BrightnessReason.MODIFIER_DIMMED);
}
if (!mAppliedDimming) {
slowChange = false; // 表示需要快速设置亮度
}
mAppliedDimming = true; // 表示使用了Dim亮度
} else if (mAppliedDimming) {
slowChange = false;
mAppliedDimming = false;
}
// #################################################### Part 10 ####################################################
// 低电量模式下，需要调低亮度以节约功耗
if (mPowerRequest.lowPowerMode) {
if (brightnessState > mScreenBrightnessRangeMinimum) {
final float brightnessFactor =
Math.min(mPowerRequest.screenLowPowerBrightnessFactor, 1);
final float lowPowerBrightnessFloat = (brightnessState * brightnessFactor);
brightnessState = Math.max(lowPowerBrightness, mScreenBrightnessRangeMinimum);
mBrightnessReasonTemp.addModifier(BrightnessReason.MODIFIER_LOW_POWER);
}
if (!mAppliedLowPower) {
slowChange = false;
}
// 表示使用了低电量模式的亮度
mAppliedLowPower = true;
} else if (mAppliedLowPower) {
slowChange = false;
mAppliedLowPower = false;
}
// #################################################### Part 11 ####################################################
if (!mPendingScreenOff) {
if (mSkipScreenOnBrightnessRamp) { // mSkipScreenOnBrightnessRamp表示亮屏时不使用亮度动画
if (state == Display.STATE_ON) {
if (mSkipRampState == RAMP_STATE_SKIP_NONE && mDozing) {
mInitialAutoBrightness = brightness;
mSkipRampState = RAMP_STATE_SKIP_INITIAL;
} else if (mSkipRampState == RAMP_STATE_SKIP_INITIAL
&& mUseSoftwareAutoBrightnessConfig
&& brightness != mInitialAutoBrightness) {
mSkipRampState = RAMP_STATE_SKIP_AUTOBRIGHT;
} else if (mSkipRampState == RAMP_STATE_SKIP_AUTOBRIGHT) {
mSkipRampState = RAMP_STATE_SKIP_NONE;
}
} else {
mSkipRampState = RAMP_STATE_SKIP_NONE;
}
}
// 是否处于或原本处于VR状态
final boolean wasOrWillBeInVr =
(state == Display.STATE_VR || oldState == Display.STATE_VR);
// 表示是否在亮屏时，使用亮度动画，使用亮度动画，在亮屏时可能会出现缓慢的设置亮度。由mSkipScreenOnBrightnessRamp决定
final boolean initialRampSkip =
state == Display.STATE_ON && mSkipRampState != RAMP_STATE_SKIP_NONE;
// display硬件是否支持全范围亮度值，如果不支持，设置亮度时就不使用亮度动画设置
final boolean hasBrightnessBuckets =
Display.isDozeState(state) && mBrightnessBucketsInDozeConfig; // 表示doze状态时，display硬件是否支持全范围亮度值
// 是否colorfade已经完成对显示内容的覆盖，如果已经覆盖，那么就没必要使用亮度动画了，因为已经看不到显示内容了
final boolean isDisplayContentVisible =
mColorFadeEnabled && mPowerState.getColorFadeLevel() == 1.0f;
// 是否使用到了临时亮度
final boolean brightnessIsTemporary =
mAppliedTemporaryBrightness || mAppliedTemporaryAutoBrightnessAdjustment;
float animateValue = brightnessState == PowerManager.BRIGHTNESS_OFF_FLOAT
? PowerManager.BRIGHTNESS_MIN : brightnessState;
if (isValidBrightnessValue(animateValue)) {
// 以下条件，直接设置亮度，没有亮度动画(rate=0)
if (initialRampSkip || hasBrightnessBuckets
|| wasOrWillBeInVr || !isDisplayContentVisible || brightnessIsTemporary) {
animateScreenBrightness(animateValue, SCREEN_ANIMATION_RATE_MINIMUM);
} else {
animateScreenBrightness(animateValue,
slowChange ? mBrightnessRampRateSlow : mBrightnessRampRateFast);
}
// #################################################### Part 12 ####################################################
// 每次亮度发生变化后，对这次变化进行记录, 依据就是brightnessIsTemporary和userInitiatedChange
// brightnessIsTemporary表示是否使用临时亮度，默认为false,并且在拖动过程中，这个值为ture，拖动亮度条结束后，将重回false
// userInitiatedChange表示用户是否调整过亮度调整过程中为false，调整完成后将变为ture，并在下一次执行到该方法时又重回false
// 因此，只要亮度发生变化，就会进入下面进行统计，userInitiatedChange则表示是否是用户发起的变化，perfect!
// 不过，notifyBrightnessChanged()中则对统计条件进行了限制：只统计使用自动亮度情况下的变化，关闭自动亮度，使用windowOverlay亮度都是不会统计的
if (!brightnessIsTemporary) {
if (userInitiatedChange && (mAutomaticBrightnessController == null
|| !mAutomaticBrightnessController.hasValidAmbientLux())) {
userInitiatedChange = false;
}
notifyBrightnessChanged(brightness, userInitiatedChange, hadUserBrightnessPoint);
}
}
// 每次亮度调整后，log的输出，日常处理问题相当有用
if (!mBrightnessReasonTemp.equals(mBrightnessReason) || brightnessAdjustmentFlags != 0) {
Slog.v(TAG, "Brightness [" + brightnessState + "] reason changing to: '"
+ mBrightnessReasonTemp.toString(brightnessAdjustmentFlags)
+ "', previous reason: '" + mBrightnessReason + "'.");
mBrightnessReason.set(mBrightnessReasonTemp);
}
// #################################################### Part 13 ####################################################
if (mDisplayWhiteBalanceController != null) { // 自调节色温
if (state == Display.STATE_ON && mDisplayWhiteBalanceSettings.isEnabled()) {
mDisplayWhiteBalanceController.setEnabled(true);
mDisplayWhiteBalanceController.updateDisplayColorTemperature();
} else {
mDisplayWhiteBalanceController.setEnabled(false);
}
}
// #################################################### Part 14 ####################################################
// mPendingScreenOnUnblocker用于亮屏过程，非空表示屏幕目前被阻塞，等待WindowManager模块完成亮屏操作后回调将它置为null
// Colorfade是一个暗层动画，亮灭屏时会淡入淡出
final boolean ready = mPendingScreenOnUnblocker == null &&
(!mColorFadeEnabled ||
(!mColorFadeOnAnimator.isStarted() && !mColorFadeOffAnimator.isStarted())) // 是否正在有colorfade动画进行
&& mPowerState.waitUntilClean(mCleanListener); // 判断屏幕状态和ColorFade是否设置完成，两个都完成时返回true
// 所以ready表示display状态是否设置完成
// 表示display状态设置完毕，亮度也设置完毕
final boolean finished = ready
&& !mScreenBrightnessRampAnimator.isAnimating(); // 亮度动画是否在进行
// mReportedScreenStateToPolicy表示向PhoneWindowManager报告亮灭屏阶段的值
if (ready && state != Display.STATE_OFF
&& mReportedScreenStateToPolicy == REPORTED_TO_POLICY_SCREEN_TURNING_ON) {
setReportedScreenState(REPORTED_TO_POLICY_SCREEN_ON); // 将mReportedScreenStateToPolicy设置为REPORTED_TO_POLICY_SCREEN_ON，表示亮屏完成
mWindowManagerPolicy.screenTurnedOn(); // 报告PhoneWindowManager
}
// 表示更新display的设置或者亮度的设置还没有完成，需要持锁保证它们的完成
if (!finished && !mUnfinishedBusiness) {
mCallbacks.acquireSuspendBlocker();
mUnfinishedBusiness = true;
}
// 回调通知PMS,display状态完成更新，PMS将会再次发起请求
if (ready && mustNotify) {
synchronized (mLock) {
if (!mPendingRequestChangedLocked) {
mDisplayReadyLocked = true; // 表示更新完成了
}
}
sendOnStateChangedWithWakelock(); // 回调PMS
}
// 表示更新display和亮度的设置全部完成，释放锁
if (finished && mUnfinishedBusiness) {
mUnfinishedBusiness = false;
mCallbacks.releaseSuspendBlocker();
}
// 用来记录上次设置Display状态是否为ON
mDozing = state != Display.STATE_ON;
}
根据具体功能将它按功能划分成了几部分来看：
-
Part 1：mPowerRequest的更新，mPowerRequest代表当前PMS中的请求封装对象；
-
Part 2：根据mPowerRequest对象中的policy参数确定要设置的Display状态；
-
Part 3：针对Proximity Sensor的处理;
-
Part 4：根据Part2、Part3确定的state开始设置Display状态；
-
Part 5：确定屏幕亮度；
-
Part 6：应用自动亮度；
-
Part 7：Doze状态时，使用Doze默认亮度；
-
Part 8：应用用户手动调节亮度；
-
Part 9：设置Dim时亮度；
-
Part 10：设置低电量状态时的亮度；
-
Part 11：确定是否使用亮度动画和亮度的设置；
-
Part 12：亮度变化后的log输出和记录；
-
Part 13：更新色温调节状态；
-
Part 14：Display状态和亮度设置完成后的处理。
在这里，对涉及亮灭屏的如下关键流程进行分析：Part1、2、4、11、14，其中Part1、2两部分，是根据PMS中的policy来确定要设置的Display状态，这个好理解，并且都在代码中注释了，所以下面直接从Part4开始。
4.animateScreenStateChange()灭屏动画执行和更新Display状态
当确定好将要设置的Display State后，通过animateScreenStateChange()方法进行设置：
// frameworks/base/services/core/java/com/android/server/display/DisplayPowerController.java
private void animateScreenStateChange(int target, boolean performScreenOffTransition) {
if (mColorFadeEnabled &&
(mColorFadeOnAnimator.isStarted() || mColorFadeOffAnimator.isStarted())) { // 如果在已经在进行ColorFade动画，非Display.ON时直接返回
if (target != Display.STATE_ON) {
return;
}
// 代表是否已开始设置灭屏动画(ColorFade淡入,屏幕变黑)
mPendingScreenOff = false;
}
// 在退出Doze状态时，是否需要是先过渡到OFF状态
if (mDisplayBlanksAfterDozeConfig // 默认为fale
&& Display.isDozeState(mPowerState.getScreenState())
&& !Display.isDozeState(target)) {
mPowerState.prepareColorFade(mContext,
mColorFadeFadesConfig ? ColorFade.MODE_FADE : ColorFade.MODE_WARM_UP);
if (mColorFadeOffAnimator != null) {
mColorFadeOffAnimator.end();
}
// 先过渡到OFF状态
setScreenState(Display.STATE_OFF, target != Display.STATE_OFF /*reportOnly*/);
}
// 如果已经开始设置灭屏动画，但又收到非Display OFF请求，则不再等待灭屏动画完成，直接将Display状态设置为OFF
if (mPendingScreenOff && target != Display.STATE_OFF) {
setScreenState(Display.STATE_OFF);
mPendingScreenOff = false; // 重置
mPowerState.dismissColorFadeResources(); // 移除ColorFade
}
// 按照请求状态进行
if (target == Display.STATE_ON) { // Display目标状态为亮屏
// 通过DisplayPowerState去设置Display，并向PhoneWindowManager发出通知，WMS回调后返回true
if (!setScreenState(Display.STATE_ON)) {
return;
}
// 是否使用了亮屏动画,默认false
if (USE_COLOR_FADE_ON_ANIMATION && mColorFadeEnabled && mPowerRequest.isBrightOrDim()) {
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 { // 如果没有使用ColorFade动画，则直接将ColorFade级别设置为1(全透明)
mPowerState.setColorFadeLevel(1.0f);
mPowerState.dismissColorFade();
}
} else if (target == Display.STATE_VR) { // Display目标状态为VR，这个状态略去
// ..........
} else if (target == Display.STATE_DOZE) { // Display目标状态为DOZE
// 如果正在亮屏状态下进行亮度设置过程，先返回
if (mScreenBrightnessRampAnimator.isAnimating()
&& mPowerState.getScreenState() == Display.STATE_ON) {
return;
}
// 去设置Doze状态
if (!setScreenState(Display.STATE_DOZE)) {
return;
}
mPowerState.setColorFadeLevel(1.0f);
mPowerState.dismissColorFade();
} else if (target == Display.STATE_DOZE_SUSPEND) { // Display目标状态为STATE_DOZE_SUSPEND
if (mScreenBrightnessRampAnimator.isAnimating()
&& mPowerState.getScreenState() != Display.STATE_DOZE_SUSPEND) {
return;
}
// Display设置成STATE_DOZE_SUSPEND前，状态必须为STATE_DOZE才可以
if (mPowerState.getScreenState() != Display.STATE_DOZE_SUSPEND) {
if (!setScreenState(Display.STATE_DOZE)) {
return;
}
setScreenState(Display.STATE_DOZE_SUSPEND);
}
mPowerState.setColorFadeLevel(1.0f);
mPowerState.dismissColorFade();
} else if (target == Display.STATE_ON_SUSPEND) { // Display目标状态为STATE_ON_SUSPEND
if (mScreenBrightnessRampAnimator.isAnimating()
&& mPowerState.getScreenState() != Display.STATE_ON_SUSPEND) {
return;
}
// Display设置成STATE_ON_SUSPEND前，状态必须为STATE_ON才可以
if (mPowerState.getScreenState() != Display.STATE_ON_SUSPEND) {
if (!setScreenState(Display.STATE_ON)) {
return;
}
setScreenState(Display.STATE_ON_SUSPEND);
}
mPowerState.setColorFadeLevel(1.0f);
mPowerState.dismissColorFade();
} else { // 只剩下STATE_OFF，说明要灭屏
mPendingScreenOff = true; // 表示开始执行灭屏ColorFade动画
if (!mColorFadeEnabled) { // 如果不支持ColorFade，则直接添加
mPowerState.setColorFadeLevel(0.0f);
}
// 说明ColorFade动画已经执行完毕，于是开始去设置STATE_OFF状态
if (mPowerState.getColorFadeLevel() == 0.0f) {
setScreenState(Display.STATE_OFF);
mPendingScreenOff = false; // 重置
mPowerState.dismissColorFadeResources();
} else if (performScreenOffTransition
&& mPowerState.prepareColorFade(mContext,
mColorFadeFadesConfig ?
ColorFade.MODE_FADE : ColorFade.MODE_COOL_DOWN)
&& mPowerState.getScreenState() != Display.STATE_OFF) { // 如果以上条件不满足，进入这里，开始执行灭屏动画，第一次都会进入该else-if块
mColorFadeOffAnimator.start(); // 开始执行灭屏动画
} else {
mColorFadeOffAnimator.end(); // 灭屏动画执行完毕
}
}
}
这个方法也很长，但只有两个作用：
-
调用setScreenState()方法来继续设置Display状态；
-
通过ColorFade执行亮灭屏动画。
ColorFade是一个蒙层，它的level设置为1时全透明，0时全黑。在亮屏时，将该层级逐渐设置为1，产生逐渐亮屏的效果。灭屏时，将该层级逐渐设置为0，产生逐渐灭屏的效果。
这个方法可以看出，亮屏时，先设置Display的状态，再设置ColorFadelevel为1；灭屏时，先设置ColorFade level为0，再设置Display状态。这个区别导致了最终亮灭屏过程中设置状态和亮度的先后。
接下来，看下一步setScreenState()方法的执行：
// frameworks/base/services/core/java/com/android/server/display/DisplayPowerController.java
private boolean setScreenState(int state, boolean reportOnly) {
// 是否设置OFF状态
final boolean isOff = (state == Display.STATE_OFF);
// 如果当前状态和目标状态不同
if (mPowerState.getScreenState() != state) {
// 说明非PSensor导致的设置OFF操作，向PhoneWindowManger报告状态
if (isOff && !mScreenOffBecauseOfProximity) {
if (mReportedScreenStateToPolicy == REPORTED_TO_POLICY_SCREEN_ON) {
// 记录状态
setReportedScreenState(REPORTED_TO_POLICY_SCREEN_TURNING_OFF);
blockScreenOff();
// 通知PhoneWindowManager灭屏
mWindowManagerPolicy.screenTurningOff(mPendingScreenOffUnblocker);
unblockScreenOff();
} else if (mPendingScreenOffUnblocker != null) {
return false;
}
}
// reportOnly忽略即可，一般都为false
if (!reportOnly) {
// 进入DisplayPowerState中设置Display状态
mPowerState.setScreenState(state);
}
}
if (isOff && mReportedScreenStateToPolicy != REPORTED_TO_POLICY_SCREEN_OFF
&& !mScreenOffBecauseOfProximity) {
// 记录状态
setReportedScreenState(REPORTED_TO_POLICY_SCREEN_OFF);
// 解除阻塞
unblockScreenOn();
mWindowManagerPolicy.screenTurnedOff(); // 通知PhoneWindowManager灭屏完毕
} else if (!isOff
&& mReportedScreenStateToPolicy == REPORTED_TO_POLICY_SCREEN_TURNING_OFF) { //这种情况说明已经灭屏到一半儿了用户又打算亮屏，这时也应该走完灭屏的流程
unblockScreenOff();
mWindowManagerPolicy.screenTurnedOff(); // 通知PhoneWindowManager灭屏完毕
setReportedScreenState(REPORTED_TO_POLICY_SCREEN_OFF);
}
// 说明由OFF状态切换为其他状态
if (!isOff && mReportedScreenStateToPolicy == REPORTED_TO_POLICY_SCREEN_OFF) {
setReportedScreenState(REPORTED_TO_POLICY_SCREEN_TURNING_ON);
if (mPowerState.getColorFadeLevel() == 0.0f) {
// ColorFade level一直为0,从而导致无法设置亮屏亮度，从而阻塞了亮屏流程，直到WMS中收到回调
blockScreenOn();
} else {
unblockScreenOn(); // 解除阻塞
}
mWindowManagerPolicy.screenTurningOn(mPendingScreenOnUnblocker); // 通知PhoneWindowManager灭屏完毕
}
// mPendingScreenOnUnblocker会在unblockScreenOn()中置为null，表示解除阻塞
return mPendingScreenOnUnblocker == null;
}
这个方法中，设置Display状态，同时向PhoneWindowManager进行通知。mReportedScreenStateToPolicy变量用来记录当前状态，根据不同状态向PhoneWindowManager进行通知。在Display状态发生变化过程中，每当进行到某一步，会将该值设置成对应的值，共有四个值：
// 设置非OFF状态完成，或者说灭屏状态
private static final int REPORTED_TO_POLICY_SCREEN_OFF = 0;
// 开始设置非OFF状态
private static final int REPORTED_TO_POLICY_SCREEN_TURNING_ON = 1;
// 非OFF状态完成
private static final int REPORTED_TO_POLICY_SCREEN_ON = 2;
// 开始设置非OFF状态
private static final int REPORTED_TO_POLICY_SCREEN_TURNING_OFF = 3;
根据这些值通知PhoneWindowManger去执行对应操作。如在开始亮屏时，会调用mWindowManagerPolicy.screenTurningOn(mPendingScreenOnUnblocker)，WMS模块中收到调用后会做相应处理，这个过程中，由于mPendingScreenOnUnblocker对象非空，因此setScreenState()将返回false，导致阻塞colorFade的设置，从而会无法设置屏幕亮度。
在WMS处理完毕后，又通过mPendingScreenOnUnblocker参数回调DMS，并通过unblockScreenOn()方法，将mPendingScreenOnUnblocker对象置为null：
// frameworks/base/services/core/java/com/android/server/display/DisplayPowerController.java
private void unblockScreenOn() {
if (mPendingScreenOnUnblocker != null) {
mPendingScreenOnUnblocker = null;
long delay = SystemClock.elapsedRealtime() - mScreenOnBlockStartRealTime;
}
}
再次进入setScreenState()后，由于mPendingScreenOnUnblocker已经为null，因此不会阻塞ColorFade和亮度的设置。接下来，进入DisplayPowerState#setScreenState()来进一步设置Display的状态。
5.DisplayPowerState#setScreenState()设置状态
DisplayPowerState代表了当前Display的整体状态，包括Display的状态、亮度、ColorFade Level值，凡是涉及到Display的值，最后都会进入DisplayPowerState中进行设置，setScreenState()如下：
// frameworks/base/services/core/java/com/android/server/display/DisplayPowerState.java
public void setScreenState(int state) {
if (mScreenState != state) {
mScreenState = state; // 更新当前Display状态
mScreenReady = false; // 表示更新Display状态、亮度、ColorFade level未完成
scheduleScreenUpdate(); // 执行更新操作
}
}
这里将更新mScreenState变量，更新mScreenReady为false，表示Display状态未更新完成，然后调用scheduleScreenUpdate()方法。scheduleScreenUpdate()方法，在分析完DisplayController中的流程后再进行分析。
6.animateScreenBrightness()更新亮度
回到updatePowerState()中，执行完Part4后，下面来看Part11部分亮度的设置。设置亮度值使用animateScreenBrightness()方法：
// frameworks/base/services/core/java/com/android/server/display/DisplayPowerController.java
private void animateScreenBrightness(float target, int rate) {
// mScreenBrightnessRampAnimator中开始设置亮度
if (mScreenBrightnessRampAnimator.animateTo(target, rate)) {
.......
}
}
第一个参数表示要设置的亮度值，第二个表示设置亮度的速率，关于亮度值和亮度设置速率值的获取、以及亮度动画，会在后面亮度设置部分详细分析，本片文章还是侧重于设置过程。
亮度的设置，不像设置Display状态那样烦琐，mScreenBrightnessRampAnimator是一个RampAnimator对象，该类是一个自定义动画类，专门用于更新亮度。进入该类的animateTo()后，最终会调用到DisplayPowerState的setScreenBrightness()方法，将亮度设置给DisplayPowerState。
7.DisplayPowerState#setScreenBrightness()设置亮度
// frameworks/base/services/core/java/com/android/server/display/DisplayPowerState.java
public void setScreenBrightness(float brightness) {
if (mScreenBrightness != brightness) {
// 更新当前亮度值
mScreenBrightness = brightness;
if (mScreenState != Display.STATE_OFF) {
// 表示更新Display状态、亮度、ColorFade level未完成
mScreenReady = false;
// 执行更新操作
scheduleScreenUpdate();
}
}
}
这里更新了mScreenBrightness变量，也调用了scheduleScreenUpdate()开始执行更新操作。现在，Display的状态和亮度都传到了DisplayPowerState中，下面将通过scheduleScreenUpdate()方法开始更新。
8.scheduleScreenUpdate()执行更新
// frameworks/base/services/core/java/com/android/server/display/DisplayPowerState.java
private void scheduleScreenUpdate() {
if (!mScreenUpdatePending) { // 表示将开始更新Display整体状态
mScreenUpdatePending = true;
postScreenUpdateThreadSafe();
}
}
//------------------------------
private void postScreenUpdateThreadSafe() {
mHandler.removeCallbacks(mScreenUpdateRunnable);
mHandler.post(mScreenUpdateRunnable);
}
以上两个方法中，先将mScreenUpdatePending设置为true，表示将开始更新Display整体状态，然后通过Handler将在mScreenUpdateRunnable这个runnable中进行处理：
// frameworks/base/services/core/java/com/android/server/display/DisplayPowerState.java
private final Runnable mScreenUpdateRunnable = new Runnable() {
@Override
public void run() {
mScreenUpdatePending = false;
// 确认最终的亮度，在Display状态为OFF时，或者ColorFade level为0时，将设置为0，其他情况下设置为DPC中传入的亮度值
float brightnessState = mScreenState != Display.STATE_OFF
&& mColorFadeLevel > 0f ? mScreenBrightness : PowerManager.BRIGHTNESS_OFF_FLOAT;
// PhotonicModulator是一个独立的线程，专门用来更新Display状态和亮度
if (mPhotonicModulator.setState(mScreenState, brightnessState)) {
// 更新完成
mScreenReady = true;
invokeCleanListenerIfNeeded();
} else {
}
}
};
这里会对要更新的亮度值再做一次确认，根据Display状态、ColorFade来确定一个最终亮度值，然后在mPhotonicModulator中开始更新。
9.PhotonicModulator#setState()子线程进行更新
PhotonicModulator是一个继承于Thread的类，专门用于更新Display状态和亮度，因此更新屏幕状态和背光是在独立的线程中异步进行的，setState()方法如下：
// frameworks/base/services/core/java/com/android/server/display/DisplayPowerState.java
public boolean setState(int state, int backlight) {
synchronized (mLock) {
// Display状态是否发生变化，mPendingState表示即将开始设置的状态，设置完成后也不会清除
boolean stateChanged = state != mPendingState;
// 亮度是否发生变化，mPendingBacklight表示即将开始设置的亮度，设置完成后也不会清除
boolean backlightChanged = backlight != mPendingBacklight;
// Display状态或亮度任意一个发生变化，就开始更新
if (stateChanged || backlightChanged) {
mPendingState = state; // 更新mPendingState值
mPendingBacklight = backlight; // 更新mPendingBacklight值
// 表示是否处于change过程中
boolean changeInProgress = mStateChangeInProgress || mBacklightChangeInProgress;
mStateChangeInProgress = stateChanged || mStateChangeInProgress;
mBacklightChangeInProgress = backlightChanged || mBacklightChangeInProgress;
// 当不处于change过程中时，唤起PhotonicModulator线程
if (!changeInProgress) {
mLock.notifyAll();
}
}
return !mStateChangeInProgress; // 只要State更新完成，就返回true
}
}
当屏幕状态和亮度任意一个发生变化，将通过notifyAll()唤醒PhotonicModulator线程，然后执行该线程的run()方法，这是一个生产-消费者模型，肯定有其他地方对其进行了wait()操作。接下来看下它的run()方法：
// frameworks/base/services/core/java/com/android/server/display/DisplayPowerState.java
public void run() {
for (;;) {
final int state;
final boolean stateChanged;
final int backlight;
final boolean backlightChanged;
synchronized (mLock) {
state = mPendingState;
// mActualState表示实际Display状态
stateChanged = (state != mActualState);
backlight = mPendingBacklight;
// mActualBacklight表示实际亮度
backlightChanged = (backlight != mActualBacklight);
if (!stateChanged) {
// 再一次发起更新流程
postScreenUpdateThreadSafe();
mStateChangeInProgress = false;
}
if (!backlightChanged) {
mBacklightChangeInProgress = false;
}
if (!stateChanged && !backlightChanged) {
try {
// state和亮度都设置完成后，该线程进入wait状态
mLock.wait();
} catch (InterruptedException ex) { }
continue;
}
mActualState = state;
mActualBacklight = backlight;
}
// 调用DisplayBlanker中去请求Display
mBlanker.requestDisplayState(state, backlight);
}
}
在Display状态和亮度都更新完成之后，通过Object.wait()方法，让该线程进入WAITTING状态了。通过这种方式，不断设置过来的Display状态和亮度。
最终，调用mBlanker.requestDisplayState()进行下一步设置，这里又经过DMS，最后会对具体的DisplayDevice对象进行状态和亮度的设置中，这中间的逻辑就略过。
10.LocalDisplayDevice#requestDisplayStateLocked()
requestDisplayStateLocked()为具体的物理屏设置新的Display状态和亮度值：
// frameworks/base/services/core/java/com/android/server/display/LocalDisplayAdapter.java
@Override
public Runnable requestDisplayStateLocked(final int state, final float brightnessState) {
final boolean stateChanged = (mState != state);
final boolean brightnessChanged = (!BrightnessSynchronizer.floatEquals(
mBrightnessState, brightnessState))
&& mBacklight != null;
if (stateChanged || brightnessChanged) {
......
return new Runnable() {
@Override
public void run() {
......
// 设置亮度
if (brightnessChanged || vrModeChange) {
setDisplayBrightness(brightnessState);
}
// 设置状态
if (state != currentState) {
setDisplayState(state);
}
}
private void setDisplayState(int state) {
......
try {
SurfaceControl.setDisplayPowerMode(token, mode);
} finally {}
}
private void setDisplayBrightness(float brightness) {
try {
if (mBacklight != null) {
mBacklight.setBrightness(brightness);
}
} finally {
}
}
};
}
return null;
}
最终，将亮度设置给了LightsService，将状态则是给了SurfaceControl，并由这两模块将分别将亮度和状态SurfaceFlinger中，最终完成整个设置。
回到updatePowerState()中，在Part14部分中，当Display状态和亮度都设置完成后，会将mDisplayReadyLocked值设置为true，表示Display状态更新完成，并在sendOnStateChangedWithWakelock()方法中回调PMS，PMS再次发起请求时，由于mDisplayReadyLocked已经变为true，因此将返回true，PMS将认为DMS对请求处理完成。
11.总结
以上就是display模块中涉及到的亮灭屏流程。结合之前PMS中的两篇亮灭屏流程，Framework层的亮灭屏流程全部分析完成。
（1）亮屏时序图
DMS3-1.png
（2）灭屏时序图
DMS3-2.png
网友评论