DisplayContent: Cleanup after tap detector removal (2afff4c6) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/wm/DisplayContent.java

+0 −135

Original line number	Diff line number	Diff line
		@@ -550,15 +550,6 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		// TODO(multi-display): remove some of the usages.
		boolean isDefaultDisplay;

		/** Detect user tapping outside of current focused task bounds .*/
		// TODO(b/315321016): Remove once pointer event detection is removed from WM.
		@VisibleForTesting
		final TaskTapPointerEventListener mTapDetector;

		/** Detect user tapping outside of current focused root task bounds .*/
		// TODO(b/315321016): Remove once pointer event detection is removed from WM.
		private Region mTouchExcludeRegion = new Region();

		/** Save allocating when calculating rects */
		private final Rect mTmpRect = new Rect();
		private final Rect mTmpRect2 = new Rect();
		@@ -571,10 +562,6 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp

		final PinnedTaskController mPinnedTaskController;

		final ArrayList<WindowState> mTapExcludedWindows = new ArrayList<>();
		/** A collection of windows that provide tap exclude regions inside of them. */
		final ArraySet<WindowState> mTapExcludeProvidingWindows = new ArraySet<>();

		private final LinkedList<ActivityRecord> mTmpUpdateAllDrawn = new LinkedList();

		private final TaskForResizePointSearchResult mTmpTaskForResizePointSearchResult =
		@@ -1193,15 +1180,6 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		"PointerEventDispatcher" + mDisplayId, mDisplayId);
		mPointerEventDispatcher = new PointerEventDispatcher(inputChannel);

		if (com.android.input.flags.Flags.removePointerEventTrackingInWm()) {
		mTapDetector = null;
		} else {
		// Tap Listeners are supported for:
		// 1. All physical displays (multi-display).
		// 2. VirtualDisplays on VR, AA (and everything else).
		mTapDetector = new TaskTapPointerEventListener(mWmService, this);
		registerPointerEventListener(mTapDetector);
		}
		if (mWmService.mAtmService.getRecentTasks() != null) {
		registerPointerEventListener(
		mWmService.mAtmService.getRecentTasks().getInputListener());
		@@ -3301,117 +3279,6 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		mTmpTaskForResizePointSearchResult.process(taskDisplayArea, x, y, delta));
		}

		void updateTouchExcludeRegion() {
		if (mTapDetector == null) {
		// The touch exclude region is used to detect the region outside of the focused task
		// so that the tap detector can detect outside touches. Don't calculate the exclude
		// region when the tap detector is disabled.
		return;
		}
		final Task focusedTask = (mFocusedApp != null ? mFocusedApp.getTask() : null);
		if (focusedTask == null) {
		mTouchExcludeRegion.setEmpty();
		} else {
		mTouchExcludeRegion.set(0, 0, mDisplayInfo.logicalWidth, mDisplayInfo.logicalHeight);
		final int delta = dipToPixel(RESIZE_HANDLE_WIDTH_IN_DP, mDisplayMetrics);
		mTmpRect.setEmpty();
		mTmpRect2.setEmpty();

		forAllTasks(t -> { processTaskForTouchExcludeRegion(t, focusedTask, delta); });

		// If we removed the focused task above, add it back and only leave its
		// outside touch area in the exclusion. TapDetector is not interested in
		// any touch inside the focused task itself.
		if (!mTmpRect2.isEmpty()) {
		mTouchExcludeRegion.op(mTmpRect2, Region.Op.UNION);
		}
		}
		if (mInputMethodWindow != null && mInputMethodWindow.isVisible()) {
		// If the input method is visible and the user is typing, we don't want these touch
		// events to be intercepted and used to change focus. This would likely cause a
		// disappearance of the input method.
		mInputMethodWindow.getTouchableRegion(mTmpRegion);
		mTouchExcludeRegion.op(mTmpRegion, Op.UNION);
		}
		for (int i = mTapExcludedWindows.size() - 1; i >= 0; i--) {
		final WindowState win = mTapExcludedWindows.get(i);
		if (!win.isVisible()) {
		continue;
		}
		win.getTouchableRegion(mTmpRegion);
		mTouchExcludeRegion.op(mTmpRegion, Region.Op.UNION);
		}
		amendWindowTapExcludeRegion(mTouchExcludeRegion);
		mTapDetector.setTouchExcludeRegion(mTouchExcludeRegion);
		}

		private void processTaskForTouchExcludeRegion(Task task, Task focusedTask, int delta) {
		if (mTapDetector == null) {
		// The touch exclude region is used to detect the region outside of the focused task
		// so that the tap detector can detect outside touches. Don't calculate the exclude
		// region when the tap detector is disabled.
		}
		final ActivityRecord topVisibleActivity = task.getTopVisibleActivity();

		if (topVisibleActivity == null \|\| !topVisibleActivity.hasContentToDisplay()) {
		return;
		}

		// Exclusion region is the region that TapDetector doesn't care about.
		// Here we want to remove all non-focused tasks from the exclusion region.
		// We also remove the outside touch area for resizing for all freeform
		// tasks (including the focused).
		// We save the focused task region once we find it, and add it back at the end.
		// If the task is root home task and it is resizable and visible (top of its root task),
		// we want to exclude the root docked task from touch so we need the entire screen area
		// and not just a small portion which the root home task currently is resized to.
		if (task.isActivityTypeHome() && task.isVisible() && task.isResizeable()) {
		task.getDisplayArea().getBounds(mTmpRect);
		} else {
		task.getDimBounds(mTmpRect);
		}

		if (task == focusedTask) {
		// Add the focused task rect back into the exclude region once we are done
		// processing root tasks.
		// NOTE: this looks like a no-op, but this usage of mTmpRect2 is expected by
		// updateTouchExcludeRegion.
		mTmpRect2.set(mTmpRect);
		}

		final boolean isFreeformed = task.inFreeformWindowingMode();
		if (task != focusedTask \|\| isFreeformed) {
		if (isFreeformed) {
		// If the task is freeformed, enlarge the area to account for outside
		// touch area for resize.
		mTmpRect.inset(-delta, -delta);
		// Intersect with display content frame. If we have system decor (status bar/
		// navigation bar), we want to exclude that from the tap detection.
		// Otherwise, if the app is partially placed under some system button (eg.
		// Recents, Home), pressing that button would cause a full series of
		// unwanted transfer focus/resume/pause, before we could go home.
		mTmpRect.inset(getInsetsStateController().getRawInsetsState().calculateInsets(
		mTmpRect, systemBars() \| ime(), false /* ignoreVisibility */));
		}
		mTouchExcludeRegion.op(mTmpRect, Region.Op.DIFFERENCE);
		}
		}

		/**
		* Union the region with all the tap exclude region provided by windows on this display.
		*
		* @param inOutRegion The region to be amended.
		*/
		private void amendWindowTapExcludeRegion(Region inOutRegion) {
		final Region region = Region.obtain();
		for (int i = mTapExcludeProvidingWindows.size() - 1; i >= 0; i--) {
		final WindowState win = mTapExcludeProvidingWindows.valueAt(i);
		win.getTapExcludeRegion(region);
		inOutRegion.op(region, Op.UNION);
		}
		region.recycle();
		}

		@Override
		void switchUser(int userId) {
		super.switchUser(userId);
		@@ -3768,7 +3635,6 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		pw.print("x"); pw.println(mDisplayInfo.largestNominalAppHeight);
		pw.print(subPrefix + "deferred=" + mDeferredRemoval
		+ " mLayoutNeeded=" + mLayoutNeeded);
		pw.println(" mTouchExcludeRegion=" + mTouchExcludeRegion);

		pw.println();
		super.dump(pw, prefix, dumpAll);
		@@ -4117,7 +3983,6 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		}

		getInputMonitor().setFocusedAppLw(newFocus);
		updateTouchExcludeRegion();
		return true;
		}

services/core/java/com/android/server/wm/RootWindowContainer.java

+0 −1

Original line number	Diff line number	Diff line
		@@ -911,7 +911,6 @@ class RootWindowContainer extends WindowContainer<DisplayContent>
		dc.getInputMonitor().updateInputWindowsLw(true /force/);
		dc.updateSystemGestureExclusion();
		dc.updateKeepClearAreas();
		dc.updateTouchExcludeRegion();
		});

		// Check to see if we are now in a state where the screen should

services/core/java/com/android/server/wm/TaskTapPointerEventListener.java

deleted100644 → 0

+0 −128

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2013 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		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.view.InputDevice;
		import android.view.MotionEvent;
		import android.view.WindowManagerPolicyConstants.PointerEventListener;

		/**
		* 1. Adjust the top most focus display if touch down on some display.
		* 2. Adjust the pointer icon when cursor moves to the task bounds.
		*/
		public class TaskTapPointerEventListener implements PointerEventListener {

		private final Region mTouchExcludeRegion = new Region();
		private final WindowManagerService mService;
		private final DisplayContent mDisplayContent;
		private final Rect mTmpRect = new Rect();
		private int mPointerIconType = TYPE_NOT_SPECIFIED;

		public TaskTapPointerEventListener(WindowManagerService service,
		DisplayContent displayContent) {
		// TODO(b/315321016): Remove this class when the flag rollout is complete.
		if (com.android.input.flags.Flags.removePointerEventTrackingInWm()) {
		throw new IllegalStateException("TaskTapPointerEventListener should not be used!");
		}
		mService = service;
		mDisplayContent = displayContent;
		}

		private void restorePointerIcon(int x, int y) {
		if (mPointerIconType != TYPE_NOT_SPECIFIED) {
		mPointerIconType = TYPE_NOT_SPECIFIED;
		}
		}

		@Override
		public void onPointerEvent(MotionEvent motionEvent) {
		switch (motionEvent.getActionMasked()) {
		case MotionEvent.ACTION_DOWN: {
		final int x;
		final int y;
		if (motionEvent.getSource() == InputDevice.SOURCE_MOUSE) {
		x = (int) motionEvent.getXCursorPosition();
		y = (int) motionEvent.getYCursorPosition();
		} else {
		x = (int) motionEvent.getX();
		y = (int) motionEvent.getY();
		}

		synchronized (this) {
		if (!mTouchExcludeRegion.contains(x, y)) {
		mService.mTaskPositioningController.handleTapOutsideTask(
		mDisplayContent, x, y);
		}
		}
		}
		break;
		case MotionEvent.ACTION_HOVER_ENTER:
		case MotionEvent.ACTION_HOVER_MOVE: {
		final int x = (int) motionEvent.getX();
		final int y = (int) motionEvent.getY();
		if (mTouchExcludeRegion.contains(x, y)) {
		restorePointerIcon(x, y);
		break;
		}
		final Task task = mDisplayContent.findTaskForResizePoint(x, y);
		int iconType = TYPE_NOT_SPECIFIED;
		if (task != null) {
		task.getDimBounds(mTmpRect);
		if (!mTmpRect.isEmpty() && !mTmpRect.contains(x, y)) {
		if (x < mTmpRect.left) {
		iconType =
		(y < mTmpRect.top) ? TYPE_TOP_LEFT_DIAGONAL_DOUBLE_ARROW :
		(y > mTmpRect.bottom) ? TYPE_TOP_RIGHT_DIAGONAL_DOUBLE_ARROW :
		TYPE_HORIZONTAL_DOUBLE_ARROW;
		} else if (x > mTmpRect.right) {
		iconType =
		(y < mTmpRect.top) ? TYPE_TOP_RIGHT_DIAGONAL_DOUBLE_ARROW :
		(y > mTmpRect.bottom) ? TYPE_TOP_LEFT_DIAGONAL_DOUBLE_ARROW :
		TYPE_HORIZONTAL_DOUBLE_ARROW;
		} else if (y < mTmpRect.top \|\| y > mTmpRect.bottom) {
		iconType = TYPE_VERTICAL_DOUBLE_ARROW;
		}
		}
		}
		if (mPointerIconType != iconType) {
		mPointerIconType = iconType;
		}
		}
		break;
		case MotionEvent.ACTION_HOVER_EXIT: {
		final int x = (int) motionEvent.getX();
		final int y = (int) motionEvent.getY();
		restorePointerIcon(x, y);
		}
		break;
		}
		}

		void setTouchExcludeRegion(Region newRegion) {
		synchronized (this) {
		mTouchExcludeRegion.set(newRegion);
		}
		}
		}

services/core/java/com/android/server/wm/WindowManagerService.java

+0 −20

Original line number	Diff line number	Diff line
		@@ -81,15 +81,11 @@ import static android.view.WindowManager.LayoutParams.TYPE_ACCESSIBILITY_OVERLAY
		import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_STARTING;
		import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD;
		import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD_DIALOG;
		import static android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR;
		import static android.view.WindowManager.LayoutParams.TYPE_NOTIFICATION_SHADE;
		import static android.view.WindowManager.LayoutParams.TYPE_PRESENTATION;
		import static android.view.WindowManager.LayoutParams.TYPE_PRIVATE_PRESENTATION;
		import static android.view.WindowManager.LayoutParams.TYPE_QS_DIALOG;
		import static android.view.WindowManager.LayoutParams.TYPE_STATUS_BAR;
		import static android.view.WindowManager.LayoutParams.TYPE_TOAST;
		import static android.view.WindowManager.LayoutParams.TYPE_VOICE_INTERACTION;
		import static android.view.WindowManager.LayoutParams.TYPE_VOLUME_OVERLAY;
		import static android.view.WindowManager.LayoutParams.TYPE_WALLPAPER;
		import static android.view.WindowManager.REMOVE_CONTENT_MODE_UNDEFINED;
		import static android.view.WindowManager.TRANSIT_NONE;
		@@ -1520,18 +1516,6 @@ public class WindowManagerService extends IWindowManager.Stub
		}
		}

		static boolean excludeWindowTypeFromTapOutTask(int windowType) {
		switch (windowType) {
		case TYPE_STATUS_BAR:
		case TYPE_NOTIFICATION_SHADE:
		case TYPE_NAVIGATION_BAR:
		case TYPE_INPUT_METHOD_DIALOG:
		case TYPE_VOLUME_OVERLAY:
		return true;
		}
		return false;
		}

		public int addWindow(Session session, IWindow client, LayoutParams attrs, int viewVisibility,
		int displayId, int requestUserId, @InsetsType int requestedVisibleTypes,
		InputChannel outInputChannel, InsetsState outInsetsState,
		@@ -1830,10 +1814,6 @@ public class WindowManagerService extends IWindowManager.Stub
		displayContent.mWinAddedSinceNullFocus.add(win);
		}

		if (excludeWindowTypeFromTapOutTask(type)) {
		displayContent.mTapExcludedWindows.add(win);
		}

		win.mSession.onWindowAdded(win);
		mWindowMap.put(client.asBinder(), win);
		win.initAppOpsState();

services/core/java/com/android/server/wm/WindowState.java

+0 −14

Original line number	Diff line number	Diff line
		@@ -2355,18 +2355,12 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP
		}

		final int type = mAttrs.type;
		if (WindowManagerService.excludeWindowTypeFromTapOutTask(type)) {
		dc.mTapExcludedWindows.remove(this);
		}

		if (type == TYPE_PRESENTATION \|\| type == TYPE_PRIVATE_PRESENTATION) {
		mWmService.mDisplayManagerInternal.onPresentation(dc.getDisplay().getDisplayId(),
		/isShown=/ false);
		}

		// Remove this window from mTapExcludeProvidingWindows. If it was not registered, this will
		// not do anything.
		dc.mTapExcludeProvidingWindows.remove(this);
		dc.getDisplayPolicy().removeWindowLw(this);

		disposeInputChannel();
		@@ -5522,18 +5516,10 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP
		// Clear the tap excluded region if the region passed in is null or empty.
		if (region == null \|\| region.isEmpty()) {
		mTapExcludeRegion.setEmpty();
		// Remove this window from mTapExcludeProvidingWindows since it won't be providing
		// tap exclude regions.
		currentDisplay.mTapExcludeProvidingWindows.remove(this);
		} else {
		mTapExcludeRegion.set(region);
		// Make sure that this window is registered as one that provides a tap exclude region
		// for its containing display.
		currentDisplay.mTapExcludeProvidingWindows.add(this);
		}

		// Trigger touch exclude region update on current display.
		currentDisplay.updateTouchExcludeRegion();
		// Trigger touchable region update for this window.
		currentDisplay.getInputMonitor().updateInputWindowsLw(true /* force */);
		}