qidao123.com ToB IT社区-企服评测·应用市场»论坛 › 软件与程序人生 › 移动端开发 › Android核心窗口

Android核心窗口

[复制链接]
发表于 2025-12-11 17:33:39 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

×
概述

作甚核心窗口？顾名思义就是有核心窗口,要留意和view的核心概念要做区分，两个不是一个层面上的概念。为什么窗口要拥有核心呢，下面都是我的明白，有不对的地方接待讨论:核心窗口重要利用在InputDispachar分发按键事故——keyevent阶段,在keyevent分发阶段,此时的核心窗口就是该事故应该分发给的窗口。不像触摸事故，在分发过程中可以通过触摸的坐标推断给事故应该分发给谁人窗口，keyeven来自物理按键，没有对应的坐标，只能通过核心窗口确定发送给谁人窗口。
表明完毕核心窗口的作用，在来简朴先容下一种常见的ANR,即no focus anr，这种anr发生就是由于在分发一次keyEvent时,没有找到核心窗口，便开始了anr计时，5s之后，分发事故的过程中发仍旧没有对应的核心窗口，便会发生无核心ANR。
核心窗口的更新流程在Android12之后，涉及到了三个模块:WMS, Surfaceflinger, InputDispachar,下文将会分析具体得人更新核心窗口流程。
起首明白三个概念：
1. 顶部核心屏幕：mTopFocusedDisplayId，这个变量的声明位于窗口的根节点RootWindowContainer中.
这个变量代表了相应没有指明屏幕的key大概pointer范例的event的屏幕的id。
  1. frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
  3. // The ID of the display which is responsible for receiving display-unspecified key and pointer
  4.     // events.
  5.     private int mTopFocusedDisplayId = INVALID_DISPLAY;
复制代码
2. 核心app：mFocusedApp代表了一个DisplayContent上正处于前台的ActivityRecord,一样寻常这个ActivityRecord下的窗口将会成为核心窗口，存在当核心app属于该ActivityRecord，但是核心窗口不属于该ActivityRecord下属的窗口的情况。
  1. frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
  2. /**
  3.      * The foreground app of this display. Windows below this app cannot be the focused window. If
  4.      * the user taps on the area outside of the task of the focused app, we will notify AM about the
  5.      * new task the user wants to interact with.
  6.      */
  7.     ActivityRecord mFocusedApp = null;
复制代码
3. 核心窗口：mCurrentFocus，当前正在与用户交互的窗口。此窗口负责吸取来自用户的键事故和指针事故。
  1. frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
  2. /**
  3.      /**
  4.      * Window that is currently interacting with the user. This window is responsible for receiving
  5.      * key events and pointer events from the user.
  6.      */
  7.     WindowState mCurrentFocus = null;
复制代码
mTopFocusedDisplayId界说在根节点RootWindowContainer中，这表明整个Android体系中只能有一个顶部核心屏幕，mFocusedApp和mCurrentFocus界说在DisplayContent中，表明每个屏幕都有自己的核心app和核心窗口。
在WindowState的构建过程中，会构建出一个范例为InputWindowHandle的对象，该对象的重要作用是生存窗口的一些信息，随后发送给InputDispatcher，InputWindowHandle在input系代表该应用窗口的对象，用于辨认以及分发事故。
先来总结一下核心窗口的产生过程，这个流程筹划到WMS,surfaceflinger,InputDispatcher:核心窗口的天生过程可以说是一个选拔，选送的过程，在窗口发生一些改变的时间会触发到wms去
  1. frameworks/base/services/core/java/com/android/server/wm/WindowState.java
  3. WindowState(WindowManagerService service, Session s, IWindow c, WindowToken token,
  4.             WindowState parentWindow, int appOp, WindowManager.LayoutParams a, int viewVisibility,
  5.             int ownerId, int showUserId, boolean ownerCanAddInternalSystemWindow,
  6.             PowerManagerWrapper powerManagerWrapper) {
  7.         super(service);
  8.         mTmpTransaction = service.mTransactionFactory.get();
  9.         mSession = s;
  10.         mClient = c;
  11.         mAppOp = appOp;
  12.         mToken = token;
  13.         mActivityRecord = mToken.asActivityRecord();
  14.         mOwnerUid = ownerId;
  15.         mShowUserId = showUserId;
  16.         mOwnerCanAddInternalSystemWindow = ownerCanAddInternalSystemWindow;
  17.         mWindowId = new WindowId(this);
  18.         mAttrs.copyFrom(a);
  19.         mLastSurfaceInsets.set(mAttrs.surfaceInsets);
  20.         mViewVisibility = viewVisibility;
  21.         mPolicy = mWmService.mPolicy;
  22.         mContext = mWmService.mContext;
  23.         DeathRecipient deathRecipient = new DeathRecipient();
  24.         mPowerManagerWrapper = powerManagerWrapper;
  25.         mForceSeamlesslyRotate = token.mRoundedCornerOverlay;
  26.         // 如下：
  27.         mInputWindowHandle = new InputWindowHandleWrapper(new InputWindowHandle(
  28.                 mActivityRecord != null
  29.                         ? mActivityRecord.getInputApplicationHandle(false /* update */) : null,
  30.                 getDisplayId()));
  31.         mInputWindowHandle.setOwnerPid(s.mPid);
  32.         mInputWindowHandle.setOwnerUid(s.mUid);
  33.         mInputWindowHandle.setName(getName());
  34.         mInputWindowHandle.setPackageName(mAttrs.packageName);
  35.         mInputWindowHandle.setLayoutParamsType(mAttrs.type);
复制代码
  1. frameworks/base/services/core/java/com/android/server/wm/WindowState.java
  3. /**
  4. * Functions as a handle for a window that can receive input.
  5. * Enables the native input dispatcher to refer indirectly to the window manager's window state.
  6. * @hide
  7. */
  8. public final class InputWindowHandle {
  9.     // Pointer to the native input window handle.
  10.     // This field is lazily initialized via JNI.
  11.     @SuppressWarnings("unused")
  12.     private long ptr;
  14.     // The input application handle.
  15.     public InputApplicationHandle inputApplicationHandle;
  17.     // The token associates input data with a window and its input channel. The client input
  18.     // channel and the server input channel will both contain this token.
  19.     public IBinder token;
  21.     // The window name.
  22.     public String name;
  24.     // Window layout params attributes.  (WindowManager.LayoutParams)
  25.     public int layoutParamsFlags;
  26.     public int layoutParamsType;
  28.     // Dispatching timeout.
  29.     public long dispatchingTimeoutMillis;
  31.     // Window frame.
  32.     public int frameLeft;
  33.     public int frameTop;
  34.     public int frameRight;
  35.     public int frameBottom;
  37.     public int surfaceInset;
  39.     // Global scaling factor applied to touch events when they are dispatched
  40.     // to the window
  41.     public float scaleFactor;
复制代码
  1. frameworks/base/core/java/android/view/InputApplicationHandle.java
  3. /**
  4. * Functions as a handle for an application that can receive input.
  5. * Enables the native input dispatcher to refer indirectly to the window manager's
  6. * application window token.
  7. * @hide
  8. */
  9. public final class InputApplicationHandle {
  10.     // Pointer to the native input application handle.
  11.     // This field is lazily initialized via JNI.
  12.     @SuppressWarnings("unused")
  13.     private long ptr;
  15.     // Application name.
  16.     public final @NonNull String name;
  18.     // Dispatching timeout.
  19.     public final long dispatchingTimeoutMillis;
  21.     public final @NonNull IBinder token;
  23.     private native void nativeDispose();
  25.     public InputApplicationHandle(@NonNull IBinder token, @NonNull String name,
  26.             long dispatchingTimeoutMillis) {
  27.         this.token = token;
  28.         this.name = name;
  29.         this.dispatchingTimeoutMillis = dispatchingTimeoutMillis;
  30.     }
  32.     public InputApplicationHandle(InputApplicationHandle handle) {
  33.         this.token = handle.token;
  34.         this.dispatchingTimeoutMillis = handle.dispatchingTimeoutMillis;
  35.         this.name = handle.name;
  36.     }
  38.     @Override
  39.     protected void finalize() throws Throwable {
  40.         try {
  41.             nativeDispose();
  42.         } finally {
  43.             super.finalize();
  44.         }
  45.     }
  46. }
复制代码
一.WMS端革新流程

在framework中，触发核心窗口更新的流程的入口是WMS.updateFocusedWindowLocked，触发该函数的位置在fw中非常的多,比如在窗口布局过程中，窗口添加过程中，窗口的移除过程中:

updateFocusedWindowLocked
可见该函数的参数有两个，第一个参数代表更新核心的场景，如下，共5个场景，可以简朴代表调用updateFocusedWindowLocked的场景，第二个参数代表在更新核心窗口的过程是否顺道更新一下InputWindows信息。
在wms的updateFocusedWindowLocked方法中进一步调用了RootWindowContainer的updateFocusedWindowLocked
  1. frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java
  3. static final int UPDATE_FOCUS_NORMAL = 0;
  4. /** Caller will assign layers */
  5. static final int UPDATE_FOCUS_WILL_ASSIGN_LAYERS = 1;
  6. /** Caller is performing surface placement */
  7. static final int UPDATE_FOCUS_PLACING_SURFACES = 2;
  8. /** Caller will performSurfacePlacement */
  9. static final int UPDATE_FOCUS_WILL_PLACE_SURFACES = 3;
  10. /** Indicates we are removing the focused window when updating the focus. */
  11. static final int UPDATE_FOCUS_REMOVING_FOCUS = 4;
  13. boolean updateFocusedWindowLocked(int mode, boolean updateInputWindows) {
  14.         Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "wmUpdateFocus");
  15.         boolean changed = mRoot.updateFocusedWindowLocked(mode, updateInputWindows);
  16.         Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
  17.         return changed;
  18.     }
复制代码
在RootWindowContainer方法中可见随即遍历了每一个DisplayContent，开始选拔每个DisplayContent上的核心窗口:dc.updateFocusedWindowLocked(mode, updateInputWindows, topFocusedDisplayId);
todo 去形貌一下topFocusedDisplayId的革新过程
  1. frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
  2. boolean updateFocusedWindowLocked(int mode, boolean updateInputWindows) {
  3.         mTopFocusedAppByProcess.clear();
  4.         boolean changed = false;
  5.         // 先初始化一下topFocusedDisplayId
  6.         int topFocusedDisplayId = INVALID_DISPLAY;
  7.         遍历RootWindowContainer下的每一个DisplayContent
  8.         for (int i = mChildren.size() - 1; i >= 0; --i) {
  9.             final DisplayContent dc = mChildren.get(i);
  10.             // 调用每一DisplayContent上的updateFocusedWindowLocked，去更新每一个DisplayContent上的焦点窗口
  11.             changed |= dc.updateFocusedWindowLocked(mode, updateInputWindows, topFocusedDisplayId);
  12.             final WindowState newFocus = dc.mCurrentFocus;
  13.             if (newFocus != null) {
  14.                 final int pidOfNewFocus = newFocus.mSession.mPid;
  15.                 if (mTopFocusedAppByProcess.get(pidOfNewFocus) == null) {
  16.                     mTopFocusedAppByProcess.put(pidOfNewFocus, newFocus.mActivityRecord);
  17.                 }
  18.                 if (topFocusedDisplayId == INVALID_DISPLAY) {
  19.                     topFocusedDisplayId = dc.getDisplayId();
  20.                 }
  21.             } else if (topFocusedDisplayId == INVALID_DISPLAY && dc.mFocusedApp != null) {
  22.                 // The top-most display that has a focused app should still be the top focused
  23.                 // display even when the app window is not ready yet (process not attached or
  24.                 // window not added yet).
  25.                 topFocusedDisplayId = dc.getDisplayId();
  26.             }
  27.         }
  28.         // 选了一圈下来，如果topFocusedDisplayId == INVALID_DISPLAY，就把topFocusedDisplayId = DEFAULT_DISPLAY
  29.         if (topFocusedDisplayId == INVALID_DISPLAY) {
  30.             topFocusedDisplayId = DEFAULT_DISPLAY;
  31.         }
  32.         if (mTopFocusedDisplayId != topFocusedDisplayId) {
  33.             mTopFocusedDisplayId = topFocusedDisplayId;
  34.             mWmService.mInputManager.setFocusedDisplay(topFocusedDisplayId);
  35.             mWmService.mPolicy.setTopFocusedDisplay(topFocusedDisplayId);
  36.             ProtoLog.d(WM_DEBUG_FOCUS_LIGHT, "New topFocusedDisplayId=%d", topFocusedDisplayId);
  37.         }
  38.         return changed;
  39.     }
复制代码
  1. frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
  3. /**
  4.      * Update the focused window and make some adjustments if the focus has changed.
  5.      *
  6.      * @param mode Indicates the situation we are in. Possible modes are:
  7.      *             {@link WindowManagerService#UPDATE_FOCUS_NORMAL},
  8.      *             {@link WindowManagerService#UPDATE_FOCUS_PLACING_SURFACES},
  9.      *             {@link WindowManagerService#UPDATE_FOCUS_WILL_PLACE_SURFACES},
  10.      *             {@link WindowManagerService#UPDATE_FOCUS_REMOVING_FOCUS}
  11.      * @param updateInputWindows Whether to sync the window information to the input module.
  12.      * @param topFocusedDisplayId Display id of current top focused display.
  13.      * @return {@code true} if the focused window has changed.
  14.      */
  15.     boolean updateFocusedWindowLocked(int mode, boolean updateInputWindows,
  16.             int topFocusedDisplayId) {
  17.         WindowState newFocus = findFocusedWindowIfNeeded(topFocusedDisplayId);
  18.         if (mCurrentFocus == newFocus) {
  19.             // add by sd. fix not trust virtual display binder leak.
  20.             if (newFocus == null && !isTrusted()) {
  21.                 mWinRemovedSinceNullFocus.clear();
  22.                 mWinAddedSinceNullFocus.clear();
  23.             }
  24.             // end
  25.             return false;
  26.         }
  27.         
  28.         ProtoLog.d(WM_DEBUG_FOCUS_LIGHT, "Changing focus from %s to %s displayId=%d Callers=%s",
  29.                 mCurrentFocus, newFocus, getDisplayId(), Debug.getCallers(4));
  30.         final WindowState oldFocus = mCurrentFocus;
  31.         mCurrentFocus = newFocus;
  33.       
  34.         if (mode != UPDATE_FOCUS_WILL_ASSIGN_LAYERS) {
  35.             // If we defer assigning layers, then the caller is responsible for doing this part.
  36.             getInputMonitor().setInputFocusLw(newFocus, updateInputWindows);
  37.         }
  39.         adjustForImeIfNeeded();
  41.         // We may need to schedule some toast windows to be removed. The toasts for an app that
  42.         // does not have input focus are removed within a timeout to prevent apps to redress
  43.         // other apps' UI.
  44.         scheduleToastWindowsTimeoutIfNeededLocked(oldFocus, newFocus);
  46.         if (mode == UPDATE_FOCUS_PLACING_SURFACES) {
  47.             pendingLayoutChanges |= FINISH_LAYOUT_REDO_ANIM;
  48.         }
  50.         // Notify the accessibility manager for the change so it has the windows before the newly
  51.         // focused one starts firing events.
  52.         // TODO(b/151179149) investigate what info accessibility service needs before input can
  53.         // dispatch focus to clients.
  54.         if (mWmService.mAccessibilityController != null) {
  55.             mWmService.mH.sendMessage(PooledLambda.obtainMessage(
  56.                     this::updateAccessibilityOnWindowFocusChanged,
  57.                     mWmService.mAccessibilityController));
  58.         }
  60.         mLastFocus = mCurrentFocus;
  61.         return true;
  62.     }
复制代码
  2. frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
  4. /**
  5.      * Looking for the focused window on this display if the top focused display hasn't been
  6.      * found yet (topFocusedDisplayId is INVALID_DISPLAY) or per-display focused was allowed.
  7.      *
  8.      * @param topFocusedDisplayId Id of the top focused display.
  9.      * @return The focused window or null if there isn't any or no need to seek.
  10.      */
  11.     WindowState findFocusedWindowIfNeeded(int topFocusedDisplayId) {
  12.         return (mWmService.mPerDisplayFocusEnabled || topFocusedDisplayId == INVALID_DISPLAY)
  13.                     ? findFocusedWindow() : null;
  14.     }
  16.     WindowState findFocusedWindow() {
  17.         mTmpWindow = null;
  19.         forAllWindows(mFindFocusedWindow, true /* traverseTopToBottom */);
  21.         if (mTmpWindow == null) {
  22.             ProtoLog.v(WM_DEBUG_FOCUS_LIGHT, "findFocusedWindow: No focusable windows, display=%d",
  23.                     getDisplayId());
  24.             return null;
  25.         }
  26.         return mTmpWindow;
  27.     }
复制代码
如下会从上到下遍历该DisplayContent上的全部WindowState,如果找到符合条件的窗口，那么该窗口，则将该窗口生存在mTmpWindow，并返回ture。由于是从上往下遍历，以是层级越高的窗口越偶然机成为核心窗口。
起首不满足canReceiveKeys条件的是不能成为核心窗口的.其他成为核心窗口的条件不赘述。
  1. frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
  3. private final ToBooleanFunction<WindowState> mFindFocusedWindow = w -> {
  4.         final ActivityRecord focusedApp = mFocusedApp;
  5.         ProtoLog.v(WM_DEBUG_FOCUS, "Looking for focus: %s, flags=%d, canReceive=%b, reason=%s",
  6.                 w, w.mAttrs.flags, w.canReceiveKeys(),
  7.                 w.canReceiveKeysReason(false /* fromUserTouch */));
  8.         // 焦点窗口首先要满足 canReceiveKeys，否则无法成为焦点窗口。
  9.         if (!w.canReceiveKeys()) {
  10.             return false;
  11.         }
  13.         // 输入法相关,暂时不分析
  14.         if (w.mIsImWindow && w.isChildWindow() && (mImeLayeringTarget == null
  15.                 || !mImeLayeringTarget.getRequestedVisibility(ITYPE_IME))) {
  16.             return false;
  17.         }
  18.         if (w.mAttrs.type == TYPE_INPUT_METHOD_DIALOG && mImeLayeringTarget != null
  19.                 && !mImeLayeringTarget.getRequestedVisibility(ITYPE_IME)
  20.                 && mImeLayeringTarget.isAnimating(PARENTS | TRANSITION,
  21.                 ANIMATION_TYPE_APP_TRANSITION)) {
  22.             return false;
  23.         }
  24.         // 获取当前窗口所属的ActivityRecord
  25.         final ActivityRecord activity = w.mActivityRecord;
  26.         //
  27.         if (focusedApp == null) {
  28.             ProtoLog.v(WM_DEBUG_FOCUS_LIGHT,
  29.                     "findFocusedWindow: focusedApp=null using new focus @ %s", w);
  30.             mTmpWindow = w;
  31.             return true;
  32.         }
  34.         if (!focusedApp.windowsAreFocusable()) {
  35.             // Current focused app windows aren't focusable...
  36.             ProtoLog.v(WM_DEBUG_FOCUS_LIGHT, "findFocusedWindow: focusedApp windows not"
  37.                     + " focusable using new focus @ %s", w);
  38.             mTmpWindow = w;
  39.             return true;
  40.         }
  42.         // Descend through all of the app tokens and find the first that either matches
  43.         // win.mActivityRecord (return win) or mFocusedApp (return null).
  44.         //如果当前所遍历到的窗口的层级位于focusedApp之下且该窗口属于activity的窗口，则把焦点窗口置为null。然后返回。
  45.         if (activity != null && w.mAttrs.type != TYPE_APPLICATION_STARTING) {
  46.             if (focusedApp.compareTo(activity) > 0) {
  47.                 // App root task below focused app root task. No focus for you!!!
  48.                 ProtoLog.v(WM_DEBUG_FOCUS_LIGHT,
  49.                         "findFocusedWindow: Reached focused app=%s", focusedApp);
  50.                 mTmpWindow = null;
  51.                 return true;
  52.             }
  53.         }
  54.         // 以上条件都不符合
  55.         ProtoLog.v(WM_DEBUG_FOCUS_LIGHT, "findFocusedWindow: Found new focus @ %s", w);
  56.         mTmpWindow = w;
  57.         return true;
  58.     };
复制代码
canReceiveKeys == true的条件
  1. frameworks/base/services/core/java/com/android/server/wm/WindowState.java
  3. boolean canReceiveKeys() {
  4.         return canReceiveKeys(false /* fromUserTouch */);
  5.     }
  7.     public String canReceiveKeysReason(boolean fromUserTouch) {
  8.         return "fromTouch= " + fromUserTouch
  9.                 + " isVisibleOrAdding=" + isVisibleOrAdding()
  10.                 + " mViewVisibility=" + mViewVisibility
  11.                 + " mRemoveOnExit=" + mRemoveOnExit
  12.                 + " flags=" + mAttrs.flags
  13.                 + " appWindowsAreFocusable="
  14.                 + (mActivityRecord == null || mActivityRecord.windowsAreFocusable(fromUserTouch))
  15.                 + " canReceiveTouchInput=" + canReceiveTouchInput()
  16.                 + " displayIsOnTop=" + getDisplayContent().isOnTop()
  17.                 + " displayIsTrusted=" + getDisplayContent().isTrusted();
  18.     }
  20.     public boolean canReceiveKeys(boolean fromUserTouch) {
  21.         final boolean canReceiveKeys = isVisibleOrAdding()
  22.                 && (mViewVisibility == View.VISIBLE) && !mRemoveOnExit
  23.                 && ((mAttrs.flags & WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE) == 0)
  24.                 && (mActivityRecord == null || mActivityRecord.windowsAreFocusable(fromUserTouch))
  25.                 && canReceiveTouchInput();
  26.         if (!canReceiveKeys) {
  27.             return false;
  28.         }
  29.         // Do not allow untrusted virtual display to receive keys unless user intentionally
  30.         // touches the display.
  31.         return fromUserTouch || getDisplayContent().isOnTop()
  32.                 || getDisplayContent().isTrusted();
  33.     }
  35.     @Override
  36.     public boolean canShowWhenLocked() {
  37.         final boolean showBecauseOfActivity =
  38.                 mActivityRecord != null && mActivityRecord.canShowWhenLocked();
  39.         final boolean showBecauseOfWindow = (getAttrs().flags & FLAG_SHOW_WHEN_LOCKED) != 0;
  40.         return showBecauseOfActivity || showBecauseOfWindow;
  41.     }
  43.     /**
  44.      * @return {@code true} if this window can receive touches based on among other things,
  45.      * windowing state and recents animation state.
  46.      **/
  47.     boolean canReceiveTouchInput() {
  48.         if (mActivityRecord == null  || mActivityRecord.getTask() == null) {
  49.             return true;
  50.         }
  52.         return !mActivityRecord.getTask().getRootTask().shouldIgnoreInput()
  53.                 && mActivityRecord.mVisibleRequested
  54.                 && !isRecentsAnimationConsumingAppInput();
  55.     }
复制代码
回到DisplayCpntent.updateFocusedWindowLocked
  1. frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
  3. /**
  4.      * Update the focused window and make some adjustments if the focus has changed.
  5.      *
  6.      * @param mode Indicates the situation we are in. Possible modes are:
  7.      *             {@link WindowManagerService#UPDATE_FOCUS_NORMAL},
  8.      *             {@link WindowManagerService#UPDATE_FOCUS_PLACING_SURFACES},
  9.      *             {@link WindowManagerService#UPDATE_FOCUS_WILL_PLACE_SURFACES},
  10.      *             {@link WindowManagerService#UPDATE_FOCUS_REMOVING_FOCUS}
  11.      * @param updateInputWindows Whether to sync the window information to the input module.
  12.      * @param topFocusedDisplayId Display id of current top focused display.
  13.      * @return {@code true} if the focused window has changed.
  14.      */
  15.      
  16.     boolean updateFocusedWindowLocked(int mode, boolean updateInputWindows,
  17.             int topFocusedDisplayId) {
  18.         // 此时的newFocus为找到的新焦点窗口
  19.         WindowState newFocus = findFocusedWindowIfNeeded(topFocusedDisplayId);
  20.         // 如该Displaycontent上的焦点窗口没有发生变化，则不用去更新，返回
  21.         if (mCurrentFocus == newFocus) {
  22.             // add by sd. fix not trust virtual display binder leak.
  23.             if (newFocus == null && !isTrusted()) {
  24.                 mWinRemovedSinceNullFocus.clear();
  25.                 mWinAddedSinceNullFocus.clear();
  26.             }
  27.             // end
  28.             return false;
  29.         }
  30.         
  31.         ProtoLog.d(WM_DEBUG_FOCUS_LIGHT, "Changing focus from %s to %s displayId=%d Callers=%s",
  32.                 mCurrentFocus, newFocus, getDisplayId(), Debug.getCallers(4));
  33.         final WindowState oldFocus = mCurrentFocus;
  34.         mCurrentFocus = newFocus;
  36.        // 如果更新模式不是UPDATE_FOCUS_WILL_ASSIGN_LAYERS，则把刚才选举出的焦点窗口设置给getInputMonitor，随后会交给surfaceflinger。
  37.         if (mode != UPDATE_FOCUS_WILL_ASSIGN_LAYERS) {
  38.             // If we defer assigning layers, then the caller is responsible for doing this part.
  39.             getInputMonitor().setInputFocusLw(newFocus, updateInputWindows);
  40.         }
  42.         .....
  43.         mLastFocus = mCurrentFocus;
  44.         return true;
  45.     }
复制代码
  1. frameworks/base/services/core/java/com/android/server/wm/InputMonitor.java
  3. void setInputFocusLw(WindowState newWindow, boolean updateInputWindows) {
  4.         ProtoLog.v(WM_DEBUG_FOCUS_LIGHT, "Input focus has changed to %s display=%d",
  5.                 newWindow, mDisplayId);
  6.         final IBinder focus = newWindow != null ? newWindow.mInputChannelToken : null;
  7.         // 没有发生改变 返回
  8.         if (focus == mInputFocus) {
  9.             return;
  10.         }
  12.         if (newWindow != null && newWindow.canReceiveKeys()) {
  13.             // Displaying a window implicitly causes dispatching to be unpaused.
  14.             // This is to protect against bugs if someone pauses dispatching but
  15.             // forgets to resume.
  16.             newWindow.mToken.paused = false;
  17.         }
  18.         // 设置 mUpdateInputWindowsNeeded = true;
  19.         setUpdateInputWindowsNeededLw();
  21.         if (updateInputWindows) {
  22.             updateInputWindowsLw(false /*force*/);
  23.         }
  24.     }
复制代码
  1. frameworks/base/services/core/java/com/android/server/wm/InputMonitor.java
  3. /* Updates the cached window information provided to the input */
  4. void updateInputWindowsLw(boolean force) {
  5.         if (!force && !mUpdateInputWindowsNeeded) {
  6.             return;
  7.         }
  8.         scheduleUpdateInputWindows();
  9.     }
  11.     private void scheduleUpdateInputWindows() {
  12.         if (mDisplayRemoved) {
  13.             return;
  14.         }
  16.         if (!mUpdateInputWindowsPending) {
  17.             mUpdateInputWindowsPending = true;
  18.             mHandler.post(mUpdateInputWindows);
  19.         }
  20.     }
复制代码
  1. frameworks/base/services/core/java/com/android/server/wm/InputMonitor.java
  3. private class UpdateInputWindows implements Runnable {
  4.         @Override
  5.         public void run() {
  6.             synchronized (mService.mGlobalLock) {
  7.                 mUpdateInputWindowsPending = false;
  8.                 mUpdateInputWindowsNeeded = false;
  10.                 if (mDisplayRemoved) {
  11.                     return;
  12.                 }
  14.                 // Populate the input window list with information about all of the windows that
  15.                 // could potentially receive input.
  16.                 // As an optimization, we could try to prune the list of windows but this turns
  17.                 // out to be difficult because only the native code knows for sure which window
  18.                 // currently has touch focus.
  20.                 // If there's a drag in flight, provide a pseudo-window to catch drag input
  21.                 final boolean inDrag = mService.mDragDropController.dragDropActiveLocked();
  23.                 // Add all windows on the default display.
  24.                 mUpdateInputForAllWindowsConsumer.updateInputWindows(inDrag);
  25.             }
  26.         }
  27.     }
复制代码
  1. frameworks/base/services/core/java/com/android/server/wm/InputMonitor.java
  3. private void updateInputWindows(boolean inDrag) {
  4.             Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "updateInputWindows");
  6.             mPipInputConsumer = getInputConsumer(INPUT_CONSUMER_PIP);
  7.             mWallpaperInputConsumer = getInputConsumer(INPUT_CONSUMER_WALLPAPER);
  8.             mRecentsAnimationInputConsumer = getInputConsumer(INPUT_CONSUMER_RECENTS_ANIMATION);
  10.             mAddPipInputConsumerHandle = mPipInputConsumer != null;
  11.             mAddWallpaperInputConsumerHandle = mWallpaperInputConsumer != null;
  12.             mAddRecentsAnimationInputConsumerHandle = mRecentsAnimationInputConsumer != null;
  14.             mDisableWallpaperTouchEvents = false;
  15.             mInDrag = inDrag;
  17.             resetInputConsumers(mInputTransaction);
  18.             // 遍历对应屏幕上的所有WindowState，更新他们的InputWindowHandle，随后发送给SurfaceFlinger
  19.             mDisplayContent.forAllWindows(this, true /* traverseTopToBottom */);
  20.             // 更新焦点窗口信息给SurfaceFlinger
  21.             updateInputFocusRequest(mRecentsAnimationInputConsumer);
  23.             if (!mUpdateInputWindowsImmediately) {
  24.                 mDisplayContent.getPendingTransaction().merge(mInputTransaction);
  25.                 mDisplayContent.scheduleAnimation();
  26.             }
  28.             Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
  29.         }
复制代码
更新全部窗口的InputWindowHandle信息
  1. public void accept(WindowState w) {
  2.             ......
  3.             if (w.mWinAnimator.hasSurface()) {
  4.                 //更新该窗口的inputWindowHandle信息
  5.                 populateInputWindowHandle(inputWindowHandle, w);
  6.                 // 将更新后的inputWindowHandle发送给Surfaceflinger
  7.                 setInputWindowInfoIfNeeded(mInputTransaction,
  8.                         w.mWinAnimator.mSurfaceController.mSurfaceControl, inputWindowHandle);
  9.             }
  10.         }
  11.     }
复制代码
更新全部核心窗口
  1. private void updateInputFocusRequest(InputConsumerImpl recentsAnimationInputConsumer) {
  2.         final WindowState focus = mDisplayContent.mCurrentFocus;
  3.         ......
  4.         requestFocus(focusToken, focus.getName());
  5.     }
  6. }
复制代码
  2. private void requestFocus(IBinder focusToken, String windowName) {
  3.         if (focusToken == mInputFocus) {
  4.             return;
  5.         }
  7.         mInputFocus = focusToken;
  8.         mInputTransaction.setFocusedWindow(mInputFocus, windowName, mDisplayId);
  9.         EventLog.writeEvent(LOGTAG_INPUT_FOCUS, "Focus request " + windowName,
  10.                 "reason=UpdateInputWindows");
  11.         ProtoLog.v(WM_DEBUG_FOCUS_LIGHT, "Focus requested for window=%s", windowName);
  12.     }
复制代码
二.SurfaceFlinger端革新流程

SurfaceFlinger中省略了处置处罚Trasnaction的流程,直接分析SurfaceFlinger向InputDispatcher更新layer的信息和核心信息.
1.网络windowInfos 遍历SurfaceFlinger 当前绘制的Layer聚集mDrawingState,当对应的layer有inputChannel时把该layer的 信息封装后 生存在 windowInfos. 网络 全部的display信息,添加到 displayInfos中.
2.更新 WindowInfo等信息 到相干的监听,InputDispatcher 便是此中的监听之一
3.更新 FocusedWindow信息至 inputFlinger.
  1. void SurfaceFlinger::updateInputFlinger() {
  2.     ATRACE_CALL();
  3.     if (!mInputFlinger) {
  4.         return;
  5.     }
  7.     std::vector<WindowInfo> windowInfos;
  8.     std::vector<DisplayInfo> displayInfos;
  9.     bool updateWindowInfo = false;
  10.     // 只有当有mVisibleRegionsDirty || mInputInfoChanged变化的之后才去收集   windowInfos 和displayInfos
  11.     if (mVisibleRegionsDirty || mInputInfoChanged) {
  12.         mInputInfoChanged = false;
  13.         updateWindowInfo = true;
  14.         // 1.收集windowInfos 遍历SurfaceFlinger 当前绘制的Layer集合mDrawingState,当对应的layer有inputChannel时
  15.         // 把该layer的 信息封装后 保存在 windowInfos
  16.         // 2.收集 所有的display信息,添加到 displayInfos中
  17.         buildWindowInfos(windowInfos, displayInfos);
  18.     }
  19.     // 当 上层 有请求 焦点窗口时, mInputWindowCommands 不为空
  20.     if (!updateWindowInfo && mInputWindowCommands.empty()) {
  21.         return;
  22.     }
  24.     BackgroundExecutor::getInstance().sendCallbacks({[updateWindowInfo,
  25.                                                       windowInfos = std::move(windowInfos),
  26.                                                       displayInfos = std::move(displayInfos),
  27.                                                       inputWindowCommands =
  28.                                                               std::move(mInputWindowCommands),
  29.                                                       inputFlinger = mInputFlinger, this]() {
  30.         ATRACE_NAME("BackgroundExecutor::updateInputFlinger");
  31.         if (updateWindowInfo) {
  32.             // 更新 WindowInfo等信息 到相关的监听,InputDispatcher 便是其中的监听之一
  33.             mWindowInfosListenerInvoker->windowInfosChanged(windowInfos, displayInfos,
  34.                                                             inputWindowCommands.syncInputWindows);
  35.         } else if (inputWindowCommands.syncInputWindows) { // syncInputWindows 在特殊情况下为 false,普通更新信息 都为false
  36.             // If the caller requested to sync input windows, but there are no
  37.             // changes to input windows, notify immediately.
  38.             windowInfosReported();
  39.         }
  40.         // 更新 FocusedWindow信息至 inputFlinger,当上层有请求新的焦点窗口时 inputWindowCommands.focusRequests 就有值
  41.         for (const auto& focusRequest : inputWindowCommands.focusRequests) {
  42.             inputFlinger->setFocusedWindow(focusRequest);
  43.         }
  44.     }});
  46.     mInputWindowCommands.clear();
  47. }
复制代码
至此Surfaceflinger的相干分析完毕.
三.InputFlinger端核心革新流程

1.更新InputFlinger端的InputWindowInfo信息

1.更新Display信息到 mDisplayInfos
2.更新 WindowInfoHandle 到 mWindowHandlesByDisplay中
  1. frameworks/native/services/inputflinger/dispatcher/InputDispatcher.cpp
  3. void InputDispatcher::onWindowInfosChanged(const gui::WindowInfosUpdate& update) {
  4.     // The listener sends the windows as a flattened array. Separate the windows by display for
  5.     // more convenient parsing.
  6.     std::unordered_map<int32_t, std::vector<sp<WindowInfoHandle>>> handlesPerDisplay;
  7.     for (const auto& info : update.windowInfos) {
  8.         handlesPerDisplay.emplace(info.displayId, std::vector<sp<WindowInfoHandle>>());
  9.         handlesPerDisplay[info.displayId].push_back(sp<WindowInfoHandle>::make(info));
  10.     }
  12.     { // acquire lock
  13.         std::scoped_lock _l(mLock);
  15.         // Ensure that we have an entry created for all existing displays so that if a displayId has
  16.         // no windows, we can tell that the windows were removed from the display.
  17.         for (const auto& [displayId, _] : mWindowHandlesByDisplay) {
  18.             handlesPerDisplay[displayId];
  19.         }
  20.                
  21.                
  22.                 // 更新Display信息到 mDisplayInfos
  23.         mDisplayInfos.clear();
  24.         for (const auto& displayInfo : update.displayInfos) {
  25.             mDisplayInfos.emplace(displayInfo.displayId, displayInfo);
  26.         }
  27.         
  28.         // 将会更新 WindowInfoHandle 到 mWindowHandlesByDisplay中
  29.         for (const auto& [displayId, handles] : handlesPerDisplay) {
  30.             setInputWindowsLocked(handles, displayId);
  31.         }
  33.         if (update.vsyncId < mWindowInfosVsyncId) {
  34.             ALOGE("Received out of order window infos update. Last update vsync id: %" PRId64
  35.                   ", current update vsync id: %" PRId64,
  36.                   mWindowInfosVsyncId, update.vsyncId);
  37.         }
  38.         mWindowInfosVsyncId = update.vsyncId;
  39.     }
  40.     // Wake up poll loop since it may need to make new input dispatching choices.
  41.     mLooper->wake();
  42. }
复制代码
2.更新InputFlinger端的核心信息点窗口：

该过程中重要做了两件事：

  • 在更新 屏幕–核心map，返回更新结果的布局体，struct FocusChanges {       sp<IBinder> oldFocus;       sp<IBinder> newFocus;       int32_t displayId;       std::string reason;
    可见该布局体包罗原始核心信息，更新的核心窗口信息，屏幕id，核心改变缘故起因。
  • 把更新结果关照到窗口端
  1. frameworks/native/services/inputflinger/dispatcher/InputDispatcher.cpp
  2. void InputDispatcher::setFocusedWindow(const FocusRequest& request) {
  3.     { // acquire lock
  4.         std::scoped_lock _l(mLock);
  5.         // 去更新对应屏幕上的焦点信息，并返回更新结果的结构体
  6.         std::optional<FocusResolver::FocusChanges> changes =
  7.                 mFocusResolver.setFocusedWindow(request, getWindowHandlesLocked(request.displayId));
  8.         // change不为空，说明更新成功，接下把更新结果通知到窗口端
  9.         if (changes) {
  10.             onFocusChangedLocked(*changes);
  11.         }
  12.     } // release lock
  13.     // Wake up poll loop since it may need to make new input dispatching choices.
  14.     mLooper->wake();
  15. }
复制代码
2.1 在更新 屏幕–核心map，返回更新结果的布局体
  1. frameworks/native/services/inputflinger/dispatcher/FocusResolver.cpp
  3. std::optional<FocusResolver::FocusChanges> FocusResolver::setFocusedWindow(
  4.         const FocusRequest& request, const std::vector<sp<InputWindowHandle>>& windows) {
  5.     const int32_t displayId = request.displayId;
  6.     const sp<IBinder> currentFocus = getFocusedWindowToken(displayId);
  7.     if (currentFocus == request.token) {
  8.         ALOGD_IF(DEBUG_FOCUS,
  9.                  "setFocusedWindow %s on display %" PRId32 " ignored, reason: already focused",
  10.                  request.windowName.c_str(), displayId);
  11.         return std::nullopt;
  12.     }
  14.     // request.focusedToken 一般为null，跳过
  15.     if (request.focusedToken) {
  16.         if (currentFocus != request.focusedToken) {
  17.             ALOGW("setFocusedWindow %s on display %" PRId32
  18.                   " ignored, reason: focusedToken %s is not focused",
  19.                   request.windowName.c_str(), displayId, request.focusedWindowName.c_str());
  20.             return std::nullopt;
  21.         }
  22.         // 判断新请求的窗口是否可以成为焦点窗口
  23.         Focusability result = isTokenFocusable(request.token, windows);
  24.         if (result == Focusability::OK) {
  25.             return updateFocusedWindow(displayId, "setFocusedWindow with focus check",
  26.                                        request.token, request.windowName);
  27.         }
  28.         ALOGW("setFocusedWindow %s on display %" PRId32 " ignored, reason: %s",
  29.               request.windowName.c_str(), displayId, NamedEnum::string(result).c_str());
  30.         return std::nullopt;
  31.     }
  33.     Focusability result = isTokenFocusable(request.token, windows);
  34.     // Update focus request. The focus resolver will always try to handle this request if there is
  35.     // no focused window on the display.
  36.     mFocusRequestByDisplay[displayId] = request;
  37.     mLastFocusResultByDisplay[displayId] = result;
  39.     if (result == Focusability::OK) {
  40.         return updateFocusedWindow(displayId, "setFocusedWindow", request.token,
  41.                                    request.windowName);
  42.     }
  44.     // The requested window is not currently focusable. Wait for the window to become focusable
  45.     // but remove focus from the current window so that input events can go into a pending queue
  46.     // and be sent to the window when it becomes focused.
  47.     return updateFocusedWindow(displayId, "Waiting for window because " + NamedEnum::string(result),
  48.                                nullptr);
  49. }
复制代码
如下将会更新对应屏幕上的核心窗口：
在更新完 屏幕–核心map后，返回更新结果的布局体，struct FocusChanges {         sp<IBinder> oldFocus;         sp<IBinder> newFocus;         int32_t displayId;         std::string reason;
可见该布局体包罗原始核心信息，更新的核心窗口信息，屏幕id，核心改变缘故起因。
  1. frameworks/native/services/inputflinger/dispatcher/FocusResolver.cpp
  3. std::optional<FocusResolver::FocusChanges> FocusResolver::updateFocusedWindow(
  4.         int32_t displayId, const std::string& reason, const sp<IBinder>& newFocus,
  5.         const std::string& tokenName) {
  6.     //获取对应屏幕上的旧的焦点信息
  7.     sp<IBinder> oldFocus = getFocusedWindowToken(displayId);
  8.     // 没有发生变化 返回
  9.     if (newFocus == oldFocus) {
  10.         return std::nullopt;
  11.     }
  12.     if (newFocus) {
  13.         // 如果设置的新焦点不为空，则更新 屏幕--焦点map
  14.         mFocusedWindowTokenByDisplay[displayId] = {tokenName, newFocus};
  15.     } else {
  16.         // 如果设置的新焦点为空，则删除屏幕--焦点map中该屏幕的焦点信息
  17.         mFocusedWindowTokenByDisplay.erase(displayId);
  18.     }
  19.     /* 返回struct FocusChanges {
  20.         sp<IBinder> oldFocus;
  21.         sp<IBinder> newFocus;
  22.         int32_t displayId;
  23.         std::string reason;
  24.     };结构体*/
  25.     return {{oldFocus, newFocus, displayId, reason}};
  26. }
复制代码
2.2 把更新结果关照到窗口端

如被骗InputFlinger的核心窗口完成改变时将会调用到该函数：

  • 天生核心脱离旧的核心窗口的天生，随后该事故会发给旧的核心窗口。
  • 天生核心进入新的窗口的事故，这个事故稍后会发送给新的核心窗口。
  1. frameworks/native/services/inputflinger/dispatcher/InputDispatcher.cpp
  3. void InputDispatcher::onFocusChangedLocked(const FocusResolver::FocusChanges& changes) {
  4.     if (changes.oldFocus) {
  5.         // 如果旧的焦点窗口的InputChannel还可用
  6.         std::shared_ptr<InputChannel> focusedInputChannel = getInputChannelLocked(changes.oldFocus);
  7.         if (focusedInputChannel) {
  8.             CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS,
  9.                                        "focus left window");
  10.             synthesizeCancelationEventsForInputChannelLocked(focusedInputChannel, options);
  11.             // 入队一个 焦点从旧的窗口撤出的事件，这个事件稍后会发送给旧的焦点窗口
  12.             enqueueFocusEventLocked(changes.oldFocus, false /*hasFocus*/, changes.reason);
  13.         }
  14.     }
  15.     if (changes.newFocus) {
  16.         // 新的焦点窗口不为空，入队一个 焦点进入新的窗口的事件，这个事件稍后会发送给新的焦点窗口
  17.         enqueueFocusEventLocked(changes.newFocus, true /*hasFocus*/, changes.reason);
  18.     }
复制代码
发送InputDiapatchar端核心改变的事故给应用端，紧接着会打印对应的event log:
核心撤出: input_focus: [Focus leaving 7d52ce4 NotificationShade (server),reason=setFocusedWindow]
核心进入: input_foc: [Focus entering 106fc21 com.android.settings/com.android.settings.Settings$ConnectedDeviceDashboardActivity (server),reason=setFocusedWind
  1. frameworks/native/services/inputflinger/dispatcher/InputDispatcher.cpp
  2. void InputDispatcher::(nsecs_t currentTime, std::shared_ptr<FocusEntry> entry) {
  3.     std::shared_ptr<InputChannel> channel = getInputChannelLocked(entry->connectionToken);
  4.     if (channel == nullptr) {
  5.         return; // Window has gone away
  6.     }
  7.     InputTarget target;
  8.     target.inputChannel = channel;
  9.     target.flags = InputTarget::FLAG_DISPATCH_AS_IS;
  10.     entry->dispatchInProgress = true;
  11.     std::string message = std::string("Focus ") + (entry->hasFocus ? "entering " : "leaving ") +
  12.             channel->getName();
  13.     std::string reason = std::string("reason=").append(entry->reason);
  14.     // 打印event log
  15.     android_log_event_list(LOGTAG_INPUT_FOCUS) << message << reason << LOG_ID_EVENTS;
  16.     // 分发焦点事件
  17.     dispatchEventLocked(currentTime, entry, {target});
  18. }
复制代码
至此 ，分析完毕
增补更新核心app的流程
  1. 解锁时:
  2. newFocus:ActivityRecord{807c8eb u0 com.android.launcher3/.uioverrides.QuickstepLauncher} t7}
  3. java.lang.Exception
  4.         at com.android.server.wm.DisplayContent.setFocusedApp(DisplayContent.java:3848)
  5.         at com.android.server.wm.ActivityTaskManagerService.setLastResumedActivityUncheckLocked(ActivityTaskManagerService.java:
  6.         at com.android.server.wm.ActivityTaskSupervisor.updateTopResumedActivityIfNeeded(ActivityTaskSupervisor.java:2130)
  7.         at com.android.server.wm.TaskFragment.setResumedActivity(TaskFragment.java:520)
  8.         at com.android.server.wm.TaskFragment.onActivityStateChanged(TaskFragment.java:816)
  9.         at com.android.server.wm.ActivityRecord.setState(ActivityRecord.java:5639)
  10.         at com.android.server.wm.TaskFragment.resumeTopActivity(TaskFragment.java:1421)
  11.         at com.android.server.wm.Task.resumeTopActivityInnerLocked(Task.java:5017)
  12.         at com.android.server.wm.Task.resumeTopActivityUncheckedLocked(Task.java:4947)
  13.         at com.android.server.wm.Task.resumeTopActivityUncheckedLocked(Task.java:4966)
  14.         at com.android.server.wm.Task.resumeTopActivityUncheckedLocked(Task.java:4998)
  15.         at com.android.server.wm.RootWindowContainer.lambda$applySleepTokens$20(RootWindowContainer.java:2369)
  16.         at com.android.server.wm.RootWindowContainer.$r8$lambda$95qC-1ZUnz4HFKq9TM8jsgele88(Unknown Source:0)
  17.         at com.android.server.wm.RootWindowContainer$$ExternalSyntheticLambda18.accept(Unknown Source:8)
  18.         at com.android.server.wm.Task.forAllRootTasks(Task.java:3182)
  19.         at com.android.server.wm.WindowContainer.forAllRootTasks(WindowContainer.java:2066)
  20.         at com.android.server.wm.WindowContainer.forAllRootTasks(WindowContainer.java:2066)
  21.         at com.android.server.wm.WindowContainer.forAllRootTasks(WindowContainer.java:2066)
  22.         at com.android.server.wm.WindowContainer.forAllRootTasks(WindowContainer.java:2066)
  23.         at com.android.server.wm.WindowContainer.forAllRootTasks(WindowContainer.java:2066)
  24.         at com.android.server.wm.WindowContainer.forAllRootTasks(WindowContainer.java:2066)
  25.         at com.android.server.wm.WindowContainer.forAllRootTasks(WindowContainer.java:2059)
  26.         at com.android.server.wm.RootWindowContainer.applySleepTokens(RootWindowContainer.java:2354)
  27.         at com.android.server.wm.ActivityTaskManagerService.updateSleepIfNeededLocked(ActivityTaskManagerService.java:4787)
  28.         at com.android.server.wm.RootWindowContainer.removeSleepToken(RootWindowContainer.java:2624)
  29.         at com.android.server.wm.ActivityTaskManagerService$SleepTokenAcquirerImpl.release(ActivityTaskManagerService.java:4762)
  30.         at com.android.server.wm.KeyguardController.updateKeyguardSleepToken(KeyguardController.java:518)
  31.         at com.android.server.wm.KeyguardController.updateKeyguardSleepToken(KeyguardController.java:509)
  32.         at com.android.server.wm.KeyguardController.keyguardGoingAway(KeyguardController.java:270)
  33.         at com.android.server.wm.ActivityTaskManagerService.lambda$keyguardGoingAway$4(ActivityTaskManagerService.java:3479)
  34.         at com.android.server.wm.ActivityTaskManagerService.$r8$lambda$3ir4F8YeWgNCplL0b7P4iAJf_NI(Unknown Source:0)
  35.         at com.android.server.wm.ActivityTaskManagerService$$ExternalSyntheticLambda1.accept(Unknown Source:6)
  36.         at com.android.server.wm.RootWindowContainer.forAllDisplays(RootWindowContainer.java:1258)
  37.         at com.android.server.wm.ActivityTaskManagerService.keyguardGoingAway(ActivityTaskManagerService.java:3478)
  38.         at android.app.IActivityTaskManager$Stub.onTransact(IActivityTaskManager.java:1721)
  39.         at com.android.server.wm.ActivityTaskManagerService.onTransact(ActivityTaskManagerService.java:5335)
  40.         at android.os.Binder.execTransactInternal(Binder.java:1280)
  41.         at android.os.Binder.execTransact(Binder.java:1244)
复制代码
冷启动应用时:
  1. newFocus:ActivityRecord{39b5e82 u0 com.android.settings/.Settings} t8}
  2. java.lang.Exception
  3.         at com.android.server.wm.DisplayContent.setFocusedApp(DisplayContent.java:3848)
  4.         at com.android.server.wm.ActivityTaskManagerService.setLastResumedActivityUncheckLocked(ActivityTaskManagerService.java:4716)
  5.         at com.android.server.wm.ActivityTaskSupervisor.updateTopResumedActivityIfNeeded(ActivityTaskSupervisor.java:2130)
  6.         at com.android.server.wm.TaskFragment.setResumedActivity(TaskFragment.java:520)
  7.         at com.android.server.wm.TaskFragment.onActivityStateChanged(TaskFragment.java:816)
  8.         at com.android.server.wm.ActivityRecord.setState(ActivityRecord.java:5639)
  9.         at com.android.server.wm.Task.minimalResumeActivityLocked(Task.java:4760)
  10.         at com.android.server.wm.ActivityTaskSupervisor.realStartActivityLocked(ActivityTaskSupervisor.java:981)
  11.         at com.android.server.wm.ActivityTaskSupervisor.startSpecificActivity(ActivityTaskSupervisor.java:1048)
  12.         at com.android.server.wm.TaskFragment.resumeTopActivity(TaskFragment.java:1542)
  13.         at com.android.server.wm.Task.resumeTopActivityInnerLocked(Task.java:5017)
  14.         at com.android.server.wm.Task.resumeTopActivityUncheckedLocked(Task.java:4947)
  15.         at com.android.server.wm.RootWindowContainer.resumeFocusedTasksTopActivities(RootWindowContainer.java:2281)
  16.         at com.android.server.wm.RootWindowContainer.resumeFocusedTasksTopActivities(RootWindowContainer.java:2267)
  17.         at com.android.server.wm.TaskFragment.completePause(TaskFragment.java:1800)
  18.         at com.android.server.wm.ActivityRecord.activityPaused(ActivityRecord.java:6243)
  19.         at com.android.server.wm.ActivityClientController.activityPaused(ActivityClientController.java:190)
  20.         at android.app.IActivityClientController$Stub.onTransact(IActivityClientController.java:609)
  21.         at com.android.server.wm.ActivityClientController.onTransact(ActivityClientController.java:127)
  22.         at android.os.Binder.execTransactInternal(Binder.java:1280)
  23.         at android.os.Binder.execTransact(Binder.java:1244)
复制代码
回复

使用道具 举报

返回列表

傲渊山岳
+ 我要发帖

登录后关闭弹窗

登录参与点评抽奖  加入IT实名职场社区
去登录
快速回复 返回顶部 返回列表