Android6.0 亮屏灭屏流程（DisplayPowerController、WMS）（一）WMS绘制
亮屏、灭屏流程整个流程涉及的模块比较多，包括PowerManagerService、DisplayPowerControl、WMS、AMS。因此在分析完WMS之后，我们把这块也分析下。
DisplayPowerControl
我们知道灭屏流程的发起是在PowerManagerService中，会通过updatePowerState函数调用updateDisplayPowerStateLocked函数，再调用DisplayPowerControl的requestPowerState函数，到DisplayPowerControl中。DisplayPowerControl中后面会调用updatePowerState函数，我们也主要从这个函数开始分析：
updatePowerState会根据PowerManagerService传过来的显示状态，然后调用animateScreenStateChange函数。
animateScreenStateChange(state, performScreenOffTransition);下面我们先来看animateScreenStateChange函数：
private void animateScreenStateChange(int target, boolean performScreenOffTransition) {
// If there is already an animation in progress, don't interfere with it.
if (mColorFadeOnAnimator.isStarted()
|| mColorFadeOffAnimator.isStarted()) {
return;
}
// If we were in the process of turning off the screen but didn't quite
// finish. Then finish up now to prevent a jarring transition back
// to screen on if we skipped blocking screen on as usual.
if (mPendingScreenOff && target != Display.STATE_OFF) {
setScreenState(Display.STATE_OFF);
mPendingScreenOff = false;
mPowerState.dismissColorFadeResources();
}
if (target == Display.STATE_ON) {//亮屏处理
// Want screen on. The contents of the screen may not yet
// be visible if the color fade has not been dismissed because
// its last frame of animation is solid black.
if (!setScreenState(Display.STATE_ON)) {
return; // screen on blocked
}
if (USE_COLOR_FADE_ON_ANIMATION && mPowerRequest.isBrightOrDim()) {//亮屏动画
// Perform screen on animation.
if (mPowerState.getColorFadeLevel() == 1.0f) {
mPowerState.dismissColorFade();
} else if (mPowerState.prepareColorFade(mContext,
mColorFadeFadesConfig ?
ColorFade.MODE_FADE :
ColorFade.MODE_WARM_UP)) {
mColorFadeOnAnimator.start();
} else {
mColorFadeOnAnimator.end();
}
} else {//跳过亮屏动画
// Skip screen on animation.
mPowerState.setColorFadeLevel(1.0f);
mPowerState.dismissColorFade();
}
} else if (target == Display.STATE_DOZE) {
// Want screen dozing.
// Wait for brightness animation to complete beforehand when entering doze
// from screen on to prevent a perceptible jump because brightness may operate
// differently when the display is configured for dozing.
......
} else if (target == Display.STATE_DOZE_SUSPEND) {
// Want screen dozing and suspended.
// Wait for brightness animation to complete beforehand unless already
// suspended because we may not be able to change it after suspension.
......
} else {//灭屏处理
// Want screen off.
mPendingScreenOff = true;
if (mPowerState.getColorFadeLevel() == 0.0f) {//灭屏动画结束
// Turn the screen off.
// A black surface is already hiding the contents of the screen.
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) {
// Perform the screen off animation.
mColorFadeOffAnimator.start();//开启灭屏动画
} else {
// Skip the screen off animation and add a black surface to hide the
// contents of the screen.
mColorFadeOffAnimator.end();//关闭灭屏动画
}
}
}animateScreenStateChange在亮屏的处理的时候，先会调用setScreenState(Display.STATE_ON），然后根据USE_COLOR_FADE_ON_ANIMATION 判断是否要开启亮屏动画，这里我们是没有设置的。因此直接跳过亮屏动画。灭屏的处理的话，会有一个灭屏动画（也是注册一个VSync信号回调函数处理的，这里我们不分析了），当动画结束后，直接就调用setScreenState(Display.STATE_OFF)结束。
我们再来看看setScreenState函数
private boolean setScreenState(int state) {
if (mPowerState.getScreenState() != state) {
final boolean wasOn = (mPowerState.getScreenState() != Display.STATE_OFF);
mPowerState.setScreenState(state);
......
}
// Tell the window manager policy when the screen is turned off or on unless it's due
// to the proximity sensor. We temporarily block turning the screen on until the
// window manager is ready by leaving a black surface covering the screen.
// This surface is essentially the final state of the color fade animation and
// it is only removed once the window manager tells us that the activity has
// finished drawing underneath.
final boolean isOff = (state == Display.STATE_OFF);
if (isOff && mReportedScreenStateToPolicy != REPORTED_TO_POLICY_SCREEN_OFF
&& !mScreenOffBecauseOfProximity) {
mReportedScreenStateToPolicy = REPORTED_TO_POLICY_SCREEN_OFF;
unblockScreenOn();
mWindowManagerPolicy.screenTurnedOff();//调用PhoneWindowManager的screenTurnedOff
} else if (!isOff && mReportedScreenStateToPolicy == REPORTED_TO_POLICY_SCREEN_OFF) {
mReportedScreenStateToPolicy = REPORTED_TO_POLICY_SCREEN_TURNING_ON;
if (mPowerState.getColorFadeLevel() == 0.0f) {
blockScreenOn();
} else {
unblockScreenOn();
}
mWindowManagerPolicy.screenTurningOn(mPendingScreenOnUnblocker);//调用PhoneWindowManager的screenTurningOn函数
}
// Return true if the screen isn't blocked.
return mPendingScreenOnUnblocker == null;
}setScreenState函数，先是调用了DisplayPowerState的setScreenState函数，然后根据屏幕是灭屏还是亮屏调用PhoneWindowManager的相关函数。
PhoneWindowManager的screenTurnedOff和screenTurningOn函数
PhoneWindowManager的screenTurnedOff函数主要是通知kerguard，屏幕灭屏了。
@Override
public void screenTurnedOff() {
if (DEBUG_WAKEUP) Slog.i(TAG, "Screen turned off...");
updateScreenOffSleepToken(true);
synchronized (mLock) {
mScreenOnEarly = false;
mScreenOnFully = false;
mKeyguardDrawComplete = false;
mWindowManagerDrawComplete = false;
mScreenOnListener = null;
updateOrientationListenerLp();
if (mKeyguardDelegate != null) {
mKeyguardDelegate.onScreenTurnedOff();
}
}
}我们再来看PhoneWindowManager的screenTurningOn函数。当有keyguard时，我们会先发一个延时的MSG_KEYGUARD_DRAWN_TIMEOUT信号，并且会调用keyguard的onScreenTurningOn函数，当完成会调用mKeyguardDrawnCallback回调函数。我们这里还要注意下有一个屏幕点亮后的回调。
@Override
public void screenTurningOn(final ScreenOnListener screenOnListener) {
if (DEBUG_WAKEUP) Slog.i(TAG, "Screen turning on...");
updateScreenOffSleepToken(false);
synchronized (mLock) {
mScreenOnEarly = true;
mScreenOnFully = false;
mKeyguardDrawComplete = false;
mWindowManagerDrawComplete = false;
mScreenOnListener = screenOnListener;//屏幕点亮后的回调
if (mKeyguardDelegate != null) {
if (DEBUG_WAKEUP) Slog.d(TAG,
"send delay message MSG_KEYGUARD_DRAWN_TIMEOUT");
mHandler.removeMessages(MSG_KEYGUARD_DRAWN_TIMEOUT);
mHandler.sendEmptyMessageDelayed(MSG_KEYGUARD_DRAWN_TIMEOUT, 1000);
mKeyguardDelegate.onScreenTurningOn(mKeyguardDrawnCallback);
} else {
if (DEBUG_WAKEUP) Slog.d(TAG,
"null mKeyguardDelegate: setting mKeyguardDrawComplete.");
finishKeyguardDrawn();
}
}
}我们先看下mKeyguardDrawnCallback 回调，就是发送MSG_KEYGUARD_DRAWN_COMPLETE（keyguard绘制完的消息）
final DrawnListener mKeyguardDrawnCallback = new DrawnListener() {
@Override
public void onDrawn() {
if (DEBUG_WAKEUP) Slog.d(TAG, "mKeyguardDelegate.ShowListener.onDrawn.");
mHandler.sendEmptyMessage(MSG_KEYGUARD_DRAWN_COMPLETE);
}
};我们再来看看MSG_KEYGUARD_DRAWN_COMPLETE以及MSG_KEYGUARD_DRAWN_TIMEOUT信号的处理，都会调用finishKeyguardDrawn函数。
case MSG_KEYGUARD_DRAWN_COMPLETE:
if (DEBUG_WAKEUP) Slog.w(TAG, "Setting mKeyguardDrawComplete");
finishKeyguardDrawn();
break;
case MSG_KEYGUARD_DRAWN_TIMEOUT:
Slog.w(TAG, "Keyguard drawn timeout. Setting mKeyguardDrawComplete");
finishKeyguardDrawn();
break; private void finishKeyguardDrawn() {
synchronized (mLock) {
if (!mScreenOnEarly || mKeyguardDrawComplete) {
return; // We are not awake yet or we have already informed of this event.
}
mKeyguardDrawComplete = true;
if (mKeyguardDelegate != null) {
mHandler.removeMessages(MSG_KEYGUARD_DRAWN_TIMEOUT);
}
mWindowManagerDrawComplete = false;
}
// ... eventually calls finishWindowsDrawn which will finalize our screen turn on
// as well as enabling the orientation change logic/sensor.
mWindowManagerInternal.waitForAllWindowsDrawn(mWindowManagerDrawCallback,
WAITING_FOR_DRAWN_TIMEOUT);
}最后我们再看看WMS的waitForAllWindowsDrawn函数，以及两个参数mWindowManagerDrawCallback和一个WAITING_FOR_DRAWN_TIMEOUT（1秒）。
WMS的waitForAllWindowsDrawn函数
我们先来看看WMS的waitForAllWindowsDrawn函数，会把传进来的回调保存在mWaitingForDrawnCallback 。然后遍历所有的windows，把需要显示或者已经显示的窗口全部加入到mWaitingForDrawn，然后调用requestTraversalLocked这个函数我们之前分析过，就是发送一个消息，重新刷新UI布局。然后我们继续分析这个函数，如果mWaitingForDrawn为空，代表没啥显示的直接调用回调函数，如果mWaitingForDrawn有要显示的窗口，就要会先发送一个WAITING_FOR_DRAWN_TIMEOUT，这个timeout之前传进来的是1秒。然后调用checkDrawnWindowsLocked函数。
@Override
public void waitForAllWindowsDrawn(Runnable callback, long timeout) {
synchronized (mWindowMap) {
mWaitingForDrawnCallback = callback;//回调保存在mWaitingForDrawnCallback
final WindowList windows = getDefaultWindowListLocked();
for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {
final WindowState win = windows.get(winNdx);
final boolean isForceHiding = mPolicy.isForceHiding(win.mAttrs);
Slog.i(TAG,"In the function waitForAllWindowsDrawn");
if (win.isVisibleLw()
&& (win.mAppToken != null || isForceHiding)) {
Slog.i(TAG,"In the function win.isVisibleLw()");
win.mWinAnimator.mDrawState = WindowStateAnimator.DRAW_PENDING;
// Force add to mResizingWindows.
win.mLastContentInsets.set(-1, -1, -1, -1);
mWaitingForDrawn.add(win);
// No need to wait for the windows below Keyguard.
if (isForceHiding) {
break;
}
}
}
requestTraversalLocked();
}
mH.removeMessages(H.WAITING_FOR_DRAWN_TIMEOUT);
if (mWaitingForDrawn.isEmpty()) {
callback.run();
Slog.i(TAG,"In the function mWaitingForDrawn.isEmpty()");
} else {
mH.sendEmptyMessageDelayed(H.WAITING_FOR_DRAWN_TIMEOUT, timeout);
checkDrawnWindowsLocked();
Slog.i(TAG,"In the function checkDrawnWindowsLocked()");
}
}我们先来看下checkDrawnWindowsLocked函数，这个函数。遍历之前加入的mWaitingForDrawn（要显示的窗口），这个时候我们把已经去除的，不需要显示的，没有surface的窗口从mWaitingForDrawn去除，还有已经绘制好的也去除。然后再当mWaitingForDrawn为空时，就发送ALL_WINDOWS_DRAWN消息。
void checkDrawnWindowsLocked() {
if (mWaitingForDrawn.isEmpty() || mWaitingForDrawnCallback == null) {
return;
}
for (int j = mWaitingForDrawn.size() - 1; j >= 0; j--) {
WindowState win = mWaitingForDrawn.get(j);
if (win.mRemoved || !win.mHasSurface || !win.mPolicyVisibility) {
// Window has been removed or hidden; no draw will now happen, so stop waiting.
if (DEBUG_SCREEN_ON) Slog.w(TAG, "Aborted waiting for drawn: " + win);
mWaitingForDrawn.remove(win);
} else if (win.hasDrawnLw()) {
// Window is now drawn (and shown).
if (DEBUG_SCREEN_ON) Slog.d(TAG, "Window drawn win=" + win);
mWaitingForDrawn.remove(win);
}
}
if (mWaitingForDrawn.isEmpty()) {
if (DEBUG_SCREEN_ON) Slog.d(TAG, "All windows drawn!");
mH.removeMessages(H.WAITING_FOR_DRAWN_TIMEOUT);
mH.sendEmptyMessage(H.ALL_WINDOWS_DRAWN);
}
}ALL_WINDOWS_DRAWN消息的处理就是清除mWaitingForDrawnCallback ，然后调用回调。
case ALL_WINDOWS_DRAWN: {
Runnable callback;
synchronized (mWindowMap) {
callback = mWaitingForDrawnCallback;
mWaitingForDrawnCallback = null;
}
if (callback != null) {
callback.run();
}
}还有当我们调用waitForAllWindowsDrawn一般都是有需要显示的窗口，但是我们直接调用checkDrawnWindowsLocked函数，发现有的窗口还没绘制完成。那么我们就要等，会在刷新的核心函数中performLayoutAndPlaceSurfacesLockedInner有如下代码，这个时候如果之前还没绘制完成的窗口，绘制好了。会再调用checkDrawnWindowsLocked函数，如果mWaitingForDrawn中的窗口绘制好了，会在mWaitingForDrawn中去除这个窗口。然后mWaitingForDrawn为空了，之后会发送ALL_WINDOWS_DRAWN消息，还调用mWaitingForDrawnCallback回调函数。
if (mWaitingForDrawnCallback != null ||
(mInnerFields.mOrientationChangeComplete && !defaultDisplay.layoutNeeded &&
!mInnerFields.mUpdateRotation)) {
checkDrawnWindowsLocked();
}当然如果我们之前没有把mWaitingForDrawn中的窗口清空，最后在WAITING_FOR_DRAWN_TIMEOUT（这里是1秒）时间到了也会调用回调的。
case WAITING_FOR_DRAWN_TIMEOUT: {
Runnable callback = null;
synchronized (mWindowMap) {
Slog.w(TAG, "Timeout waiting for drawn: undrawn=" + mWaitingForDrawn);
mWaitingForDrawn.clear();
callback = mWaitingForDrawnCallback;
mWaitingForDrawnCallback = null;
}
if (callback != null) {
callback.run();
}
break;
}
PhoneWindowManager窗口绘制完成的回调函数
那下面我们就要继续看PhoneWindowManager中窗口绘制完成之后的回调函数。代码如下就是发送了一个消息。
final Runnable mWindowManagerDrawCallback = new Runnable() {
@Override
public void run() {
if (DEBUG_WAKEUP) Slog.i(TAG, "All windows ready for display!");
mHandler.sendEmptyMessage(MSG_WINDOW_MANAGER_DRAWN_COMPLETE);
}
};我们来看这个消息的处理
case MSG_WINDOW_MANAGER_DRAWN_COMPLETE:
if (DEBUG_WAKEUP) Slog.w(TAG, "Setting mWindowManagerDrawComplete");
finishWindowsDrawn();
break;finishWindowsDrawn就是把mWindowManagerDrawComplete 置为true，然后调用finishScreenTurningOn函数。
private void finishWindowsDrawn() {
synchronized (mLock) {
if (!mScreenOnEarly || mWindowManagerDrawComplete) {
return; // Screen is not turned on or we did already handle this case earlier.
}
mWindowManagerDrawComplete = true;
}
finishScreenTurningOn();
}finishScreenTurningOn函数调用了之前在DisplayPowerControl中调用screenTurningOn传入的回调，然后再调用WMS的enableScreenIfNeeded函数。
private void finishScreenTurningOn() {
synchronized (mLock) {
updateOrientationListenerLp();
}
final ScreenOnListener listener;
final boolean enableScreen;
synchronized (mLock) {
if (mScreenOnFully || !mScreenOnEarly || !mWindowManagerDrawComplete
|| (mAwake && !mKeyguardDrawComplete)) {
return; // spurious or not ready yet
}
listener = mScreenOnListener;
mScreenOnListener = null;
mScreenOnFully = true;
......
}
if (listener != null) {
listener.onScreenOn();
}
if (enableScreen) {
try {
mWindowManager.enableScreenIfNeeded();
} catch (RemoteException unhandled) {
}
}
}我们先分析下WMS的enableScreenIfNeeded函数，然后再看DisplayPowerControl的回调onScreenOn函数。
WMS的enableScreenIfNeeded函数
WMS的enableScreenIfNeeded函数就是调用了enableScreenIfNeededLocked函数
@Override
public void enableScreenIfNeeded() {
synchronized (mWindowMap) {
enableScreenIfNeededLocked();
}
}enableScreenIfNeededLocked这个函数仅仅是保证mDisplayEnabled为true，如果为true直接结束。
void enableScreenIfNeededLocked() {
if (mDisplayEnabled) {
return;
}
if (!mSystemBooted && !mShowingBootMessages) {
return;
}
mH.sendEmptyMessage(H.ENABLE_SCREEN);
}mDisplayEnabled不为true，发送ENABLE_SCREEN消息
case ENABLE_SCREEN: {
performEnableScreen();
break;performEnableScreen函数会让SurfaceFlinger去停止开机动画等，也会把mDisplayEnabled置为true。当然performEnableScreen在开机的时候会AMS中调用WMS的enableScreenAfterBoot函数来调用performEnableScreen函数。这个我们在博客http://blog.csdn.net/kc58236582/article/details/52921978分析过了。
public void performEnableScreen() {
synchronized(mWindowMap) {
if (mDisplayEnabled) {
return;
}
if (!mSystemBooted && !mShowingBootMessages) {
return;
}
// Don't enable the screen until all existing windows have been drawn.
if (!mForceDisplayEnabled && checkWaitingForWindowsLocked()) {
return;
}
if (!mBootAnimationStopped) {
// Do this one time.
try {//停止开机动画
IBinder surfaceFlinger = ServiceManager.getService("SurfaceFlinger");
if (surfaceFlinger != null) {
//Slog.i(TAG, "******* TELLING SURFACE FLINGER WE ARE BOOTED!");
Parcel data = Parcel.obtain();
data.writeInterfaceToken("android.ui.ISurfaceComposer");
surfaceFlinger.transact(IBinder.FIRST_CALL_TRANSACTION, // BOOT_FINISHED
data, null, 0);
data.recycle();
}
} catch (RemoteException ex) {
Slog.e(TAG, "Boot completed: SurfaceFlinger is dead!");
}
mBootAnimationStopped = true;
}
if (!mForceDisplayEnabled && !checkBootAnimationCompleteLocked()) {
if (DEBUG_BOOT) Slog.i(TAG, "performEnableScreen: Waiting for anim complete");
return;
}
mDisplayEnabled = true;//置为true
if (DEBUG_SCREEN_ON || DEBUG_BOOT) Slog.i(TAG, "******************** ENABLING SCREEN!");
// Enable input dispatch.
mInputMonitor.setEventDispatchingLw(mEventDispatchingEnabled);
}
try {
mActivityManager.bootAnimationComplete();
} catch (RemoteException e) {
}
mPolicy.enableScreenAfterBoot();
// Make sure the last requested orientation has been applied.
updateRotationUnchecked(false, false);
}窗口绘制完成后调用DisplayPowerControl中的回调
当WMS窗口绘制完成后，会在PhoneWindowManager中的finishScreenTurningOn函数调用DisplayPowerControl的回调函数。最后我们再来看看DisplayPowerControl中的回调的onScreenOn函数。只是发送了一个MSG_SCREEN_ON_UNBLOCKED消息。
private final class ScreenOnUnblocker implements WindowManagerPolicy.ScreenOnListener {
@Override
public void onScreenOn() {
Message msg = mHandler.obtainMessage(MSG_SCREEN_ON_UNBLOCKED, this);
msg.setAsynchronous(true);
mHandler.sendMessage(msg);
}
}MSG_SCREEN_ON_UNBLOCKED的处理先是调用了unblockScreenOn函数，然后再调用updatePowerState更新状态。
case MSG_SCREEN_ON_UNBLOCKED:
if (mPendingScreenOnUnblocker == msg.obj) {
unblockScreenOn();
updatePowerState();
}
break;unblockScreenOn函数，只是打印下从调用screenTurningOn开始，到窗口绘制完成在PhoneWindowManager中回调这个函数的时间差打印。
private void unblockScreenOn() {
if (mPendingScreenOnUnblocker != null) {
mPendingScreenOnUnblocker = null;
long delay = SystemClock.elapsedRealtime() - mScreenOnBlockStartRealTime;
Slog.i(TAG, "Unblocked screen on after " + delay + " ms");
Trace.asyncTraceEnd(Trace.TRACE_TAG_POWER, SCREEN_ON_BLOCKED_TRACE_NAME, 0);
}
}