Merge "Remove server side task positioner" into main (b93e1848) · Commits · e / os / android_frameworks_base

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

+1 −18

Original line number	Diff line number	Diff line
		@@ -39,7 +39,6 @@ import static android.view.WindowManager.LayoutParams.isSystemAlertWindowType;

		import static com.android.internal.protolog.ProtoLogGroup.WM_SHOW_TRANSACTIONS;
		import static com.android.server.wm.WindowManagerDebugConfig.DEBUG;
		import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_TASK_POSITIONING;
		import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;

		import android.annotation.NonNull;
		@@ -537,27 +536,11 @@ class Session extends IWindowSession.Stub implements IBinder.DeathRecipient {

		@Override
		public boolean startMovingTask(IWindow window, float startX, float startY) {
		if (DEBUG_TASK_POSITIONING) Slog.d(
		TAG_WM, "startMovingTask: {" + startX + "," + startY + "}");

		final long ident = Binder.clearCallingIdentity();
		try {
		return mService.mTaskPositioningController.startMovingTask(window, startX, startY);
		} finally {
		Binder.restoreCallingIdentity(ident);
		}
		return false;
		}

		@Override
		public void finishMovingTask(IWindow window) {
		if (DEBUG_TASK_POSITIONING) Slog.d(TAG_WM, "finishMovingTask");

		final long ident = Binder.clearCallingIdentity();
		try {
		mService.mTaskPositioningController.finishTaskPositioning(window);
		} finally {
		Binder.restoreCallingIdentity(ident);
		}
		}

		@Override

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

deleted100644 → 0

+0 −500

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 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.app.ActivityTaskManager.RESIZE_MODE_USER;
		import static android.app.ActivityTaskManager.RESIZE_MODE_USER_FORCED;
		import static android.os.InputConstants.DEFAULT_DISPATCHING_TIMEOUT_MILLIS;
		import static android.os.Trace.TRACE_TAG_WINDOW_MANAGER;

		import static com.android.internal.policy.TaskResizingAlgorithm.CTRL_BOTTOM;
		import static com.android.internal.policy.TaskResizingAlgorithm.CTRL_LEFT;
		import static com.android.internal.policy.TaskResizingAlgorithm.CTRL_NONE;
		import static com.android.internal.policy.TaskResizingAlgorithm.CTRL_RIGHT;
		import static com.android.internal.policy.TaskResizingAlgorithm.CTRL_TOP;
		import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_ORIENTATION;
		import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_TASK_POSITIONING;
		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.dipToPixel;
		import static com.android.server.wm.WindowState.MINIMUM_VISIBLE_HEIGHT_IN_DP;
		import static com.android.server.wm.WindowState.MINIMUM_VISIBLE_WIDTH_IN_DP;

		import static java.util.concurrent.CompletableFuture.completedFuture;

		import android.annotation.NonNull;
		import android.graphics.Point;
		import android.graphics.Rect;
		import android.os.Binder;
		import android.os.IBinder;
		import android.os.InputConfig;
		import android.os.RemoteException;
		import android.os.Trace;
		import android.util.DisplayMetrics;
		import android.util.Slog;
		import android.view.BatchedInputEventReceiver;
		import android.view.InputApplicationHandle;
		import android.view.InputChannel;
		import android.view.InputDevice;
		import android.view.InputEvent;
		import android.view.InputEventReceiver;
		import android.view.InputWindowHandle;
		import android.view.MotionEvent;
		import android.view.WindowManager;

		import com.android.internal.annotations.VisibleForTesting;
		import com.android.internal.policy.TaskResizingAlgorithm;
		import com.android.internal.policy.TaskResizingAlgorithm.CtrlType;
		import com.android.internal.protolog.ProtoLog;

		import java.util.concurrent.CompletableFuture;

		class TaskPositioner implements IBinder.DeathRecipient {
		private static final boolean DEBUG_ORIENTATION_VIOLATIONS = false;
		private static final String TAG_LOCAL = "TaskPositioner";
		private static final String TAG = TAG_WITH_CLASS_NAME ? TAG_LOCAL : TAG_WM;

		private static Factory sFactory;

		public static final float RESIZING_HINT_ALPHA = 0.5f;

		public static final int RESIZING_HINT_DURATION_MS = 0;

		private final WindowManagerService mService;
		private InputEventReceiver mInputEventReceiver;
		private DisplayContent mDisplayContent;
		private Rect mTmpRect = new Rect();
		private int mMinVisibleWidth;
		private int mMinVisibleHeight;

		@VisibleForTesting
		Task mTask;
		WindowState mWindow;
		private boolean mResizing;
		private boolean mPreserveOrientation;
		private boolean mStartOrientationWasLandscape;
		private final Rect mWindowOriginalBounds = new Rect();
		private final Rect mWindowDragBounds = new Rect();
		private final Point mMaxVisibleSize = new Point();
		private float mStartDragX;
		private float mStartDragY;
		@CtrlType
		private int mCtrlType = CTRL_NONE;
		@VisibleForTesting
		boolean mDragEnded;
		IBinder mClientCallback;

		InputChannel mClientChannel;
		InputApplicationHandle mDragApplicationHandle;
		InputWindowHandle mDragWindowHandle;

		/** Use {@link #create(WindowManagerService)} instead. */
		@VisibleForTesting
		TaskPositioner(WindowManagerService service) {
		mService = service;
		}

		private boolean onInputEvent(InputEvent event) {
		// All returns need to be in the try block to make sure the finishInputEvent is
		// called correctly.
		if (!(event instanceof MotionEvent)
		\|\| (event.getSource() & InputDevice.SOURCE_CLASS_POINTER) == 0) {
		return false;
		}
		final MotionEvent motionEvent = (MotionEvent) event;
		if (mDragEnded) {
		// The drag has ended but the clean-up message has not been processed by
		// window manager. Drop events that occur after this until window manager
		// has a chance to clean-up the input handle.
		return true;
		}

		final float newX = motionEvent.getRawX();
		final float newY = motionEvent.getRawY();

		switch (motionEvent.getAction()) {
		case MotionEvent.ACTION_DOWN: {
		if (DEBUG_TASK_POSITIONING) {
		Slog.w(TAG, "ACTION_DOWN @ {" + newX + ", " + newY + "}");
		}
		}
		break;

		case MotionEvent.ACTION_MOVE: {
		if (DEBUG_TASK_POSITIONING) {
		Slog.w(TAG, "ACTION_MOVE @ {" + newX + ", " + newY + "}");
		}
		synchronized (mService.mGlobalLock) {
		mDragEnded = notifyMoveLocked(newX, newY);
		mTask.getDimBounds(mTmpRect);
		}
		if (!mTmpRect.equals(mWindowDragBounds)) {
		Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER,
		"wm.TaskPositioner.resizeTask");
		mService.mAtmService.resizeTask(
		mTask.mTaskId, mWindowDragBounds, RESIZE_MODE_USER);
		Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
		}
		}
		break;

		case MotionEvent.ACTION_UP: {
		if (DEBUG_TASK_POSITIONING) {
		Slog.w(TAG, "ACTION_UP @ {" + newX + ", " + newY + "}");
		}
		mDragEnded = true;
		}
		break;

		case MotionEvent.ACTION_CANCEL: {
		if (DEBUG_TASK_POSITIONING) {
		Slog.w(TAG, "ACTION_CANCEL @ {" + newX + ", " + newY + "}");
		}
		mDragEnded = true;
		}
		break;
		}

		if (mDragEnded) {
		final boolean wasResizing = mResizing;
		synchronized (mService.mGlobalLock) {
		endDragLocked();
		mTask.getDimBounds(mTmpRect);
		}
		if (wasResizing && !mTmpRect.equals(mWindowDragBounds)) {
		// We were using fullscreen surface during resizing. Request
		// resizeTask() one last time to restore surface to window size.
		mService.mAtmService.resizeTask(
		mTask.mTaskId, mWindowDragBounds, RESIZE_MODE_USER_FORCED);
		}

		// Post back to WM to handle clean-ups. We still need the input
		// event handler for the last finishInputEvent()!
		mService.mTaskPositioningController.finishTaskPositioning();
		}
		return true;
		}

		@VisibleForTesting
		Rect getWindowDragBounds() {
		return mWindowDragBounds;
		}

		/**
		* @param displayContent The Display that the window being dragged is on.
		* @param win The window which will be dragged.
		*/
		CompletableFuture<Void> register(DisplayContent displayContent, @NonNull WindowState win) {
		if (DEBUG_TASK_POSITIONING) {
		Slog.d(TAG, "Registering task positioner");
		}

		if (mClientChannel != null) {
		Slog.e(TAG, "Task positioner already registered");
		return completedFuture(null);
		}

		mDisplayContent = displayContent;
		mClientChannel = mService.mInputManager.createInputChannel(TAG);

		mInputEventReceiver = new BatchedInputEventReceiver.SimpleBatchedInputEventReceiver(
		mClientChannel, mService.mAnimationHandler.getLooper(),
		mService.mAnimator.getChoreographer(), this::onInputEvent);

		mDragApplicationHandle = new InputApplicationHandle(new Binder(), TAG,
		DEFAULT_DISPATCHING_TIMEOUT_MILLIS);

		mDragWindowHandle = new InputWindowHandle(mDragApplicationHandle,
		displayContent.getDisplayId());
		mDragWindowHandle.name = TAG;
		mDragWindowHandle.token = mClientChannel.getToken();
		mDragWindowHandle.layoutParamsType = WindowManager.LayoutParams.TYPE_DRAG;
		mDragWindowHandle.dispatchingTimeoutMillis = DEFAULT_DISPATCHING_TIMEOUT_MILLIS;
		mDragWindowHandle.ownerPid = WindowManagerService.MY_PID;
		mDragWindowHandle.ownerUid = WindowManagerService.MY_UID;
		mDragWindowHandle.scaleFactor = 1.0f;
		// When dragging the window around, we do not want to steal focus for the window.
		mDragWindowHandle.inputConfig = InputConfig.NOT_FOCUSABLE;

		// The drag window cannot receive new touches.
		mDragWindowHandle.touchableRegion.setEmpty();

		// Pause rotations before a drag.
		ProtoLog.d(WM_DEBUG_ORIENTATION, "Pausing rotation during re-position");
		mDisplayContent.getDisplayRotation().pause();

		// Notify InputMonitor to take mDragWindowHandle.
		return mService.mTaskPositioningController.showInputSurface(win.getDisplayId())
		.thenRun(() -> {
		// The global lock is held by the callers of register but released before the async
		// results are waited on. We must acquire the lock in this callback to ensure thread
		// safety.
		synchronized (mService.mGlobalLock) {
		final Rect displayBounds = mTmpRect;
		displayContent.getBounds(displayBounds);
		final DisplayMetrics displayMetrics = displayContent.getDisplayMetrics();
		mMinVisibleWidth = dipToPixel(MINIMUM_VISIBLE_WIDTH_IN_DP, displayMetrics);
		mMinVisibleHeight = dipToPixel(MINIMUM_VISIBLE_HEIGHT_IN_DP, displayMetrics);
		mMaxVisibleSize.set(displayBounds.width(), displayBounds.height());

		mDragEnded = false;

		try {
		mClientCallback = win.mClient.asBinder();
		mClientCallback.linkToDeath(this, 0 /* flags */);
		} catch (RemoteException e) {
		// The caller has died, so clean up TaskPositioningController.
		mService.mTaskPositioningController.finishTaskPositioning();
		return;
		}
		mWindow = win;
		mTask = win.getTask();
		}
		});
		}

		void unregister() {
		if (DEBUG_TASK_POSITIONING) {
		Slog.d(TAG, "Unregistering task positioner");
		}

		if (mClientChannel == null) {
		Slog.e(TAG, "Task positioner not registered");
		return;
		}

		mService.mTaskPositioningController.hideInputSurface(mDisplayContent.getDisplayId());
		mService.mInputManager.removeInputChannel(mClientChannel.getToken());

		mInputEventReceiver.dispose();
		mInputEventReceiver = null;
		mClientChannel.dispose();
		mClientChannel = null;

		mDragWindowHandle = null;
		mDragApplicationHandle = null;
		mDragEnded = true;

		// Notify InputMonitor to remove mDragWindowHandle.
		mDisplayContent.getInputMonitor().updateInputWindowsLw(true /force/);

		// Resume rotations after a drag.
		ProtoLog.d(WM_DEBUG_ORIENTATION, "Resuming rotation after re-position");
		mDisplayContent.getDisplayRotation().resume();
		mDisplayContent = null;
		if (mClientCallback != null) {
		mClientCallback.unlinkToDeath(this, 0 /* flags */);
		}
		mWindow = null;
		}

		/**
		* Starts moving or resizing the task. This method should be only called from
		* {@link TaskPositioningController#startPositioningLocked} or unit tests.
		*/
		void startDrag(boolean resize, boolean preserveOrientation, float startX, float startY) {
		if (DEBUG_TASK_POSITIONING) {
		Slog.d(TAG, "startDrag: win=" + mWindow + ", resize=" + resize
		+ ", preserveOrientation=" + preserveOrientation + ", {" + startX + ", "
		+ startY + "}");
		}
		// Use the bounds of the task which accounts for
		// multiple app windows. Don't use any bounds from win itself as it
		// may not be the same size as the task.
		final Rect startBounds = mTmpRect;
		mTask.getBounds(startBounds);

		mCtrlType = CTRL_NONE;
		mStartDragX = startX;
		mStartDragY = startY;
		mPreserveOrientation = preserveOrientation;

		if (resize) {
		if (startX < startBounds.left) {
		mCtrlType \|= CTRL_LEFT;
		}
		if (startX > startBounds.right) {
		mCtrlType \|= CTRL_RIGHT;
		}
		if (startY < startBounds.top) {
		mCtrlType \|= CTRL_TOP;
		}
		if (startY > startBounds.bottom) {
		mCtrlType \|= CTRL_BOTTOM;
		}
		mResizing = mCtrlType != CTRL_NONE;
		}

		// In case of !isDockedInEffect we are using the union of all task bounds. These might be
		// made up out of multiple windows which are only partially overlapping. When that happens,
		// the orientation from the window of interest to the entire stack might diverge. However
		// for now we treat them as the same.
		mStartOrientationWasLandscape = startBounds.width() >= startBounds.height();
		mWindowOriginalBounds.set(startBounds);

		// Notify the app that resizing has started, even though we haven't received any new
		// bounds yet. This will guarantee that the app starts the backdrop renderer before
		// configuration changes which could cause an activity restart.
		if (mResizing) {
		notifyMoveLocked(startX, startY);

		// The WindowPositionerEventReceiver callbacks are delivered on the same handler so this
		// initial resize is always guaranteed to happen before subsequent drag resizes.
		mService.mH.post(() -> {
		mService.mAtmService.resizeTask(
		mTask.mTaskId, startBounds, RESIZE_MODE_USER_FORCED);
		});
		}

		// Make sure we always have valid drag bounds even if the drag ends before any move events
		// have been handled.
		mWindowDragBounds.set(startBounds);
		}

		private void endDragLocked() {
		mResizing = false;
		mTask.setDragResizing(false);
		}

		/** Returns true if the move operation should be ended. */
		@VisibleForTesting
		boolean notifyMoveLocked(float x, float y) {
		if (DEBUG_TASK_POSITIONING) {
		Slog.d(TAG, "notifyMoveLocked: {" + x + "," + y + "}");
		}

		if (mCtrlType != CTRL_NONE) {
		resizeDrag(x, y);
		mTask.setDragResizing(true);
		return false;
		}

		// This is a moving or scrolling operation.
		// Only allow to move in stable area so the target window won't be covered by system bar.
		// Though {@link Task#resolveOverrideConfiguration} should also avoid the case.
		mDisplayContent.getStableRect(mTmpRect);
		// The task may be put in a limited display area.
		mTmpRect.intersect(mTask.getRootTask().getParent().getBounds());

		int nX = (int) x;
		int nY = (int) y;
		if (!mTmpRect.contains(nX, nY)) {
		// For a moving operation we allow the pointer to go out of the stack bounds, but
		// use the clamped pointer position for the drag bounds computation.
		nX = Math.min(Math.max(nX, mTmpRect.left), mTmpRect.right);
		nY = Math.min(Math.max(nY, mTmpRect.top), mTmpRect.bottom);
		}

		updateWindowDragBounds(nX, nY, mTmpRect);
		return false;
		}

		/**
		* The user is drag - resizing the window.
		*
		* @param x The x coordinate of the current drag coordinate.
		* @param y the y coordinate of the current drag coordinate.
		*/
		@VisibleForTesting
		void resizeDrag(float x, float y) {
		updateDraggedBounds(TaskResizingAlgorithm.resizeDrag(x, y, mStartDragX, mStartDragY,
		mWindowOriginalBounds, mCtrlType, mMinVisibleWidth, mMinVisibleHeight,
		mMaxVisibleSize, mPreserveOrientation, mStartOrientationWasLandscape));
		}

		private void updateDraggedBounds(Rect newBounds) {
		mWindowDragBounds.set(newBounds);

		checkBoundsForOrientationViolations(mWindowDragBounds);
		}

		/**
		* Validate bounds against orientation violations (if DEBUG_ORIENTATION_VIOLATIONS is set).
		*
		* @param bounds The bounds to be checked.
		*/
		private void checkBoundsForOrientationViolations(Rect bounds) {
		// When using debug check that we are not violating the given constraints.
		if (DEBUG_ORIENTATION_VIOLATIONS) {
		if (mStartOrientationWasLandscape != (bounds.width() >= bounds.height())) {
		Slog.e(TAG, "Orientation violation detected! should be "
		+ (mStartOrientationWasLandscape ? "landscape" : "portrait")
		+ " but is the other");
		} else {
		Slog.v(TAG, "new bounds size: " + bounds.width() + " x " + bounds.height());
		}
		if (mMinVisibleWidth > bounds.width() \|\| mMinVisibleHeight > bounds.height()) {
		Slog.v(TAG, "Minimum requirement violated: Width(min, is)=(" + mMinVisibleWidth
		+ ", " + bounds.width() + ") Height(min,is)=("
		+ mMinVisibleHeight + ", " + bounds.height() + ")");
		}
		if (mMaxVisibleSize.x < bounds.width() \|\| mMaxVisibleSize.y < bounds.height()) {
		Slog.v(TAG, "Maximum requirement violated: Width(min, is)=(" + mMaxVisibleSize.x
		+ ", " + bounds.width() + ") Height(min,is)=("
		+ mMaxVisibleSize.y + ", " + bounds.height() + ")");
		}
		}
		}

		private void updateWindowDragBounds(int x, int y, Rect rootTaskBounds) {
		final int offsetX = Math.round(x - mStartDragX);
		final int offsetY = Math.round(y - mStartDragY);
		mWindowDragBounds.set(mWindowOriginalBounds);
		// Horizontally, at least mMinVisibleWidth pixels of the window should remain visible.
		final int maxLeft = rootTaskBounds.right - mMinVisibleWidth;
		final int minLeft = rootTaskBounds.left + mMinVisibleWidth - mWindowOriginalBounds.width();

		// Vertically, the top mMinVisibleHeight of the window should remain visible.
		// (This assumes that the window caption bar is at the top of the window).
		final int minTop = rootTaskBounds.top;
		final int maxTop = rootTaskBounds.bottom - mMinVisibleHeight;

		mWindowDragBounds.offsetTo(
		Math.min(Math.max(mWindowOriginalBounds.left + offsetX, minLeft), maxLeft),
		Math.min(Math.max(mWindowOriginalBounds.top + offsetY, minTop), maxTop));

		if (DEBUG_TASK_POSITIONING) Slog.d(TAG,
		"updateWindowDragBounds: " + mWindowDragBounds);
		}

		public String toShortString() {
		return TAG;
		}

		static void setFactory(Factory factory) {
		sFactory = factory;
		}

		static TaskPositioner create(WindowManagerService service) {
		if (sFactory == null) {
		sFactory = new Factory() {};
		}

		return sFactory.create(service);
		}

		@Override
		public void binderDied() {
		mService.mTaskPositioningController.finishTaskPositioning();
		}

		interface Factory {
		default TaskPositioner create(WindowManagerService service) {
		return new TaskPositioner(service);
		}
		}
		}