WM: Fix seamless rotation
With the introduction of the surface hierarchy, the seamless rotation
behavior in WSA is no longer correct: it also applies the WindowState's
offset, which leads to that being applied twice.
Instead of doing that, we simply rotate the WSA surface within the place
that WindowState dictates now.
Finally, the location of the WindowState itself also needs to be
transformed into the new orientation.
Fixes: 109927566
Test: atest CoordinateTransformsTest
Test: atest 'WindowStateTests#testSeamlesslyRotateWindow'
Change-Id: I9fb27a0a8a2bddc6ec88a4fcce6d6ea00929fb91
diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java
index b0e6208..2857603 100644
--- a/services/core/java/com/android/server/wm/DisplayContent.java
+++ b/services/core/java/com/android/server/wm/DisplayContent.java
@@ -1107,10 +1107,7 @@
}
if (rotateSeamlessly) {
- forAllWindows(w -> {
- w.mWinAnimator.seamlesslyRotateWindow(getPendingTransaction(),
- oldRotation, rotation);
- }, true /* traverseTopToBottom */);
+ seamlesslyRotate(getPendingTransaction(), oldRotation, rotation);
}
mService.mDisplayManagerInternal.performTraversal(getPendingTransaction());
diff --git a/services/core/java/com/android/server/wm/WindowContainer.java b/services/core/java/com/android/server/wm/WindowContainer.java
index 19c5a3d..8fe7063 100644
--- a/services/core/java/com/android/server/wm/WindowContainer.java
+++ b/services/core/java/com/android/server/wm/WindowContainer.java
@@ -736,6 +736,20 @@
}
/**
+ * Seamlessly rotates the container, by recomputing the location in the new
+ * rotation, and rotating buffers until they are updated for the new rotation.
+ *
+ * @param t the transaction to perform the seamless rotation in
+ * @param oldRotation the rotation we are rotating from
+ * @param newRotation the rotation we are rotating to
+ */
+ void seamlesslyRotate(Transaction t, int oldRotation, int newRotation) {
+ for (int i = mChildren.size() - 1; i >= 0; --i) {
+ mChildren.get(i).seamlesslyRotate(t, oldRotation, newRotation);
+ }
+ }
+
+ /**
* Returns true if this container is opaque and fills all the space made available by its parent
* container.
*
diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java
index bee70a0..83a6315 100644
--- a/services/core/java/com/android/server/wm/WindowState.java
+++ b/services/core/java/com/android/server/wm/WindowState.java
@@ -150,6 +150,8 @@
import static com.android.server.wm.WindowStateProto.VISIBLE_FRAME;
import static com.android.server.wm.WindowStateProto.VISIBLE_INSETS;
import static com.android.server.wm.WindowStateProto.WINDOW_CONTAINER;
+import static com.android.server.wm.utils.CoordinateTransforms.transformRect;
+import static com.android.server.wm.utils.CoordinateTransforms.transformToRotation;
import android.annotation.CallSuper;
import android.app.AppOpsManager;
@@ -1811,7 +1813,8 @@
&& (mAttrs.privateFlags & PRIVATE_FLAG_NO_MOVE_ANIMATION) == 0
&& !isDragResizing() && !adjustedForMinimizedDockOrIme
&& getWindowConfiguration().hasMovementAnimations()
- && !mWinAnimator.mLastHidden) {
+ && !mWinAnimator.mLastHidden
+ && !mSeamlesslyRotated) {
startMoveAnimation(left, top);
}
@@ -4850,6 +4853,29 @@
mFrameNumber = frameNumber;
}
+ @Override
+ void seamlesslyRotate(Transaction t, int oldRotation, int newRotation) {
+ if (!isVisibleNow() || mIsWallpaper) {
+ return;
+ }
+ final Matrix transform = mTmpMatrix;
+
+ mService.markForSeamlessRotation(this, true);
+
+ // We rotated the screen, but have not performed a new layout pass yet. In the mean time,
+ // we recompute the coordinates of mFrame in the new orientation, so the surface can be
+ // properly placed.
+ transformToRotation(oldRotation, newRotation, getDisplayInfo(), transform);
+ transformRect(transform, mFrame, null /* tmpRectF */);
+
+ updateSurfacePosition(t);
+ mWinAnimator.seamlesslyRotate(t, oldRotation, newRotation);
+
+ // Dispatch to children only after mFrame has been updated, as it's needed in the
+ // child's updateSurfacePosition.
+ super.seamlesslyRotate(t, oldRotation, newRotation);
+ }
+
private final class MoveAnimationSpec implements AnimationSpec {
private final long mDuration;
diff --git a/services/core/java/com/android/server/wm/WindowStateAnimator.java b/services/core/java/com/android/server/wm/WindowStateAnimator.java
index 3eef125..989d694 100644
--- a/services/core/java/com/android/server/wm/WindowStateAnimator.java
+++ b/services/core/java/com/android/server/wm/WindowStateAnimator.java
@@ -46,13 +46,13 @@
import static com.android.server.wm.WindowStateAnimatorProto.LAST_CLIP_RECT;
import static com.android.server.wm.WindowStateAnimatorProto.SURFACE;
import static com.android.server.wm.WindowStateAnimatorProto.SYSTEM_DECOR_RECT;
+import static com.android.server.wm.utils.CoordinateTransforms.transformToRotation;
import android.content.Context;
import android.graphics.Matrix;
import android.graphics.PixelFormat;
import android.graphics.Point;
import android.graphics.Rect;
-import android.graphics.RectF;
import android.graphics.Region;
import android.os.Debug;
import android.os.Trace;
@@ -1492,40 +1492,14 @@
}
}
- void seamlesslyRotateWindow(SurfaceControl.Transaction t,
- int oldRotation, int newRotation) {
+ void seamlesslyRotate(SurfaceControl.Transaction t, int oldRotation, int newRotation) {
final WindowState w = mWin;
- if (!w.isVisibleNow() || w.mIsWallpaper) {
- return;
- }
- final Rect cropRect = mService.mTmpRect;
- final Rect displayRect = mService.mTmpRect2;
- final RectF frameRect = mService.mTmpRectF;
+ // We rotated the screen, but have not received a new buffer with the correct size yet. In
+ // the mean time, we rotate the buffer we have to the new orientation.
final Matrix transform = mService.mTmpTransform;
-
- final float x = w.mFrame.left;
- final float y = w.mFrame.top;
- final float width = w.mFrame.width();
- final float height = w.mFrame.height();
-
- mService.getDefaultDisplayContentLocked().getBounds(displayRect);
- final float displayWidth = displayRect.width();
- final float displayHeight = displayRect.height();
-
- // Compute a transform matrix to undo the coordinate space transformation,
- // and present the window at the same physical position it previously occupied.
- final int deltaRotation = DisplayContent.deltaRotation(newRotation, oldRotation);
- DisplayContent.createRotationMatrix(deltaRotation, x, y, displayWidth, displayHeight,
+ transformToRotation(oldRotation, newRotation, w.mFrame.width(), w.mFrame.height(),
transform);
-
- // We just need to apply a rotation matrix to the window. For example
- // if we have a portrait window and rotate to landscape, the window is still portrait
- // and now extends off the bottom of the screen (and only halfway across). Essentially we
- // apply a transform to display the current buffer at it's old position
- // (in the new coordinate space). We then freeze layer updates until the resize
- // occurs, at which point we undo, them.
- mService.markForSeamlessRotation(w, true);
transform.getValues(mService.mTmpFloats);
float DsDx = mService.mTmpFloats[Matrix.MSCALE_X];
diff --git a/services/core/java/com/android/server/wm/utils/CoordinateTransforms.java b/services/core/java/com/android/server/wm/utils/CoordinateTransforms.java
index 09d7b5d..a2f37a5 100644
--- a/services/core/java/com/android/server/wm/utils/CoordinateTransforms.java
+++ b/services/core/java/com/android/server/wm/utils/CoordinateTransforms.java
@@ -22,7 +22,11 @@
import static android.view.Surface.ROTATION_90;
import android.annotation.Dimension;
+import android.annotation.Nullable;
import android.graphics.Matrix;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.view.DisplayInfo;
import android.view.Surface.Rotation;
public class CoordinateTransforms {
@@ -59,4 +63,93 @@
throw new IllegalArgumentException("Unknown rotation: " + rotation);
}
}
+
+ /**
+ * Sets a matrix such that given a rotation, it transforms that rotation's logical coordinates
+ * to physical coordinates.
+ *
+ * @param rotation the rotation to which the matrix should transform
+ * @param out the matrix to be set
+ */
+ public static void transformLogicalToPhysicalCoordinates(@Rotation int rotation,
+ @Dimension int physicalWidth, @Dimension int physicalHeight, Matrix out) {
+ switch (rotation) {
+ case ROTATION_0:
+ out.reset();
+ break;
+ case ROTATION_90:
+ out.setRotate(90);
+ out.preTranslate(0, -physicalWidth);
+ break;
+ case ROTATION_180:
+ out.setRotate(180);
+ out.preTranslate(-physicalWidth, -physicalHeight);
+ break;
+ case ROTATION_270:
+ out.setRotate(270);
+ out.preTranslate(-physicalHeight, 0);
+ break;
+ default:
+ throw new IllegalArgumentException("Unknown rotation: " + rotation);
+ }
+ }
+
+ /**
+ * Sets a matrix such that given a two rotations, that it transforms coordinates given in the
+ * old rotation to coordinates that refer to the same physical location in the new rotation.
+ *
+ * @param oldRotation the rotation to transform from
+ * @param newRotation the rotation to transform to
+ * @param info the display info
+ * @param out a matrix that will be set to the transform
+ */
+ public static void transformToRotation(@Rotation int oldRotation,
+ @Rotation int newRotation, DisplayInfo info, Matrix out) {
+ final boolean flipped = info.rotation == ROTATION_90 || info.rotation == ROTATION_270;
+ final int h = flipped ? info.logicalWidth : info.logicalHeight;
+ final int w = flipped ? info.logicalHeight : info.logicalWidth;
+
+ final Matrix tmp = new Matrix();
+ transformLogicalToPhysicalCoordinates(oldRotation, w, h, out);
+ transformPhysicalToLogicalCoordinates(newRotation, w, h, tmp);
+ out.postConcat(tmp);
+ }
+
+ /**
+ * Sets a matrix such that given a two rotations, that it transforms coordinates given in the
+ * old rotation to coordinates that refer to the same physical location in the new rotation.
+ *
+ * @param oldRotation the rotation to transform from
+ * @param newRotation the rotation to transform to
+ * @param newWidth the width of the area to transform, in the new rotation
+ * @param newHeight the height of the area to transform, in the new rotation
+ * @param out a matrix that will be set to the transform
+ */
+ public static void transformToRotation(@Rotation int oldRotation,
+ @Rotation int newRotation, int newWidth, int newHeight, Matrix out) {
+ final boolean flipped = newRotation == ROTATION_90 || newRotation == ROTATION_270;
+ final int h = flipped ? newWidth : newHeight;
+ final int w = flipped ? newHeight : newWidth;
+
+ final Matrix tmp = new Matrix();
+ transformLogicalToPhysicalCoordinates(oldRotation, w, h, out);
+ transformPhysicalToLogicalCoordinates(newRotation, w, h, tmp);
+ out.postConcat(tmp);
+ }
+
+ /**
+ * Transforms a rect using a transformation matrix
+ *
+ * @param transform the transformation to apply to the rect
+ * @param inOutRect the rect to transform
+ * @param tmp a temporary value, if null the function will allocate its own.
+ */
+ public static void transformRect(Matrix transform, Rect inOutRect, @Nullable RectF tmp) {
+ if (tmp == null) {
+ tmp = new RectF();
+ }
+ tmp.set(inOutRect);
+ transform.mapRect(tmp);
+ inOutRect.set((int) tmp.left, (int) tmp.top, (int) tmp.right, (int) tmp.bottom);
+ }
}
diff --git a/services/tests/servicestests/src/com/android/server/wm/WindowStateTests.java b/services/tests/servicestests/src/com/android/server/wm/WindowStateTests.java
index 85e846d..9f113ad 100644
--- a/services/tests/servicestests/src/com/android/server/wm/WindowStateTests.java
+++ b/services/tests/servicestests/src/com/android/server/wm/WindowStateTests.java
@@ -16,6 +16,8 @@
package com.android.server.wm;
+import android.graphics.Rect;
+import android.view.SurfaceControl;
import android.view.WindowManager;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -29,6 +31,8 @@
import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
+import static android.hardware.camera2.params.OutputConfiguration.ROTATION_90;
+import static android.view.Surface.ROTATION_0;
import static android.view.WindowManager.LayoutParams.FIRST_SUB_WINDOW;
import static android.view.WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;
import static android.view.WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
@@ -48,8 +52,10 @@
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.spy;
@@ -349,6 +355,32 @@
assertThat(app.getDisplayId(), is(mDisplayContent.getDisplayId()));
}
+ @Test
+ public void testSeamlesslyRotateWindow() {
+ final WindowState app = createWindow(null, TYPE_APPLICATION, "app");
+ final SurfaceControl.Transaction t = mock(SurfaceControl.Transaction.class);
+
+ app.mHasSurface = true;
+ app.mSurfaceControl = mock(SurfaceControl.class);
+ app.mWinAnimator.mSurfaceController = mock(WindowSurfaceController.class);
+ try {
+ app.mFrame.set(10, 20, 60, 80);
+
+ app.seamlesslyRotate(t, ROTATION_0, ROTATION_90);
+
+ assertTrue(app.mSeamlesslyRotated);
+ assertEquals(new Rect(20, mDisplayInfo.logicalWidth - 60,
+ 80, mDisplayInfo.logicalWidth - 10), app.mFrame);
+
+ verify(t).setPosition(app.mSurfaceControl, app.mFrame.left, app.mFrame.top);
+ verify(app.mWinAnimator.mSurfaceController).setPosition(t, 0, 50, false);
+ verify(app.mWinAnimator.mSurfaceController).setMatrix(t, 0, -1, 1, 0, false);
+ } finally {
+ app.mSurfaceControl = null;
+ app.mHasSurface = false;
+ }
+ }
+
private void testPrepareWindowToDisplayDuringRelayout(boolean wasVisible) {
reset(mPowerManagerWrapper);
final WindowState root = createWindow(null, TYPE_APPLICATION, "root");
diff --git a/services/tests/servicestests/src/com/android/server/wm/utils/CoordinateTransformsTest.java b/services/tests/servicestests/src/com/android/server/wm/utils/CoordinateTransformsTest.java
index 40a10e0..361522c 100644
--- a/services/tests/servicestests/src/com/android/server/wm/utils/CoordinateTransformsTest.java
+++ b/services/tests/servicestests/src/com/android/server/wm/utils/CoordinateTransformsTest.java
@@ -21,14 +21,19 @@
import static android.view.Surface.ROTATION_270;
import static android.view.Surface.ROTATION_90;
+import static com.android.server.wm.utils.CoordinateTransforms.transformLogicalToPhysicalCoordinates;
import static com.android.server.wm.utils.CoordinateTransforms.transformPhysicalToLogicalCoordinates;
+
+import static com.android.server.wm.utils.CoordinateTransforms.transformToRotation;
+
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.*;
import android.graphics.Matrix;
import android.graphics.Point;
import android.graphics.PointF;
+import android.view.DisplayInfo;
import org.junit.Before;
import org.junit.Rule;
@@ -41,6 +46,7 @@
private static final int H = 400;
private final Matrix mMatrix = new Matrix();
+ private final Matrix mMatrix2 = new Matrix();
@Rule
public final ErrorCollector mErrorCollector = new ErrorCollector();
@@ -48,39 +54,140 @@
@Before
public void setUp() throws Exception {
mMatrix.setTranslate(0xdeadbeef, 0xdeadbeef);
+ mMatrix2.setTranslate(0xbeefdead, 0xbeefdead);
}
@Test
- public void transformPhysicalToLogicalCoordinates_rot0() throws Exception {
+ public void transformPhysicalToLogicalCoordinates_rot0() {
transformPhysicalToLogicalCoordinates(ROTATION_0, W, H, mMatrix);
assertThat(mMatrix, is(Matrix.IDENTITY_MATRIX));
}
@Test
- public void transformPhysicalToLogicalCoordinates_rot90() throws Exception {
+ public void transformPhysicalToLogicalCoordinates_rot90() {
transformPhysicalToLogicalCoordinates(ROTATION_90, W, H, mMatrix);
- checkDevicePoint(0, 0).mapsToLogicalPoint(0, W);
- checkDevicePoint(W, H).mapsToLogicalPoint(H, 0);
+ checkPoint(0, 0).transformsTo(0, W);
+ checkPoint(W, H).transformsTo(H, 0);
}
@Test
- public void transformPhysicalToLogicalCoordinates_rot180() throws Exception {
+ public void transformPhysicalToLogicalCoordinates_rot180() {
transformPhysicalToLogicalCoordinates(ROTATION_180, W, H, mMatrix);
- checkDevicePoint(0, 0).mapsToLogicalPoint(W, H);
- checkDevicePoint(W, H).mapsToLogicalPoint(0, 0);
+ checkPoint(0, 0).transformsTo(W, H);
+ checkPoint(W, H).transformsTo(0, 0);
}
@Test
- public void transformPhysicalToLogicalCoordinates_rot270() throws Exception {
+ public void transformPhysicalToLogicalCoordinates_rot270() {
transformPhysicalToLogicalCoordinates(ROTATION_270, W, H, mMatrix);
- checkDevicePoint(0, 0).mapsToLogicalPoint(H, 0);
- checkDevicePoint(W, H).mapsToLogicalPoint(0, W);
+ checkPoint(0, 0).transformsTo(H, 0);
+ checkPoint(W, H).transformsTo(0, W);
}
- private DevicePointAssertable checkDevicePoint(int x, int y) {
+ @Test
+ public void transformLogicalToPhysicalCoordinates_rot0() {
+ transformLogicalToPhysicalCoordinates(ROTATION_0, W, H, mMatrix);
+ assertThat(mMatrix, is(Matrix.IDENTITY_MATRIX));
+ }
+
+ @Test
+ public void transformLogicalToPhysicalCoordinates_rot90() {
+ transformLogicalToPhysicalCoordinates(ROTATION_90, W, H, mMatrix);
+
+ checkPoint(0, W).transformsTo(0, 0);
+ checkPoint(H, 0).transformsTo(W, H);
+}
+
+ @Test
+ public void transformLogicalToPhysicalCoordinates_rot180() {
+ transformLogicalToPhysicalCoordinates(ROTATION_180, W, H, mMatrix);
+
+ checkPoint(W, H).transformsTo(0, 0);
+ checkPoint(0, 0).transformsTo(W, H);
+ }
+
+ @Test
+ public void transformLogicalToPhysicalCoordinates_rot270() {
+ transformLogicalToPhysicalCoordinates(ROTATION_270, W, H, mMatrix);
+
+ checkPoint(H, 0).transformsTo(0, 0);
+ checkPoint(0, W).transformsTo(W, H);
+ }
+
+ @Test
+ public void transformLogicalToPhysicalCoordinatesIsInverse_rot0() {
+ transformLogicalToPhysicalCoordinates(ROTATION_0, W, H, mMatrix);
+ transformPhysicalToLogicalCoordinates(ROTATION_0, W, H, mMatrix2);
+
+ assertMatricesAreInverses(mMatrix, mMatrix2);
+ }
+
+ @Test
+ public void transformLogicalToPhysicalCoordinatesIsInverse_rot90() {
+ transformLogicalToPhysicalCoordinates(ROTATION_90, W, H, mMatrix);
+ transformPhysicalToLogicalCoordinates(ROTATION_90, W, H, mMatrix2);
+
+ assertMatricesAreInverses(mMatrix, mMatrix2);
+ }
+
+ @Test
+ public void transformLogicalToPhysicalCoordinatesIsInverse_rot180() {
+ transformLogicalToPhysicalCoordinates(ROTATION_180, W, H, mMatrix);
+ transformPhysicalToLogicalCoordinates(ROTATION_180, W, H, mMatrix2);
+
+ assertMatricesAreInverses(mMatrix, mMatrix2);
+ }
+
+ @Test
+ public void transformLogicalToPhysicalCoordinatesIsInverse_rot270() {
+ transformLogicalToPhysicalCoordinates(ROTATION_270, W, H, mMatrix);
+ transformPhysicalToLogicalCoordinates(ROTATION_270, W, H, mMatrix2);
+
+ assertMatricesAreInverses(mMatrix, mMatrix2);
+ }
+
+ @Test
+ public void transformBetweenRotations_rot180_rot270() {
+ // W,H are flipped, because they need to be given in the new orientation, i.e. ROT_270.
+ transformToRotation(ROTATION_180, ROTATION_270, H, W, mMatrix);
+
+ checkPoint(0, 0).transformsTo(0, W);
+ checkPoint(W, H).transformsTo(H, 0);
+ }
+
+ @Test
+ public void transformBetweenRotations_rot90_rot0() {
+ transformToRotation(ROTATION_180, ROTATION_270, W, H, mMatrix);
+
+ checkPoint(0, 0).transformsTo(0, H);
+ // H,W is bottom right in ROT_90
+ checkPoint(H, W).transformsTo(W, 0);
+ }
+
+ @Test
+ public void transformBetweenRotations_displayInfo() {
+ final DisplayInfo di = new DisplayInfo();
+ di.rotation = ROTATION_90;
+ di.logicalWidth = H; // dimensions are flipped in ROT_90
+ di.logicalHeight = W;
+ transformToRotation(ROTATION_180, ROTATION_270, di, mMatrix);
+
+ // W,H are flipped, because they need to be given in the new orientation, i.e. ROT_270.
+ transformToRotation(ROTATION_180, ROTATION_270, H, W, mMatrix2);
+
+ assertEquals(mMatrix2, mMatrix);
+ }
+
+ private void assertMatricesAreInverses(Matrix matrix, Matrix matrix2) {
+ final Matrix concat = new Matrix();
+ concat.setConcat(matrix, matrix2);
+ assertTrue("expected identity, but was: " + concat, concat.isIdentity());
+ }
+
+ private TransformPointAssertable checkPoint(int x, int y) {
final Point devicePoint = new Point(x, y);
final float[] fs = new float[] {x, y};
mMatrix.mapPoints(fs);
@@ -92,7 +199,7 @@
};
}
- public interface DevicePointAssertable {
- void mapsToLogicalPoint(int x, int y);
+ public interface TransformPointAssertable {
+ void transformsTo(int x, int y);
}
}
\ No newline at end of file
