Merge "Remove two-finger scroll specific code" (3f94a2e3) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/am/ActivityManagerService.java

+1 −10

Original line number	Diff line number	Diff line
		@@ -9346,16 +9346,6 @@ public final class ActivityManagerService extends ActivityManagerNative
		Slog.w(TAG, "resizeTask: taskId=" + taskId + " not found");
		return;
		}
		int stackId = task.stack.mStackId;
		// We allow the task to scroll instead of resizing if this is a non-resizeable task
		// in crop windows resize mode or if the task size is affected by the docked stack
		// changing size. No need to update configuration.
		if (bounds != null && task.inCropWindowsResizeMode()
		&& mStackSupervisor.isStackDockedInEffect(stackId)) {
		mWindowManager.scrollTask(task.taskId, bounds);
		return;
		}

		// Place the task in the right stack if it isn't there already based on
		// the requested bounds.
		// The stack transition logic is:
		@@ -9363,6 +9353,7 @@ public final class ActivityManagerService extends ActivityManagerNative
		// - a non-null bounds on a non-freeform (fullscreen OR docked) task moves
		// that task to freeform
		// - otherwise the task is not moved
		int stackId = task.stack.mStackId;
		if (!StackId.isTaskResizeAllowed(stackId)) {
		throw new IllegalArgumentException("resizeTask not allowed on task=" + task);
		}

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

+1 −10

Original line number	Diff line number	Diff line
		@@ -94,9 +94,6 @@ class DisplayContent {
		/** Detect user tapping outside of current focused stack bounds .*/
		Region mTouchExcludeRegion = new Region();

		/** Detect user tapping in a non-resizeable task in docked or fullscreen stack .*/
		Region mNonResizeableRegion = new Region();

		/** Save allocating when calculating rects */
		private final Rect mTmpRect = new Rect();
		private final Rect mTmpRect2 = new Rect();
		@@ -358,7 +355,6 @@ class DisplayContent {
		mTouchExcludeRegion.set(mBaseDisplayRect);
		final int delta = mService.dipToPixel(RESIZE_HANDLE_WIDTH_IN_DP, mDisplayMetrics);
		boolean addBackFocusedTask = false;
		mNonResizeableRegion.setEmpty();
		for (int stackNdx = mStacks.size() - 1; stackNdx >= 0; --stackNdx) {
		TaskStack stack = mStacks.get(stackNdx);
		final ArrayList<Task> tasks = stack.getTasks();
		@@ -400,11 +396,6 @@ class DisplayContent {
		}
		mTouchExcludeRegion.op(mTmpRect, Region.Op.DIFFERENCE);
		}
		if (task.isTwoFingerScrollMode()) {
		stack.getBounds(mTmpRect);
		mNonResizeableRegion.op(mTmpRect, Region.Op.UNION);
		break;
		}
		}
		}
		// If we removed the focused task above, add it back and only leave its
		@@ -432,7 +423,7 @@ class DisplayContent {
		mTouchExcludeRegion.op(mTmpRegion, Op.UNION);
		}
		if (mTapDetector != null) {
		mTapDetector.setTouchExcludeRegion(mTouchExcludeRegion, mNonResizeableRegion);
		mTapDetector.setTouchExcludeRegion(mTouchExcludeRegion);
		}
		}

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

+0 −8

Original line number	Diff line number	Diff line
		@@ -201,14 +201,6 @@ final class InputMonitor implements InputManagerService.WindowManagerCallbacks {
		inputWindowHandle.frameRight = frame.right;
		inputWindowHandle.frameBottom = frame.bottom;

		if (child.isDockedInEffect()) {
		// Adjust to account for non-resizeable tasks that's scrolled
		inputWindowHandle.frameLeft += child.mXOffset;
		inputWindowHandle.frameTop += child.mYOffset;
		inputWindowHandle.frameRight += child.mXOffset;
		inputWindowHandle.frameBottom += child.mYOffset;
		}

		if (child.mGlobalScale != 1) {
		// If we are scaling the window, input coordinates need
		// to be inversely scaled to map from what is on screen

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

+9 −98

Original line number	Diff line number	Diff line
		@@ -65,9 +65,6 @@ class Task implements DimLayer.DimLayerUser {
		final Rect mPreparedFrozenBounds = new Rect();
		final Configuration mPreparedFrozenMergedConfig = new Configuration();

		private Rect mPreScrollBounds = new Rect();
		private boolean mScrollValid;

		// Bounds used to calculate the insets.
		private final Rect mTempInsetBounds = new Rect();

		@@ -234,22 +231,19 @@ class Task implements DimLayer.DimLayerUser {
		// Can't set to fullscreen if we don't have a display to get bounds from...
		return BOUNDS_CHANGE_NONE;
		}
		if (mPreScrollBounds.equals(bounds) && oldFullscreen == mFullscreen && mRotation == rotation) {
		if (mBounds.equals(bounds) && oldFullscreen == mFullscreen && mRotation == rotation) {
		return BOUNDS_CHANGE_NONE;
		}

		int boundsChange = BOUNDS_CHANGE_NONE;
		if (mPreScrollBounds.left != bounds.left \|\| mPreScrollBounds.top != bounds.top) {
		if (mBounds.left != bounds.left \|\| mBounds.top != bounds.top) {
		boundsChange \|= BOUNDS_CHANGE_POSITION;
		}
		if (mPreScrollBounds.width() != bounds.width() \|\| mPreScrollBounds.height() != bounds.height()) {
		if (mBounds.width() != bounds.width() \|\| mBounds.height() != bounds.height()) {
		boundsChange \|= BOUNDS_CHANGE_SIZE;
		}


		mPreScrollBounds.set(bounds);

		resetScrollLocked();
		mBounds.set(bounds);

		mRotation = rotation;
		if (displayContent != null) {
		@@ -352,67 +346,6 @@ class Task implements DimLayer.DimLayerUser {
		resizeLocked(mTmpRect2, mOverrideConfig, false /* forced */);
		}

		void resetScrollLocked() {
		if (mScrollValid) {
		mScrollValid = false;
		applyScrollToAllWindows(0, 0);
		}
		mBounds.set(mPreScrollBounds);
		}

		void applyScrollToAllWindows(final int xOffset, final int yOffset) {
		for (int activityNdx = mAppTokens.size() - 1; activityNdx >= 0; --activityNdx) {
		final ArrayList<WindowState> windows = mAppTokens.get(activityNdx).allAppWindows;
		for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {
		final WindowState win = windows.get(winNdx);
		win.mXOffset = xOffset;
		win.mYOffset = yOffset;
		}
		}
		}

		void applyScrollToWindowIfNeeded(final WindowState win) {
		if (mScrollValid) {
		win.mXOffset = mBounds.left;
		win.mYOffset = mBounds.top;
		}
		}

		boolean scrollLocked(Rect bounds) {
		// shift the task bound if it doesn't fully cover the stack area
		mStack.getDimBounds(mTmpRect);
		if (mService.mCurConfiguration.orientation == ORIENTATION_LANDSCAPE) {
		if (bounds.left > mTmpRect.left) {
		bounds.left = mTmpRect.left;
		bounds.right = mTmpRect.left + mBounds.width();
		} else if (bounds.right < mTmpRect.right) {
		bounds.left = mTmpRect.right - mBounds.width();
		bounds.right = mTmpRect.right;
		}
		} else {
		if (bounds.top > mTmpRect.top) {
		bounds.top = mTmpRect.top;
		bounds.bottom = mTmpRect.top + mBounds.height();
		} else if (bounds.bottom < mTmpRect.bottom) {
		bounds.top = mTmpRect.bottom - mBounds.height();
		bounds.bottom = mTmpRect.bottom;
		}
		}

		// We can stop here if we're already scrolling and the scrolled bounds not changed.
		if (mScrollValid && bounds.equals(mBounds)) {
		return false;
		}

		// Normal setBounds() does not allow non-null bounds for fullscreen apps.
		// We only change bounds for the scrolling case without change it size,
		// on resizing path we should still want the validation.
		mBounds.set(bounds);
		mScrollValid = true;
		applyScrollToAllWindows(bounds.left, bounds.top);
		return true;
		}

		/** Return true if the current bound can get outputted to the rest of the system as-is. */
		private boolean useCurrentBounds() {
		final DisplayContent displayContent = mStack.getDisplayContent();
		@@ -583,11 +516,11 @@ class Task implements DimLayer.DimLayerUser {
		}

		// Device rotation changed.
		// - Reset the bounds to the pre-scroll bounds as whatever scrolling was done is no longer
		// valid.
		// - We don't want the task to move around on the screen when this happens, so update the
		// task bounds so it stays in the same place.
		// - Rotate the bounds and notify activity manager if the task can be resized independently
		// from its stack. The stack will take care of task rotation for the other case.
		mTmpRect2.set(mPreScrollBounds);
		mTmpRect2.set(mBounds);

		if (!StackId.isTaskResizeAllowed(mStack.mStackId)) {
		setBounds(mTmpRect2, mOverrideConfig);
		@@ -600,7 +533,7 @@ class Task implements DimLayer.DimLayerUser {
		// call. We do this to prevent a deadlock between window manager lock and activity
		// manager lock been held.
		mService.mH.obtainMessage(RESIZE_TASK, mTaskId,
		RESIZE_MODE_SYSTEM_SCREEN_ROTATION, mPreScrollBounds).sendToTarget();
		RESIZE_MODE_SYSTEM_SCREEN_ROTATION, mBounds).sendToTarget();
		}
		}

		@@ -708,36 +641,14 @@ class Task implements DimLayer.DimLayerUser {
		return mStack != null && mStack.mStackId == FREEFORM_WORKSPACE_STACK_ID;
		}

		boolean inDockedWorkspace() {
		return mStack != null && mStack.mStackId == DOCKED_STACK_ID;
		}

		boolean inPinnedWorkspace() {
		return mStack != null && mStack.mStackId == PINNED_STACK_ID;
		}

		boolean isResizeableByDockedStack() {
		final DisplayContent displayContent = getDisplayContent();
		return displayContent != null && displayContent.getDockedStackLocked() != null
		&& mStack != null && StackId.isTaskResizeableByDockedStack(mStack.mStackId);
		}

		boolean isFloating() {
		return StackId.tasksAreFloating(mStack.mStackId);
		}

		/**
		* Whether the task should be treated as if it's docked. Returns true if the task
		* is currently in docked workspace, or it's side-by-side to a docked task.
		*/
		boolean isDockedInEffect() {
		return inDockedWorkspace() \|\| isResizeableByDockedStack();
		}

		boolean isTwoFingerScrollMode() {
		return inCropWindowsResizeMode() && isDockedInEffect();
		}

		WindowState getTopVisibleAppMainWindow() {
		final AppWindowToken token = getTopVisibleAppToken();
		return token != null ? token.findMainWindow() : null;

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

+24 −47

Original line number	Diff line number	Diff line
		@@ -345,20 +345,12 @@ class TaskPositioner implements DimLayer.DimLayerUser {
		mStartDragX = startX;
		mStartDragY = startY;

		if (mTask.isDockedInEffect()) {
		// If this is a docked task or if task size is affected by docked stack changing size,
		// we can only be here if the task is not resizeable and we're handling a two-finger
		// scrolling. Use the original task bounds to position the task, the dim bounds
		// is cropped and doesn't move.
		mTask.getBounds(mTmpRect);
		} else {
		// Use the dim bounds, not the original task bounds. The cursor
		// movement should be calculated relative to the visible bounds.
		// Also, use the dim 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.
		mTask.getDimBounds(mTmpRect);
		}

		if (resize) {
		if (startX < mTmpRect.left) {
		@@ -422,39 +414,24 @@ class TaskPositioner implements DimLayer.DimLayerUser {
		// This is a moving or scrolling operation.
		mTask.mStack.getDimBounds(mTmpRect);

		boolean dragEnded = false;
		int nX = (int) x;
		int nY = (int) y;
		if (!mTmpRect.contains(nX, nY)) {
		if (mTask.isDockedInEffect()) {
		// We end the scrolling operation if position is outside the stack bounds.
		dragEnded = true;
		} else {
		// 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);
		updateDimLayerVisibility(nX);
		return dragEnded;
		return false;
		}

		private void updateWindowDragBounds(int x, int y, Rect stackBounds) {
		final int offsetX = Math.round(x - mStartDragX);
		final int offsetY = Math.round(y - mStartDragY);
		mWindowDragBounds.set(mWindowOriginalBounds);
		if (mTask.isDockedInEffect()) {
		// Offset the bounds without clamp, the bounds will be shifted later
		// by window manager before applying the scrolling.
		if (mService.mCurConfiguration.orientation == ORIENTATION_LANDSCAPE) {
		mWindowDragBounds.offset(offsetX, 0);
		} else {
		mWindowDragBounds.offset(0, offsetY);
		}
		} else {
		// Horizontally, at least mMinVisibleWidth pixels of the window should remain visible.
		final int maxLeft = stackBounds.right - mMinVisibleWidth;
		final int minLeft = stackBounds.left + mMinVisibleWidth - mWindowOriginalBounds.width();
		@@ -467,7 +444,7 @@ class TaskPositioner implements DimLayer.DimLayerUser {
		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);
		}