Make per-display focus optional (1/2)
In general cases, we don't have multiple input methods simultaneously.
So that it may not make sense to have multiple focused window in the
system. Especially when there are multiple blinking cursors of input
boxes on different displays, the user may not be able to know which
input box can receive key events. In these cases, we let the system
has only one focused window.
In some cases, there can be multiple input methods simultaneously (one
for each display). To enable multiple users to interact with the
corresponding displays at the same time, we should let the system have
per-display focused window in these cases.
This CL makes per-display focus optional, and also reverts ag/5312657
Fix: 120241480
Fix: 120790099
Test: atest ActivityManagerMultiDisplayTests \
CtsWindowManagerDeviceTestCases \
WmTests
Change-Id: Ie030eed523599b217060887171710692d050e5d8
diff --git a/services/core/java/com/android/server/policy/PhoneWindowManager.java b/services/core/java/com/android/server/policy/PhoneWindowManager.java
index 3ba1155..ebe202e 100644
--- a/services/core/java/com/android/server/policy/PhoneWindowManager.java
+++ b/services/core/java/com/android/server/policy/PhoneWindowManager.java
@@ -599,6 +599,9 @@
private boolean mAodShowing;
+ private boolean mPerDisplayFocusEnabled = false;
+ private int mTopFocusedDisplayId = INVALID_DISPLAY;
+
private static final int MSG_ENABLE_POINTER_LOCATION = 1;
private static final int MSG_DISABLE_POINTER_LOCATION = 2;
private static final int MSG_DISPATCH_MEDIA_KEY_WITH_WAKE_LOCK = 3;
@@ -1811,6 +1814,9 @@
mHandleVolumeKeysInWM = mContext.getResources().getBoolean(
com.android.internal.R.bool.config_handleVolumeKeysInWindowManager);
+ mPerDisplayFocusEnabled = mContext.getResources().getBoolean(
+ com.android.internal.R.bool.config_perDisplayFocusEnabled);
+
readConfigurationDependentBehaviors();
mAccessibilityManager = (AccessibilityManager) context.getSystemService(
@@ -2542,6 +2548,20 @@
/** {@inheritDoc} */
@Override
public long interceptKeyBeforeDispatching(WindowState win, KeyEvent event, int policyFlags) {
+ final long result = interceptKeyBeforeDispatchingInner(win, event, policyFlags);
+ if (result == 0 && !mPerDisplayFocusEnabled
+ && event.getDisplayId() != mTopFocusedDisplayId) {
+ // Someone tries to send a key event to a display which doesn't have a focused window.
+ // We drop the event here, or it will cause ANR.
+ // TODO (b/121057974): The user may be confused about why the key doesn't work, so we
+ // may need to deal with this problem.
+ return -1;
+ }
+ return result;
+ }
+
+ private long interceptKeyBeforeDispatchingInner(WindowState win, KeyEvent event,
+ int policyFlags) {
final boolean keyguardOn = keyguardOn();
final int keyCode = event.getKeyCode();
final int repeatCount = event.getRepeatCount();
@@ -3123,6 +3143,11 @@
}
@Override
+ public void setTopFocusedDisplay(int displayId) {
+ mTopFocusedDisplayId = displayId;
+ }
+
+ @Override
public void registerShortcutKey(long shortcutCode, IShortcutService shortcutService)
throws RemoteException {
synchronized (mLock) {
diff --git a/services/core/java/com/android/server/policy/WindowManagerPolicy.java b/services/core/java/com/android/server/policy/WindowManagerPolicy.java
index 3d474e3..3da325c 100644
--- a/services/core/java/com/android/server/policy/WindowManagerPolicy.java
+++ b/services/core/java/com/android/server/policy/WindowManagerPolicy.java
@@ -1034,6 +1034,13 @@
public KeyEvent dispatchUnhandledKey(WindowState win, KeyEvent event, int policyFlags);
/**
+ * Called when the top focused display is changed.
+ *
+ * @param displayId The ID of the top focused display.
+ */
+ void setTopFocusedDisplay(int displayId);
+
+ /**
* Apply the keyguard policy to a specific window.
*
* @param win The window to apply the keyguard policy.
diff --git a/services/core/java/com/android/server/wm/AppWindowToken.java b/services/core/java/com/android/server/wm/AppWindowToken.java
index c458c94..5476e7a 100644
--- a/services/core/java/com/android/server/wm/AppWindowToken.java
+++ b/services/core/java/com/android/server/wm/AppWindowToken.java
@@ -91,6 +91,7 @@
import android.graphics.Point;
import android.graphics.Rect;
import android.os.Binder;
+import android.os.Build;
import android.os.Debug;
import android.os.IBinder;
import android.os.RemoteException;
@@ -733,6 +734,17 @@
}
boolean windowsAreFocusable() {
+ if (mTargetSdk < Build.VERSION_CODES.Q) {
+ final int pid = mActivityRecord != null
+ ? (mActivityRecord.app != null ? mActivityRecord.app.getPid() : 0) : 0;
+ final AppWindowToken topFocusedAppOfMyProcess =
+ mWmService.mRoot.mTopFocusedAppByProcess.get(pid);
+ if (topFocusedAppOfMyProcess != null && topFocusedAppOfMyProcess != this) {
+ // For the apps below Q, there can be only one app which has the focused window per
+ // process, because legacy apps may not be ready for a multi-focus system.
+ return false;
+ }
+ }
return getWindowConfiguration().canReceiveKeys() || mAlwaysFocusable;
}
diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java
index 2f4c5ca..415357d 100644
--- a/services/core/java/com/android/server/wm/DisplayContent.java
+++ b/services/core/java/com/android/server/wm/DisplayContent.java
@@ -61,9 +61,9 @@
import static android.view.WindowManager.LayoutParams.TYPE_WALLPAPER;
import static android.view.WindowManager.TRANSIT_ACTIVITY_OPEN;
import static android.view.WindowManager.TRANSIT_KEYGUARD_UNOCCLUDE;
-
import static android.view.WindowManager.TRANSIT_TASK_OPEN;
import static android.view.WindowManager.TRANSIT_TASK_TO_FRONT;
+
import static com.android.server.policy.WindowManagerPolicy.FINISH_LAYOUT_REDO_ANIM;
import static com.android.server.policy.WindowManagerPolicy.FINISH_LAYOUT_REDO_CONFIG;
import static com.android.server.policy.WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT;
@@ -103,6 +103,7 @@
import static com.android.server.wm.WindowManagerDebugConfig.TAG_WITH_CLASS_NAME;
import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;
import static com.android.server.wm.WindowManagerService.CUSTOM_SCREEN_ROTATION;
+import static com.android.server.wm.WindowManagerService.H.REPORT_FOCUS_CHANGE;
import static com.android.server.wm.WindowManagerService.H.REPORT_HARD_KEYBOARD_STATUS_CHANGE;
import static com.android.server.wm.WindowManagerService.H.REPORT_LOSING_FOCUS;
import static com.android.server.wm.WindowManagerService.H.SEND_NEW_CONFIGURATION;
@@ -2832,6 +2833,11 @@
forAllWindows(mScheduleToastTimeout, false /* traverseTopToBottom */);
}
+ WindowState findFocusedWindowIfNeeded() {
+ return (mWmService.mPerDisplayFocusEnabled
+ || mWmService.mRoot.mTopFocusedAppByProcess.isEmpty()) ? findFocusedWindow() : null;
+ }
+
WindowState findFocusedWindow() {
mTmpWindow = null;
@@ -2844,7 +2850,6 @@
return mTmpWindow;
}
-
/**
* Update the focused window and make some adjustments if the focus has changed.
*
@@ -2856,31 +2861,31 @@
* @param updateInputWindows Whether to sync the window information to the input module.
* @return {@code true} if the focused window has changed.
*/
- boolean updateFocusedWindowLocked(int mode, boolean updateInputWindows, boolean focusFound) {
- final WindowState newFocus = findFocusedWindow();
+ boolean updateFocusedWindowLocked(int mode, boolean updateInputWindows) {
+ WindowState newFocus = findFocusedWindowIfNeeded();
if (mCurrentFocus == newFocus) {
return false;
}
boolean imWindowChanged = false;
- // TODO (b/111080190): Multi-Session IME
- if (!focusFound) {
- final WindowState imWindow = mInputMethodWindow;
- if (imWindow != null) {
- final WindowState prevTarget = mInputMethodTarget;
+ final WindowState imWindow = mInputMethodWindow;
+ if (imWindow != null) {
+ final WindowState prevTarget = mInputMethodTarget;
+ final WindowState newTarget = computeImeTarget(true /* updateImeTarget*/);
+ imWindowChanged = prevTarget != newTarget;
- final WindowState newTarget = computeImeTarget(true /* updateImeTarget*/);
- imWindowChanged = prevTarget != newTarget;
-
- if (mode != UPDATE_FOCUS_WILL_ASSIGN_LAYERS
- && mode != UPDATE_FOCUS_WILL_PLACE_SURFACES) {
- assignWindowLayers(false /* setLayoutNeeded */);
- }
+ if (mode != UPDATE_FOCUS_WILL_ASSIGN_LAYERS
+ && mode != UPDATE_FOCUS_WILL_PLACE_SURFACES) {
+ assignWindowLayers(false /* setLayoutNeeded */);
}
}
if (imWindowChanged) {
mWmService.mWindowsChanged = true;
setLayoutNeeded();
+ newFocus = findFocusedWindowIfNeeded();
+ }
+ if (mCurrentFocus != newFocus) {
+ mWmService.mH.obtainMessage(REPORT_FOCUS_CHANGE, this).sendToTarget();
}
if (DEBUG_FOCUS_LIGHT || mWmService.localLOGV) Slog.v(TAG_WM, "Changing focus from "
diff --git a/services/core/java/com/android/server/wm/RootWindowContainer.java b/services/core/java/com/android/server/wm/RootWindowContainer.java
index 3bbef92..6e4f69e 100644
--- a/services/core/java/com/android/server/wm/RootWindowContainer.java
+++ b/services/core/java/com/android/server/wm/RootWindowContainer.java
@@ -79,6 +79,7 @@
import java.io.PrintWriter;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.function.Consumer;
/** Root {@link WindowContainer} for the device. */
@@ -122,7 +123,10 @@
// The ID of the display which is responsible for receiving display-unspecified key and pointer
// events.
- int mTopFocusedDisplayId = INVALID_DISPLAY;
+ private int mTopFocusedDisplayId = INVALID_DISPLAY;
+
+ // Map from the PID to the top most app which has a focused window of the process.
+ final HashMap<Integer, AppWindowToken> mTopFocusedAppByProcess = new HashMap<>();
// Only a separate transaction until we separate the apply surface changes
// transaction from the global transaction.
@@ -157,50 +161,32 @@
}
boolean updateFocusedWindowLocked(int mode, boolean updateInputWindows) {
+ mTopFocusedAppByProcess.clear();
boolean changed = false;
int topFocusedDisplayId = INVALID_DISPLAY;
-
for (int i = mChildren.size() - 1; i >= 0; --i) {
final DisplayContent dc = mChildren.get(i);
- changed |= dc.updateFocusedWindowLocked(mode, updateInputWindows,
- topFocusedDisplayId != INVALID_DISPLAY /* focusFound */);
- if (topFocusedDisplayId == INVALID_DISPLAY && dc.mCurrentFocus != null) {
- topFocusedDisplayId = dc.getDisplayId();
+ changed |= dc.updateFocusedWindowLocked(mode, updateInputWindows);
+ final WindowState newFocus = dc.mCurrentFocus;
+ if (newFocus != null) {
+ final int pidOfNewFocus = newFocus.mSession.mPid;
+ if (mTopFocusedAppByProcess.get(pidOfNewFocus) == null) {
+ mTopFocusedAppByProcess.put(pidOfNewFocus, newFocus.mAppToken);
+ }
+ if (topFocusedDisplayId == INVALID_DISPLAY) {
+ topFocusedDisplayId = dc.getDisplayId();
+ }
}
}
if (topFocusedDisplayId == INVALID_DISPLAY) {
topFocusedDisplayId = DEFAULT_DISPLAY;
}
- // TODO(b/118865114): Review if need callback top focus display change to view component.
- // (i.e. Activity or View)
- // Currently we only tracked topFocusedDisplayChanged for notifying InputMethodManager via
- // ViewRootImpl.windowFocusChanged to refocus IME window when top display focus changed
- // but window focus remain the same case.
- // It may need to review if any use case that need to add new callback for reporting
- // this change.
- final boolean topFocusedDisplayChanged =
- mTopFocusedDisplayId != topFocusedDisplayId && mode == UPDATE_FOCUS_NORMAL;
if (mTopFocusedDisplayId != topFocusedDisplayId) {
mTopFocusedDisplayId = topFocusedDisplayId;
- mWmService.mInputManager.setFocusedDisplay(mTopFocusedDisplayId);
+ mWmService.mInputManager.setFocusedDisplay(topFocusedDisplayId);
if (DEBUG_FOCUS_LIGHT) Slog.v(TAG_WM, "New topFocusedDisplayId="
- + mTopFocusedDisplayId);
+ + topFocusedDisplayId);
}
-
- // Report window focus or top display focus changed through REPORT_FOCUS_CHANGE.
- forAllDisplays((dc) -> {
- final boolean windowFocusChanged =
- dc.mCurrentFocus != null && dc.mCurrentFocus != dc.mLastFocus;
- final boolean isTopFocusedDisplay =
- topFocusedDisplayChanged && dc.getDisplayId() == mTopFocusedDisplayId;
- if (windowFocusChanged || isTopFocusedDisplay) {
- final Message msg = mWmService.mH.obtainMessage(
- WindowManagerService.H.REPORT_FOCUS_CHANGE, dc);
- msg.arg1 = topFocusedDisplayChanged ? 1 : 0;
- mWmService.mH.sendMessage(msg);
- }
- });
-
return changed;
}
diff --git a/services/core/java/com/android/server/wm/TaskTapPointerEventListener.java b/services/core/java/com/android/server/wm/TaskTapPointerEventListener.java
index 53d2cb0..c006a7b 100644
--- a/services/core/java/com/android/server/wm/TaskTapPointerEventListener.java
+++ b/services/core/java/com/android/server/wm/TaskTapPointerEventListener.java
@@ -16,6 +16,12 @@
package com.android.server.wm;
+import static android.view.PointerIcon.TYPE_HORIZONTAL_DOUBLE_ARROW;
+import static android.view.PointerIcon.TYPE_NOT_SPECIFIED;
+import static android.view.PointerIcon.TYPE_TOP_LEFT_DIAGONAL_DOUBLE_ARROW;
+import static android.view.PointerIcon.TYPE_TOP_RIGHT_DIAGONAL_DOUBLE_ARROW;
+import static android.view.PointerIcon.TYPE_VERTICAL_DOUBLE_ARROW;
+
import android.graphics.Rect;
import android.graphics.Region;
import android.hardware.input.InputManager;
@@ -25,21 +31,18 @@
import com.android.server.wm.WindowManagerService.H;
-import static android.view.PointerIcon.TYPE_NOT_SPECIFIED;
-import static android.view.PointerIcon.TYPE_HORIZONTAL_DOUBLE_ARROW;
-import static android.view.PointerIcon.TYPE_VERTICAL_DOUBLE_ARROW;
-import static android.view.PointerIcon.TYPE_TOP_LEFT_DIAGONAL_DOUBLE_ARROW;
-import static android.view.PointerIcon.TYPE_TOP_RIGHT_DIAGONAL_DOUBLE_ARROW;
-
public class TaskTapPointerEventListener implements PointerEventListener {
- final private Region mTouchExcludeRegion = new Region();
+ private final Region mTouchExcludeRegion = new Region();
+ private final Region mTmpRegion = new Region();
private final WindowManagerService mService;
private final DisplayContent mDisplayContent;
private final Handler mHandler;
private final Runnable mMoveDisplayToTop;
private final Rect mTmpRect = new Rect();
private int mPointerIconType = TYPE_NOT_SPECIFIED;
+ private int mLastDownX;
+ private int mLastDownY;
public TaskTapPointerEventListener(WindowManagerService service,
DisplayContent displayContent) {
@@ -47,7 +50,22 @@
mDisplayContent = displayContent;
mHandler = new Handler(mService.mH.getLooper());
mMoveDisplayToTop = () -> {
+ int x;
+ int y;
+ synchronized (this) {
+ x = mLastDownX;
+ y = mLastDownY;
+ }
synchronized (mService.mGlobalLock) {
+ if (!mService.mPerDisplayFocusEnabled
+ && mService.mRoot.getTopFocusedDisplayContent() != mDisplayContent
+ && inputMethodWindowContains(x, y)) {
+ // In a single focus system, if the input method window and the input method
+ // target window are on the different displays, when the user is tapping on the
+ // input method window, we don't move its display to top. Otherwise, the input
+ // method target window will lose the focus.
+ return;
+ }
mDisplayContent.getParent().positionChildAt(WindowContainer.POSITION_TOP,
mDisplayContent, true /* includingParents */);
}
@@ -70,6 +88,8 @@
mService.mTaskPositioningController.handleTapOutsideTask(
mDisplayContent, x, y);
}
+ mLastDownX = x;
+ mLastDownY = y;
mHandler.post(mMoveDisplayToTop);
}
}
@@ -122,4 +142,13 @@
private int getDisplayId() {
return mDisplayContent.getDisplayId();
}
+
+ private boolean inputMethodWindowContains(int x, int y) {
+ final WindowState inputMethodWindow = mDisplayContent.mInputMethodWindow;
+ if (inputMethodWindow == null || !inputMethodWindow.isVisibleLw()) {
+ return false;
+ }
+ inputMethodWindow.getTouchableRegion(mTmpRegion);
+ return mTmpRegion.contains(x, y);
+ }
}
diff --git a/services/core/java/com/android/server/wm/WindowManagerService.java b/services/core/java/com/android/server/wm/WindowManagerService.java
index 002d6d4..50bc247 100644
--- a/services/core/java/com/android/server/wm/WindowManagerService.java
+++ b/services/core/java/com/android/server/wm/WindowManagerService.java
@@ -611,6 +611,9 @@
boolean mClientFreezingScreen = false;
int mAppsFreezingScreen = 0;
+ @VisibleForTesting
+ boolean mPerDisplayFocusEnabled;
+
// State while inside of layoutAndPlaceSurfacesLocked().
boolean mFocusMayChange;
@@ -944,6 +947,8 @@
com.android.internal.R.integer.config_maxUiWidth);
mDisableTransitionAnimation = context.getResources().getBoolean(
com.android.internal.R.bool.config_disableTransitionAnimation);
+ mPerDisplayFocusEnabled = context.getResources().getBoolean(
+ com.android.internal.R.bool.config_perDisplayFocusEnabled);
mInputManager = inputManager; // Must be before createDisplayContentLocked.
mDisplayManagerInternal = LocalServices.getService(DisplayManagerInternal.class);
mDisplayWindowSettings = new DisplayWindowSettings(this);
@@ -4484,7 +4489,6 @@
AccessibilityController accessibilityController = null;
- final boolean topFocusedDisplayChanged = msg.arg1 != 0;
synchronized (mGlobalLock) {
// TODO(multidisplay): Accessibility supported only of default desiplay.
if (mAccessibilityController != null && displayContent.isDefaultDisplay) {
@@ -4495,19 +4499,7 @@
newFocus = displayContent.mCurrentFocus;
}
if (lastFocus == newFocus) {
- // Report focus to ViewRootImpl when top focused display changes.
- // Or, nothing to do for no window focus change.
- if (topFocusedDisplayChanged && newFocus != null) {
- if (DEBUG_FOCUS_LIGHT) {
- Slog.d(TAG, "Reporting focus: " + newFocus
- + " due to top focused display change.");
- }
- // See {@link IWindow#windowFocusChanged} to know why set
- // reportToClient as false.
- newFocus.reportFocusChangedSerialized(true, mInTouchMode,
- false /* reportToClient */);
- notifyFocusChanged();
- }
+ // Focus is not changing, so nothing to do.
return;
}
synchronized (mGlobalLock) {
@@ -4529,15 +4521,13 @@
if (newFocus != null) {
if (DEBUG_FOCUS_LIGHT) Slog.i(TAG_WM, "Gaining focus: " + newFocus);
- newFocus.reportFocusChangedSerialized(true, mInTouchMode,
- true /* reportToClient */);
+ newFocus.reportFocusChangedSerialized(true, mInTouchMode);
notifyFocusChanged();
}
if (lastFocus != null) {
if (DEBUG_FOCUS_LIGHT) Slog.i(TAG_WM, "Losing focus: " + lastFocus);
- lastFocus.reportFocusChangedSerialized(false, mInTouchMode,
- true /* reportToClient */);
+ lastFocus.reportFocusChangedSerialized(false, mInTouchMode);
}
} break;
@@ -4554,8 +4544,7 @@
for (int i = 0; i < N; i++) {
if (DEBUG_FOCUS_LIGHT) Slog.i(TAG_WM, "Losing delayed focus: " +
losers.get(i));
- losers.get(i).reportFocusChangedSerialized(false, mInTouchMode,
- true /* reportToClient */);
+ losers.get(i).reportFocusChangedSerialized(false, mInTouchMode);
}
} break;
diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java
index d2dfa76..f86d089 100644
--- a/services/core/java/com/android/server/wm/WindowState.java
+++ b/services/core/java/com/android/server/wm/WindowState.java
@@ -2866,13 +2866,12 @@
* Report a focus change. Must be called with no locks held, and consistently
* from the same serialized thread (such as dispatched from a handler).
*/
- void reportFocusChangedSerialized(boolean focused, boolean inTouchMode,
- boolean reportToClient) {
+ void reportFocusChangedSerialized(boolean focused, boolean inTouchMode) {
try {
- mClient.windowFocusChanged(focused, inTouchMode, reportToClient);
+ mClient.windowFocusChanged(focused, inTouchMode);
} catch (RemoteException e) {
}
- if (mFocusCallbacks != null && reportToClient) {
+ if (mFocusCallbacks != null) {
final int N = mFocusCallbacks.beginBroadcast();
for (int i=0; i<N; i++) {
IWindowFocusObserver obs = mFocusCallbacks.getBroadcastItem(i);