Introduce fixed rotation transform
It allows activity to be shown in an orientation different
from the current display. This initial change only handles
the case when transiting to another activity with different
orientation.
The opening activity and its process will be updated with
rotated configuration. The rotated display frames and insets
are also associated to the activity, then the activity can
be layouted in the rotated bounds. The surface of activity
is rotated to fit current display. And the display will be
rotated seamlessly until the transition is done.
The function is disabled by default. It can be enabled by:
adb shell settings put global fixed_rotation_transform 1
Bug: 143053092
Bug: 146415879
Bug: 147469351
Test: atest DisplayContentTests#testApplyTopFixedRotationTransform
Change-Id: Iea15c6fc68133728e5fcda87ba4efd1850fdf5d4
diff --git a/services/core/java/com/android/server/wm/ActivityRecord.java b/services/core/java/com/android/server/wm/ActivityRecord.java
index b3b8159..b61a2ce 100644
--- a/services/core/java/com/android/server/wm/ActivityRecord.java
+++ b/services/core/java/com/android/server/wm/ActivityRecord.java
@@ -6224,6 +6224,13 @@
return mRemoteAnimationDefinition;
}
+ @Override
+ void applyFixedRotationTransform(DisplayInfo info, DisplayFrames displayFrames,
+ Configuration config) {
+ super.applyFixedRotationTransform(info, displayFrames, config);
+ ensureActivityConfiguration(0 /* globalChanges */, false /* preserveWindow */);
+ }
+
void setRequestedOrientation(int requestedOrientation) {
setOrientation(requestedOrientation, mayFreezeScreenLocked());
mAtmService.getTaskChangeNotificationController().notifyActivityRequestedOrientationChanged(
@@ -6462,11 +6469,20 @@
@Override
void resolveOverrideConfiguration(Configuration newParentConfiguration) {
- Configuration resolvedConfig = getResolvedOverrideConfiguration();
+ super.resolveOverrideConfiguration(newParentConfiguration);
+ final Configuration resolvedConfig = getResolvedOverrideConfiguration();
+ if (isFixedRotationTransforming()) {
+ // The resolved configuration is applied with rotated display configuration. If this
+ // activity matches its parent (the following resolving procedures are no-op), then it
+ // can use the resolved configuration directly. Otherwise (e.g. fixed aspect ratio),
+ // the rotated configuration is used as parent configuration to compute the actual
+ // resolved configuration. It is like putting the activity in a rotated container.
+ mTmpConfig.setTo(resolvedConfig);
+ newParentConfiguration = mTmpConfig;
+ }
if (mCompatDisplayInsets != null) {
resolveSizeCompatModeConfiguration(newParentConfiguration);
} else {
- super.resolveOverrideConfiguration(newParentConfiguration);
// We ignore activities' requested orientation in multi-window modes. Task level may
// take them into consideration when calculating bounds.
if (getParent() != null && getParent().inMultiWindowMode()) {
@@ -6495,7 +6511,6 @@
* inheriting the parent bounds.
*/
private void resolveSizeCompatModeConfiguration(Configuration newParentConfiguration) {
- super.resolveOverrideConfiguration(newParentConfiguration);
final Configuration resolvedConfig = getResolvedOverrideConfiguration();
final Rect resolvedBounds = resolvedConfig.windowConfiguration.getBounds();
@@ -6669,28 +6684,26 @@
mTmpPrevBounds.set(getBounds());
super.onConfigurationChanged(newParentConfig);
- final Rect overrideBounds = getResolvedOverrideBounds();
- if (task != null && !overrideBounds.isEmpty()
- // If the changes come from change-listener, the incoming parent configuration is
- // still the old one. Make sure their orientations are the same to reduce computing
- // the compatibility bounds for the intermediate state.
- && (task.getConfiguration().orientation == newParentConfig.orientation)) {
- final Rect taskBounds = task.getBounds();
- // Since we only center the activity horizontally, if only the fixed height is smaller
- // than its container, the override bounds don't need to take effect.
- if ((overrideBounds.width() != taskBounds.width()
- || overrideBounds.height() > taskBounds.height())) {
- calculateCompatBoundsTransformation(newParentConfig);
- updateSurfacePosition();
- } else if (mSizeCompatBounds != null) {
+ if (shouldUseSizeCompatMode()) {
+ final Rect overrideBounds = getResolvedOverrideBounds();
+ if (task != null && !overrideBounds.isEmpty()) {
+ final Rect taskBounds = task.getBounds();
+ // Since we only center the activity horizontally, if only the fixed height is
+ // smaller than its container, the override bounds don't need to take effect.
+ if ((overrideBounds.width() != taskBounds.width()
+ || overrideBounds.height() > taskBounds.height())) {
+ calculateCompatBoundsTransformation(newParentConfig);
+ updateSurfacePosition();
+ } else if (mSizeCompatBounds != null) {
+ mSizeCompatBounds = null;
+ mSizeCompatScale = 1f;
+ updateSurfacePosition();
+ }
+ } else if (overrideBounds.isEmpty()) {
mSizeCompatBounds = null;
mSizeCompatScale = 1f;
updateSurfacePosition();
}
- } else if (overrideBounds.isEmpty()) {
- mSizeCompatBounds = null;
- mSizeCompatScale = 1f;
- updateSurfacePosition();
}
final int newWinMode = getWindowingMode();
@@ -7710,6 +7723,12 @@
return;
}
win.getAnimationFrames(outFrame, outInsets, outStableInsets, outSurfaceInsets);
+ if (isFixedRotationTransforming()) {
+ // This activity has been rotated but the display is still in old rotation. Because the
+ // animation applies in display space coordinates, the rotated animation frames need to
+ // be unrotated to avoid being cropped.
+ unrotateAnimationFrames(outFrame, outInsets, outStableInsets, outSurfaceInsets);
+ }
}
void setPictureInPictureParams(PictureInPictureParams p) {
diff --git a/services/core/java/com/android/server/wm/AppTransition.java b/services/core/java/com/android/server/wm/AppTransition.java
index 014cb76..8cf0881 100644
--- a/services/core/java/com/android/server/wm/AppTransition.java
+++ b/services/core/java/com/android/server/wm/AppTransition.java
@@ -528,6 +528,12 @@
}
}
+ private void notifyAppTransitionTimeoutLocked() {
+ for (int i = 0; i < mListeners.size(); i++) {
+ mListeners.get(i).onAppTransitionTimeoutLocked();
+ }
+ }
+
private int notifyAppTransitionStartingLocked(int transit, long duration,
long statusBarAnimationStartTime, long statusBarAnimationDuration) {
int redoLayout = 0;
@@ -2300,6 +2306,7 @@
if (dc == null) {
return;
}
+ notifyAppTransitionTimeoutLocked();
if (isTransitionSet() || !dc.mOpeningApps.isEmpty() || !dc.mClosingApps.isEmpty()
|| !dc.mChangingApps.isEmpty()) {
ProtoLog.v(WM_DEBUG_APP_TRANSITIONS,
diff --git a/services/core/java/com/android/server/wm/ConfigurationContainer.java b/services/core/java/com/android/server/wm/ConfigurationContainer.java
index 9bd380a..33dd9cf 100644
--- a/services/core/java/com/android/server/wm/ConfigurationContainer.java
+++ b/services/core/java/com/android/server/wm/ConfigurationContainer.java
@@ -113,13 +113,6 @@
* @see #mFullConfiguration
*/
public void onConfigurationChanged(Configuration newParentConfig) {
- onConfigurationChanged(newParentConfig, true /*forwardToChildren*/);
- }
-
- // TODO(root-unify): Consolidate with onConfigurationChanged() method above once unification is
- // done. This is only currently need during the process of unification where we don't want
- // configuration forwarded to a child from both parents.
- public void onConfigurationChanged(Configuration newParentConfig, boolean forwardToChildren) {
mResolvedTmpConfig.setTo(mResolvedOverrideConfiguration);
resolveOverrideConfiguration(newParentConfig);
mFullConfiguration.setTo(newParentConfig);
@@ -141,11 +134,9 @@
mChangeListeners.get(i).onMergedOverrideConfigurationChanged(
mMergedOverrideConfiguration);
}
- if (forwardToChildren) {
- for (int i = getChildCount() - 1; i >= 0; --i) {
- final ConfigurationContainer child = getChildAt(i);
- child.onConfigurationChanged(mFullConfiguration);
- }
+ for (int i = getChildCount() - 1; i >= 0; --i) {
+ final ConfigurationContainer child = getChildAt(i);
+ child.onConfigurationChanged(mFullConfiguration);
}
}
diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java
index 55a41ab..8af1106 100644
--- a/services/core/java/com/android/server/wm/DisplayContent.java
+++ b/services/core/java/com/android/server/wm/DisplayContent.java
@@ -255,6 +255,7 @@
implements WindowManagerPolicy.DisplayContentInfo {
private static final String TAG = TAG_WITH_CLASS_NAME ? "DisplayContent" : TAG_WM;
private static final String TAG_STACK = TAG + POSTFIX_STACK;
+ private static final int NO_ROTATION = -1;
/** The default scaling mode that scales content automatically. */
static final int FORCE_SCALING_MODE_AUTO = 0;
@@ -511,6 +512,13 @@
*/
ActivityRecord mFocusedApp = null;
+ /**
+ * The launching activity which is using fixed rotation transformation.
+ *
+ * @see #handleTopActivityLaunchingInDifferentOrientation
+ */
+ ActivityRecord mFixedRotationLaunchingApp;
+
/** Windows added since {@link #mCurrentFocus} was set to null. Used for ANR blaming. */
final ArrayList<WindowState> mWinAddedSinceNullFocus = new ArrayList<>();
@@ -1304,6 +1312,9 @@
if (mDisplayRotation.isWaitingForRemoteRotation()) {
return;
}
+ // Clear the record because the display will sync to current rotation.
+ mFixedRotationLaunchingApp = null;
+
final boolean configUpdated = updateDisplayOverrideConfigurationLocked();
if (configUpdated) {
return;
@@ -1363,7 +1374,7 @@
* {@link #sendNewConfiguration} if the method returns {@code true}.
*/
boolean updateOrientation() {
- return mDisplayRotation.updateOrientation(getOrientation(), false /* forceUpdate */);
+ return updateOrientation(false /* forceUpdate */);
}
/**
@@ -1386,7 +1397,7 @@
}
Configuration config = null;
- if (mDisplayRotation.updateOrientation(getOrientation(), forceUpdate)) {
+ if (updateOrientation(forceUpdate)) {
// If we changed the orientation but mOrientationChangeComplete is already true,
// we used seamless rotation, and we don't need to freeze the screen.
if (freezeDisplayToken != null && !mWmService.mRoot.mOrientationChangeComplete) {
@@ -1417,6 +1428,126 @@
return config;
}
+ private boolean updateOrientation(boolean forceUpdate) {
+ final int orientation = getOrientation();
+ // The last orientation source is valid only after getOrientation.
+ final WindowContainer orientationSource = getLastOrientationSource();
+ final ActivityRecord r =
+ orientationSource != null ? orientationSource.asActivityRecord() : null;
+ // Currently there is no use case from non-activity.
+ if (r != null && handleTopActivityLaunchingInDifferentOrientation(r)) {
+ mFixedRotationLaunchingApp = r;
+ // Display orientation should be deferred until the top fixed rotation is finished.
+ return false;
+ }
+ return mDisplayRotation.updateOrientation(orientation, forceUpdate);
+ }
+
+ /** @return a valid rotation if the activity can use different orientation than the display. */
+ @Surface.Rotation
+ private int rotationForActivityInDifferentOrientation(@NonNull ActivityRecord r) {
+ if (!mWmService.mIsFixedRotationTransformEnabled) {
+ return NO_ROTATION;
+ }
+ if (r.inMultiWindowMode()
+ || r.getRequestedConfigurationOrientation() == getConfiguration().orientation) {
+ return NO_ROTATION;
+ }
+ final int currentRotation = getRotation();
+ final int rotation = mDisplayRotation.rotationForOrientation(r.getRequestedOrientation(),
+ currentRotation);
+ if (rotation == currentRotation) {
+ return NO_ROTATION;
+ }
+ return rotation;
+ }
+
+ /**
+ * We need to keep display rotation fixed for a while when the activity in different orientation
+ * is launching until the launch animation is done to avoid showing the previous activity
+ * inadvertently in a wrong orientation.
+ *
+ * @return {@code true} if the fixed rotation is started.
+ */
+ private boolean handleTopActivityLaunchingInDifferentOrientation(@NonNull ActivityRecord r) {
+ if (!mWmService.mIsFixedRotationTransformEnabled) {
+ return false;
+ }
+ if (r.isFinishingFixedRotationTransform()) {
+ return false;
+ }
+ if (r.hasFixedRotationTransform()) {
+ // It has been set and not yet finished.
+ return true;
+ }
+ if (!mAppTransition.isTransitionSet()) {
+ // Apply normal rotation animation in case of the activity set different requested
+ // orientation without activity switch.
+ return false;
+ }
+ if (!mOpeningApps.contains(r)
+ // Without screen rotation, the rotation behavior of non-top visible activities is
+ // undefined. So the fixed rotated activity needs to cover the screen.
+ && r.findMainWindow() != mDisplayPolicy.getTopFullscreenOpaqueWindow()) {
+ return false;
+ }
+ final int rotation = rotationForActivityInDifferentOrientation(r);
+ if (rotation == NO_ROTATION) {
+ return false;
+ }
+ if (!r.getParent().matchParentBounds()) {
+ // Because the fixed rotated configuration applies to activity directly, if its parent
+ // has it own policy for bounds, the activity bounds based on parent is unknown.
+ return false;
+ }
+
+ startFixedRotationTransform(r, rotation);
+ mAppTransition.registerListenerLocked(new WindowManagerInternal.AppTransitionListener() {
+ void done() {
+ r.clearFixedRotationTransform();
+ mAppTransition.unregisterListener(this);
+ }
+
+ @Override
+ public void onAppTransitionFinishedLocked(IBinder token) {
+ if (token == r.token) {
+ done();
+ }
+ }
+
+ @Override
+ public void onAppTransitionCancelledLocked(int transit) {
+ done();
+ }
+
+ @Override
+ public void onAppTransitionTimeoutLocked() {
+ done();
+ }
+ });
+ return true;
+ }
+
+ /** @return {@code true} if the display orientation will be changed. */
+ boolean continueUpdateOrientationForDiffOrienLaunchingApp(WindowToken token) {
+ if (token != mFixedRotationLaunchingApp) {
+ return false;
+ }
+ if (updateOrientation()) {
+ sendNewConfiguration();
+ return true;
+ }
+ return false;
+ }
+
+ private void startFixedRotationTransform(WindowToken token, int rotation) {
+ mTmpConfiguration.unset();
+ final DisplayInfo info = computeScreenConfiguration(mTmpConfiguration, rotation);
+ final WmDisplayCutout cutout = calculateDisplayCutoutForRotation(rotation);
+ final DisplayFrames displayFrames = new DisplayFrames(mDisplayId, info, cutout);
+ token.applyFixedRotationTransform(info, displayFrames, mTmpConfiguration);
+ }
+
/**
* Update rotation of the display.
*
@@ -1618,6 +1749,63 @@
}
/**
+ * Compute display info and configuration according to the given rotation without changing
+ * current display.
+ */
+ DisplayInfo computeScreenConfiguration(Configuration outConfig, int rotation) {
+ final boolean rotated = (rotation == ROTATION_90 || rotation == ROTATION_270);
+ final int dw = rotated ? mBaseDisplayHeight : mBaseDisplayWidth;
+ final int dh = rotated ? mBaseDisplayWidth : mBaseDisplayHeight;
+ outConfig.windowConfiguration.getBounds().set(0, 0, dw, dh);
+
+ final int uiMode = getConfiguration().uiMode;
+ final DisplayCutout displayCutout =
+ calculateDisplayCutoutForRotation(rotation).getDisplayCutout();
+ computeScreenAppConfiguration(outConfig, dw, dh, rotation, uiMode, displayCutout);
+
+ final DisplayInfo displayInfo = new DisplayInfo(mDisplayInfo);
+ displayInfo.rotation = rotation;
+ displayInfo.logicalWidth = dw;
+ displayInfo.logicalHeight = dh;
+ final Rect appBounds = outConfig.windowConfiguration.getAppBounds();
+ displayInfo.appWidth = appBounds.width();
+ displayInfo.appHeight = appBounds.height();
+ displayInfo.displayCutout = displayCutout.isEmpty() ? null : displayCutout;
+ computeSizeRangesAndScreenLayout(displayInfo, rotated, uiMode, dw, dh,
+ mDisplayMetrics.density, outConfig);
+ return displayInfo;
+ }
+
+ /** Compute configuration related to application without changing current display. */
+ private void computeScreenAppConfiguration(Configuration outConfig, int dw, int dh,
+ int rotation, int uiMode, DisplayCutout displayCutout) {
+ final int appWidth = mDisplayPolicy.getNonDecorDisplayWidth(dw, dh, rotation, uiMode,
+ displayCutout);
+ final int appHeight = mDisplayPolicy.getNonDecorDisplayHeight(dw, dh, rotation, uiMode,
+ displayCutout);
+ mDisplayPolicy.getNonDecorInsetsLw(rotation, dw, dh, displayCutout, mTmpRect);
+ final int leftInset = mTmpRect.left;
+ final int topInset = mTmpRect.top;
+ // AppBounds at the root level should mirror the app screen size.
+ outConfig.windowConfiguration.setAppBounds(leftInset /* left */, topInset /* top */,
+ leftInset + appWidth /* right */, topInset + appHeight /* bottom */);
+ outConfig.windowConfiguration.setRotation(rotation);
+ outConfig.orientation = (dw <= dh) ? ORIENTATION_PORTRAIT : ORIENTATION_LANDSCAPE;
+
+ final float density = mDisplayMetrics.density;
+ outConfig.screenWidthDp = (int) (mDisplayPolicy.getConfigDisplayWidth(dw, dh, rotation,
+ uiMode, displayCutout) / density);
+ outConfig.screenHeightDp = (int) (mDisplayPolicy.getConfigDisplayHeight(dw, dh, rotation,
+ uiMode, displayCutout) / density);
+ outConfig.compatScreenWidthDp = (int) (outConfig.screenWidthDp / mCompatibleScreenScale);
+ outConfig.compatScreenHeightDp = (int) (outConfig.screenHeightDp / mCompatibleScreenScale);
+
+ final boolean rotated = (rotation == ROTATION_90 || rotation == ROTATION_270);
+ outConfig.compatSmallestScreenWidthDp = computeCompatSmallestWidth(rotated, uiMode, dw,
+ dh, displayCutout);
+ }
+
+ /**
* Compute display configuration based on display properties and policy settings.
* Do not call if mDisplayReady == false.
*/
@@ -1625,42 +1813,19 @@
final DisplayInfo displayInfo = updateDisplayAndOrientation(config.uiMode, config);
calculateBounds(displayInfo, mTmpBounds);
config.windowConfiguration.setBounds(mTmpBounds);
+ config.windowConfiguration.setWindowingMode(getWindowingMode());
+ config.windowConfiguration.setDisplayWindowingMode(getWindowingMode());
final int dw = displayInfo.logicalWidth;
final int dh = displayInfo.logicalHeight;
- config.orientation = (dw <= dh) ? ORIENTATION_PORTRAIT : ORIENTATION_LANDSCAPE;
- config.windowConfiguration.setWindowingMode(getWindowingMode());
- config.windowConfiguration.setDisplayWindowingMode(getWindowingMode());
- config.windowConfiguration.setRotation(displayInfo.rotation);
-
- final float density = mDisplayMetrics.density;
- config.screenWidthDp =
- (int)(mDisplayPolicy.getConfigDisplayWidth(dw, dh, displayInfo.rotation,
- config.uiMode, displayInfo.displayCutout) / density);
- config.screenHeightDp =
- (int)(mDisplayPolicy.getConfigDisplayHeight(dw, dh, displayInfo.rotation,
- config.uiMode, displayInfo.displayCutout) / density);
-
- mDisplayPolicy.getNonDecorInsetsLw(displayInfo.rotation, dw, dh,
- displayInfo.displayCutout, mTmpRect);
- final int leftInset = mTmpRect.left;
- final int topInset = mTmpRect.top;
- // appBounds at the root level should mirror the app screen size.
- config.windowConfiguration.setAppBounds(leftInset /* left */, topInset /* top */,
- leftInset + displayInfo.appWidth /* right */,
- topInset + displayInfo.appHeight /* bottom */);
- final boolean rotated = (displayInfo.rotation == Surface.ROTATION_90
- || displayInfo.rotation == Surface.ROTATION_270);
+ computeScreenAppConfiguration(config, dw, dh, displayInfo.rotation, config.uiMode,
+ displayInfo.displayCutout);
config.screenLayout = (config.screenLayout & ~Configuration.SCREENLAYOUT_ROUND_MASK)
| ((displayInfo.flags & Display.FLAG_ROUND) != 0
? Configuration.SCREENLAYOUT_ROUND_YES
: Configuration.SCREENLAYOUT_ROUND_NO);
- config.compatScreenWidthDp = (int)(config.screenWidthDp / mCompatibleScreenScale);
- config.compatScreenHeightDp = (int)(config.screenHeightDp / mCompatibleScreenScale);
- config.compatSmallestScreenWidthDp = computeCompatSmallestWidth(rotated, config.uiMode, dw,
- dh, displayInfo.displayCutout);
config.densityDpi = displayInfo.logicalDensityDpi;
config.colorMode =
@@ -2107,19 +2272,19 @@
/**
* In the general case, the orientation is computed from the above app windows first. If none of
* the above app windows specify orientation, the orientation is computed from the child window
- * container, e.g. {@link AppWindowToken#getOrientation(int)}.
+ * container, e.g. {@link ActivityRecord#getOrientation(int)}.
*/
@ScreenOrientation
@Override
int getOrientation() {
- final WindowManagerPolicy policy = mWmService.mPolicy;
+ mLastOrientationSource = null;
if (mIgnoreRotationForApps) {
return SCREEN_ORIENTATION_USER;
}
if (mWmService.mDisplayFrozen) {
- if (policy.isKeyguardLocked()) {
+ if (mWmService.mPolicy.isKeyguardLocked()) {
// Use the last orientation the while the display is frozen with the keyguard
// locked. This could be the keyguard forced orientation or from a SHOW_WHEN_LOCKED
// window. We don't want to check the show when locked window directly though as
@@ -2131,7 +2296,9 @@
return getLastOrientation();
}
}
- return mRootDisplayArea.getOrientation();
+ final int rootOrientation = mRootDisplayArea.getOrientation();
+ mLastOrientationSource = mRootDisplayArea.getLastOrientationSource();
+ return rootOrientation;
}
void updateDisplayInfo() {
diff --git a/services/core/java/com/android/server/wm/DisplayPolicy.java b/services/core/java/com/android/server/wm/DisplayPolicy.java
index 3302445..a96e3a61 100644
--- a/services/core/java/com/android/server/wm/DisplayPolicy.java
+++ b/services/core/java/com/android/server/wm/DisplayPolicy.java
@@ -1430,7 +1430,7 @@
}
}
- private void simulateLayoutDecorWindow(WindowState win, DisplayFrames displayFrames, int uiMode,
+ private void simulateLayoutDecorWindow(WindowState win, DisplayFrames displayFrames,
InsetsState insetsState, WindowFrames simulatedWindowFrames, Runnable layout) {
win.setSimulatedWindowFrames(simulatedWindowFrames);
try {
@@ -1454,7 +1454,7 @@
final WindowFrames simulatedWindowFrames = new WindowFrames();
if (mNavigationBar != null) {
simulateLayoutDecorWindow(
- mNavigationBar, displayFrames, uiMode, insetsState, simulatedWindowFrames,
+ mNavigationBar, displayFrames, insetsState, simulatedWindowFrames,
() -> layoutNavigationBar(displayFrames, uiMode, mLastNavVisible,
mLastNavTranslucent, mLastNavAllowedHidden,
mLastNotificationShadeForcesShowingNavigation,
@@ -1462,7 +1462,7 @@
}
if (mStatusBar != null) {
simulateLayoutDecorWindow(
- mStatusBar, displayFrames, uiMode, insetsState, simulatedWindowFrames,
+ mStatusBar, displayFrames, insetsState, simulatedWindowFrames,
() -> layoutStatusBar(displayFrames, mLastSystemUiFlags,
false /* isRealLayout */));
}
@@ -1536,7 +1536,7 @@
if (updateSysUiVisibility) {
updateSystemUiVisibilityLw();
}
- layoutScreenDecorWindows(displayFrames, null /* transientFrames */);
+ layoutScreenDecorWindows(displayFrames, null /* simulatedFrames */);
postAdjustDisplayFrames(displayFrames);
mLastNavVisible = navVisible;
mLastNavTranslucent = navTranslucent;
@@ -1939,6 +1939,7 @@
final int requestedSysUiFl = PolicyControl.getSystemUiVisibility(null, attrs);
final int sysUiFl = requestedSysUiFl | getImpliedSysUiFlagsForLayout(attrs);
+ displayFrames = win.getDisplayFrames(displayFrames);
final WindowFrames windowFrames = win.getWindowFrames();
sTmpLastParentFrame.set(windowFrames.mParentFrame);
diff --git a/services/core/java/com/android/server/wm/DisplayRotation.java b/services/core/java/com/android/server/wm/DisplayRotation.java
index 539853b..64c5faa 100644
--- a/services/core/java/com/android/server/wm/DisplayRotation.java
+++ b/services/core/java/com/android/server/wm/DisplayRotation.java
@@ -484,9 +484,11 @@
prepareNormalRotationAnimation();
}
- // The display is frozen now, give a remote handler (system ui) some time to reposition
- // things.
- startRemoteRotation(oldRotation, mRotation);
+ // TODO(b/147469351): Remove the restriction.
+ if (mDisplayContent.mFixedRotationLaunchingApp == null) {
+ // Give a remote handler (system ui) some time to reposition things.
+ startRemoteRotation(oldRotation, mRotation);
+ }
return true;
}
@@ -557,7 +559,15 @@
@VisibleForTesting
boolean shouldRotateSeamlessly(int oldRotation, int newRotation, boolean forceUpdate) {
final WindowState w = mDisplayPolicy.getTopFullscreenOpaqueWindow();
- if (w == null || w != mDisplayContent.mCurrentFocus) {
+ if (w == null) {
+ return false;
+ }
+ // Display doesn't need to be frozen because application has been started in correct
+ // rotation already, so the rest of the windows can use seamless rotation.
+ if (w.mToken.hasFixedRotationTransform()) {
+ return true;
+ }
+ if (w != mDisplayContent.mCurrentFocus) {
return false;
}
// We only enable seamless rotation if the top window has requested it and is in the
diff --git a/services/core/java/com/android/server/wm/SeamlessRotator.java b/services/core/java/com/android/server/wm/SeamlessRotator.java
index c621c48..024da88 100644
--- a/services/core/java/com/android/server/wm/SeamlessRotator.java
+++ b/services/core/java/com/android/server/wm/SeamlessRotator.java
@@ -20,6 +20,7 @@
import static android.view.Surface.ROTATION_90;
import android.graphics.Matrix;
+import android.graphics.Rect;
import android.os.IBinder;
import android.view.DisplayInfo;
import android.view.Surface.Rotation;
@@ -27,6 +28,7 @@
import android.view.SurfaceControl.Transaction;
import com.android.server.wm.utils.CoordinateTransforms;
+import com.android.server.wm.utils.InsetUtils;
import java.io.PrintWriter;
import java.io.StringWriter;
@@ -45,34 +47,51 @@
private final float[] mFloat9 = new float[9];
private final int mOldRotation;
private final int mNewRotation;
+ private final int mRotationDelta;
+ private final int mW;
+ private final int mH;
public SeamlessRotator(@Rotation int oldRotation, @Rotation int newRotation, DisplayInfo info) {
mOldRotation = oldRotation;
mNewRotation = newRotation;
+ mRotationDelta = DisplayContent.deltaRotation(oldRotation, newRotation);
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;
+ mH = flipped ? info.logicalWidth : info.logicalHeight;
+ mW = flipped ? info.logicalHeight : info.logicalWidth;
final Matrix tmp = new Matrix();
- CoordinateTransforms.transformLogicalToPhysicalCoordinates(oldRotation, w, h, mTransform);
- CoordinateTransforms.transformPhysicalToLogicalCoordinates(newRotation, w, h, tmp);
+ CoordinateTransforms.transformLogicalToPhysicalCoordinates(oldRotation, mW, mH, mTransform);
+ CoordinateTransforms.transformPhysicalToLogicalCoordinates(newRotation, mW, mH, tmp);
mTransform.postConcat(tmp);
}
/**
- * Applies a transform to the {@link WindowState} surface that undoes the effect of the global
- * display rotation.
+ * Applies a transform to the {@link WindowContainer} surface that undoes the effect of the
+ * global display rotation.
*/
- public void unrotate(Transaction transaction, WindowState win) {
+ public void unrotate(Transaction transaction, WindowContainer win) {
transaction.setMatrix(win.getSurfaceControl(), mTransform, mFloat9);
-
// WindowState sets the position of the window so transform the position and update it.
final float[] winSurfacePos = {win.mLastSurfacePosition.x, win.mLastSurfacePosition.y};
mTransform.mapPoints(winSurfacePos);
transaction.setPosition(win.getSurfaceControl(), winSurfacePos[0], winSurfacePos[1]);
}
+ /** Rotates the frame from {@link #mNewRotation} to {@link #mOldRotation}. */
+ void unrotateFrame(Rect inOut) {
+ if (mRotationDelta == ROTATION_90) {
+ inOut.set(inOut.top, mH - inOut.right, inOut.bottom, mH - inOut.left);
+ } else if (mRotationDelta == ROTATION_270) {
+ inOut.set(mW - inOut.bottom, inOut.left, mW - inOut.top, inOut.right);
+ }
+ }
+
+ /** Rotates the insets from {@link #mNewRotation} to {@link #mOldRotation}. */
+ void unrotateInsets(Rect inOut) {
+ InsetUtils.rotateInsets(inOut, mRotationDelta);
+ }
+
/**
* Returns the rotation of the display before it started rotating.
*
@@ -95,10 +114,8 @@
* it.
*/
public void finish(WindowState win, boolean timeout) {
- mTransform.reset();
final Transaction t = win.getPendingTransaction();
- t.setMatrix(win.mSurfaceControl, mTransform, mFloat9);
- t.setPosition(win.mSurfaceControl, win.mLastSurfacePosition.x, win.mLastSurfacePosition.y);
+ finish(t, win);
if (win.mWinAnimator.mSurfaceController != null && !timeout) {
t.deferTransactionUntil(win.mSurfaceControl,
win.getDeferTransactionBarrier(), win.getFrameNumber());
@@ -107,6 +124,13 @@
}
}
+ /** Removes the transform and restore to the original last position. */
+ void finish(Transaction t, WindowContainer win) {
+ mTransform.reset();
+ t.setMatrix(win.mSurfaceControl, mTransform, mFloat9);
+ t.setPosition(win.mSurfaceControl, win.mLastSurfacePosition.x, win.mLastSurfacePosition.y);
+ }
+
public void dump(PrintWriter pw) {
pw.print("{old="); pw.print(mOldRotation); pw.print(", new="); pw.print(mNewRotation);
pw.print("}");
diff --git a/services/core/java/com/android/server/wm/WindowContainer.java b/services/core/java/com/android/server/wm/WindowContainer.java
index 294c36a..da996dc 100644
--- a/services/core/java/com/android/server/wm/WindowContainer.java
+++ b/services/core/java/com/android/server/wm/WindowContainer.java
@@ -141,6 +141,12 @@
@ActivityInfo.ScreenOrientation
protected int mOrientation = SCREEN_ORIENTATION_UNSPECIFIED;
+ /**
+ * The window container which decides its orientation since the last time
+ * {@link #getOrientation(int) was called.
+ */
+ protected WindowContainer mLastOrientationSource;
+
private final Pools.SynchronizedPool<ForAllWindowsConsumerWrapper> mConsumerWrapperPool =
new Pools.SynchronizedPool<>(3);
@@ -1061,6 +1067,7 @@
* @return The orientation as specified by this branch or the window hierarchy.
*/
int getOrientation(int candidate) {
+ mLastOrientationSource = null;
if (!fillsParent()) {
// Ignore containers that don't completely fill their parents.
return SCREEN_ORIENTATION_UNSET;
@@ -1072,6 +1079,7 @@
// if none of the children have a better candidate for the orientation.
if (mOrientation != SCREEN_ORIENTATION_UNSET
&& mOrientation != SCREEN_ORIENTATION_UNSPECIFIED) {
+ mLastOrientationSource = this;
return mOrientation;
}
@@ -1087,6 +1095,7 @@
// can find one. Else return SCREEN_ORIENTATION_BEHIND so the caller can choose to
// look behind this container.
candidate = orientation;
+ mLastOrientationSource = wc;
continue;
}
@@ -1100,6 +1109,7 @@
ProtoLog.v(WM_DEBUG_ORIENTATION, "%s is requesting orientation %d (%s)",
wc.toString(), orientation,
ActivityInfo.screenOrientationToString(orientation));
+ mLastOrientationSource = wc;
return orientation;
}
}
@@ -1108,6 +1118,22 @@
}
/**
+ * @return The deepest source which decides the orientation of this window container since the
+ * last time {@link #getOrientation(int) was called.
+ */
+ @Nullable
+ WindowContainer getLastOrientationSource() {
+ final WindowContainer source = mLastOrientationSource;
+ if (source != null && source != this) {
+ final WindowContainer nextSource = source.getLastOrientationSource();
+ if (nextSource != null) {
+ return nextSource;
+ }
+ }
+ return source;
+ }
+
+ /**
* 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/WindowManagerInternal.java b/services/core/java/com/android/server/wm/WindowManagerInternal.java
index 59eee9c..240f566 100644
--- a/services/core/java/com/android/server/wm/WindowManagerInternal.java
+++ b/services/core/java/com/android/server/wm/WindowManagerInternal.java
@@ -120,6 +120,11 @@
public void onAppTransitionCancelledLocked(int transit) {}
/**
+ * Called when an app transition is timed out.
+ */
+ public void onAppTransitionTimeoutLocked() {}
+
+ /**
* Called when an app transition gets started
*
* @param transit transition type indicating what kind of transition gets run, must be one
diff --git a/services/core/java/com/android/server/wm/WindowManagerService.java b/services/core/java/com/android/server/wm/WindowManagerService.java
index bb3b66b..f3c45ff 100644
--- a/services/core/java/com/android/server/wm/WindowManagerService.java
+++ b/services/core/java/com/android/server/wm/WindowManagerService.java
@@ -411,6 +411,10 @@
private static final int ANIMATION_COMPLETED_TIMEOUT_MS = 5000;
+ // TODO(b/143053092): Remove the settings if it becomes stable.
+ private static final String FIXED_ROTATION_TRANSFORM_SETTING_NAME = "fixed_rotation_transform";
+ boolean mIsFixedRotationTransformEnabled;
+
final WindowManagerConstants mConstants;
final WindowTracing mWindowTracing;
@@ -737,6 +741,8 @@
DEVELOPMENT_ENABLE_SIZECOMPAT_FREEFORM);
private final Uri mRenderShadowsInCompositorUri = Settings.Global.getUriFor(
DEVELOPMENT_RENDER_SHADOWS_IN_COMPOSITOR);
+ private final Uri mFixedRotationTransformUri = Settings.Global.getUriFor(
+ FIXED_ROTATION_TRANSFORM_SETTING_NAME);
public SettingsObserver() {
super(new Handler());
@@ -761,6 +767,8 @@
UserHandle.USER_ALL);
resolver.registerContentObserver(mRenderShadowsInCompositorUri, false, this,
UserHandle.USER_ALL);
+ resolver.registerContentObserver(mFixedRotationTransformUri, false, this,
+ UserHandle.USER_ALL);
}
@Override
@@ -804,6 +812,11 @@
return;
}
+ if (mFixedRotationTransformUri.equals(uri)) {
+ updateFixedRotationTransform();
+ return;
+ }
+
@UpdateAnimationScaleMode
final int mode;
if (mWindowAnimationScaleUri.equals(uri)) {
@@ -820,6 +833,12 @@
mH.sendMessage(m);
}
+ void loadSettings() {
+ updateSystemUiSettings();
+ updatePointerLocation();
+ updateFixedRotationTransform();
+ }
+
void updateSystemUiSettings() {
boolean changed;
synchronized (mGlobalLock) {
@@ -883,6 +902,11 @@
mAtmService.mSizeCompatFreeform = sizeCompatFreeform;
}
+
+ void updateFixedRotationTransform() {
+ mIsFixedRotationTransformEnabled = Settings.Global.getInt(mContext.getContentResolver(),
+ FIXED_ROTATION_TRANSFORM_SETTING_NAME, 0) != 0;
+ }
}
private void setShadowRenderer() {
@@ -1643,7 +1667,7 @@
outFrame, outContentInsets, outStableInsets, outDisplayCutout)) {
res |= WindowManagerGlobal.ADD_FLAG_ALWAYS_CONSUME_SYSTEM_BARS;
}
- outInsetsState.set(displayContent.getInsetsPolicy().getInsetsForDispatch(win),
+ outInsetsState.set(win.getInsetsState(),
win.mClient instanceof IWindow.Stub /* copySource */);
if (mInTouchMode) {
@@ -2381,7 +2405,7 @@
outStableInsets);
outCutout.set(win.getWmDisplayCutout().getDisplayCutout());
outBackdropFrame.set(win.getBackdropFrame(win.getFrameLw()));
- outInsetsState.set(displayContent.getInsetsPolicy().getInsetsForDispatch(win),
+ outInsetsState.set(win.getInsetsState(),
win.mClient instanceof IWindow.Stub /* copySource */);
if (DEBUG) {
Slog.v(TAG_WM, "Relayout given client " + client.asBinder()
@@ -4566,8 +4590,7 @@
mTaskSnapshotController.systemReady();
mHasWideColorGamutSupport = queryWideColorGamutSupport();
mHasHdrSupport = queryHdrSupport();
- UiThread.getHandler().post(mSettingsObserver::updateSystemUiSettings);
- UiThread.getHandler().post(mSettingsObserver::updatePointerLocation);
+ UiThread.getHandler().post(mSettingsObserver::loadSettings);
IVrManager vrManager = IVrManager.Stub.asInterface(
ServiceManager.getService(Context.VR_SERVICE));
if (vrManager != null) {
diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java
index ed4e684..ff49b6b 100644
--- a/services/core/java/com/android/server/wm/WindowState.java
+++ b/services/core/java/com/android/server/wm/WindowState.java
@@ -696,6 +696,11 @@
return;
}
+ if (mToken.hasFixedRotationTransform()) {
+ // The transform of its surface is handled by fixed rotation.
+ return;
+ }
+
if (mPendingSeamlessRotate != null) {
oldRotation = mPendingSeamlessRotate.getOldRotation();
}
@@ -1000,6 +1005,7 @@
final boolean isFullscreenAndFillsDisplay = !inMultiWindowMode() && matchesDisplayBounds();
final boolean windowsAreFloating = task != null && task.isFloating();
final DisplayContent dc = getDisplayContent();
+ final DisplayInfo displayInfo = getDisplayInfo();
final WindowFrames windowFrames = getLayoutingWindowFrames();
mInsetFrame.set(getBounds());
@@ -1086,7 +1092,7 @@
layoutXDiff = mInsetFrame.left - windowFrames.mContainingFrame.left;
layoutYDiff = mInsetFrame.top - windowFrames.mContainingFrame.top;
layoutContainingFrame = mInsetFrame;
- mTmpRect.set(0, 0, dc.getDisplayInfo().logicalWidth, dc.getDisplayInfo().logicalHeight);
+ mTmpRect.set(0, 0, displayInfo.logicalWidth, displayInfo.logicalHeight);
subtractInsets(windowFrames.mDisplayFrame, layoutContainingFrame, layoutDisplayFrame,
mTmpRect);
if (!layoutInParentFrame()) {
@@ -1161,9 +1167,8 @@
windowFrames.mDisplayFrame);
windowFrames.calculateDockedDividerInsets(c.getDisplayCutout().getSafeInsets());
} else {
- getDisplayContent().getBounds(mTmpRect);
- windowFrames.calculateInsets(
- windowsAreFloating, isFullscreenAndFillsDisplay, mTmpRect);
+ windowFrames.calculateInsets(windowsAreFloating, isFullscreenAndFillsDisplay,
+ getDisplayFrames(dc.mDisplayFrames).mUnrestricted);
}
windowFrames.setDisplayCutout(
@@ -1186,12 +1191,8 @@
if (mIsWallpaper && (fw != windowFrames.mFrame.width()
|| fh != windowFrames.mFrame.height())) {
- final DisplayContent displayContent = getDisplayContent();
- if (displayContent != null) {
- final DisplayInfo displayInfo = displayContent.getDisplayInfo();
- getDisplayContent().mWallpaperController.updateWallpaperOffset(this,
- displayInfo.logicalWidth, displayInfo.logicalHeight, false);
- }
+ dc.mWallpaperController.updateWallpaperOffset(this,
+ displayInfo.logicalWidth, displayInfo.logicalHeight, false /* sync */);
}
// Calculate relative frame
@@ -1467,9 +1468,28 @@
}
}
+ DisplayFrames getDisplayFrames(DisplayFrames originalFrames) {
+ final DisplayFrames diplayFrames = mToken.getFixedRotationTransformDisplayFrames();
+ if (diplayFrames != null) {
+ return diplayFrames;
+ }
+ return originalFrames;
+ }
+
DisplayInfo getDisplayInfo() {
- final DisplayContent displayContent = getDisplayContent();
- return displayContent != null ? displayContent.getDisplayInfo() : null;
+ final DisplayInfo displayInfo = mToken.getFixedRotationTransformDisplayInfo();
+ if (displayInfo != null) {
+ return displayInfo;
+ }
+ return getDisplayContent().getDisplayInfo();
+ }
+
+ InsetsState getInsetsState() {
+ final InsetsState insetsState = mToken.getFixedRotationTransformInsetsState();
+ if (insetsState != null) {
+ return insetsState;
+ }
+ return getDisplayContent().getInsetsPolicy().getInsetsForDispatch(this);
}
@Override
@@ -1990,6 +2010,11 @@
}
private boolean matchesDisplayBounds() {
+ final Rect displayBounds = mToken.getFixedRotationTransformDisplayBounds();
+ if (displayBounds != null) {
+ // If the rotated display bounds are available, the window bounds are also rotated.
+ return displayBounds.equals(getBounds());
+ }
return getDisplayContent().getBounds().equals(getBounds());
}
@@ -4774,7 +4799,7 @@
if (!displayContent.isDefaultDisplay && !displayContent.supportsSystemDecorations()) {
// On a different display there is no system decor. Crop the window
// by the screen boundaries.
- final DisplayInfo displayInfo = displayContent.getDisplayInfo();
+ final DisplayInfo displayInfo = getDisplayInfo();
policyCrop.set(0, 0, mWindowFrames.mCompatFrame.width(),
mWindowFrames.mCompatFrame.height());
policyCrop.intersect(-mWindowFrames.mCompatFrame.left, -mWindowFrames.mCompatFrame.top,
@@ -5000,7 +5025,7 @@
return;
}
- final DisplayInfo displayInfo = getDisplayContent().getDisplayInfo();
+ final DisplayInfo displayInfo = getDisplayInfo();
anim.initialize(mWindowFrames.mFrame.width(), mWindowFrames.mFrame.height(),
displayInfo.appWidth, displayInfo.appHeight);
anim.restrictDuration(MAX_ANIMATION_DURATION);
@@ -5538,7 +5563,7 @@
}
/**
- * If the transient frame is set, the computed result won't be used in real layout. So this
+ * If the simulated frame is set, the computed result won't be used in real layout. So this
* frames must be cleared when the simulated computation is done.
*/
void setSimulatedWindowFrames(WindowFrames windowFrames) {
diff --git a/services/core/java/com/android/server/wm/WindowToken.java b/services/core/java/com/android/server/wm/WindowToken.java
index 43cd66d..1180566 100644
--- a/services/core/java/com/android/server/wm/WindowToken.java
+++ b/services/core/java/com/android/server/wm/WindowToken.java
@@ -36,15 +36,20 @@
import static com.android.server.wm.WindowTokenProto.WINDOW_CONTAINER;
import android.annotation.CallSuper;
+import android.content.res.Configuration;
+import android.graphics.Rect;
import android.os.Debug;
import android.os.IBinder;
import android.util.proto.ProtoOutputStream;
+import android.view.DisplayInfo;
+import android.view.InsetsState;
import android.view.SurfaceControl;
import com.android.server.policy.WindowManagerPolicy;
import com.android.server.protolog.common.ProtoLog;
import java.io.PrintWriter;
+import java.util.ArrayList;
import java.util.Comparator;
/**
@@ -84,6 +89,57 @@
/** The owner has {@link android.Manifest.permission#MANAGE_APP_TOKENS} */
final boolean mOwnerCanManageAppTokens;
+ private FixedRotationTransformState mFixedRotationTransformState;
+
+ /**
+ * Used to fix the transform of the token to be rotated to a rotation different than it's
+ * display. The window frames and surfaces corresponding to this token will be layouted and
+ * rotated by the given rotated display info, frames and insets.
+ */
+ private static class FixedRotationTransformState {
+ final DisplayInfo mDisplayInfo;
+ final DisplayFrames mDisplayFrames;
+ final InsetsState mInsetsState;
+ final Configuration mRotatedOverrideConfiguration;
+ final SeamlessRotator mRotator;
+ final ArrayList<WindowContainer<?>> mRotatedContainers = new ArrayList<>();
+ boolean mIsTransforming = true;
+
+ FixedRotationTransformState(DisplayInfo rotatedDisplayInfo,
+ DisplayFrames rotatedDisplayFrames, InsetsState rotatedInsetsState,
+ Configuration rotatedConfig, int currentRotation) {
+ mDisplayInfo = rotatedDisplayInfo;
+ mDisplayFrames = rotatedDisplayFrames;
+ mInsetsState = rotatedInsetsState;
+ mRotatedOverrideConfiguration = rotatedConfig;
+ // This will use unrotate as rotate, so the new and old rotation are inverted.
+ mRotator = new SeamlessRotator(rotatedDisplayInfo.rotation, currentRotation,
+ rotatedDisplayInfo);
+ }
+
+ /**
+ * Transforms the window container from the next rotation to the current rotation for
+ * showing the window in a display with different rotation.
+ */
+ void transform(WindowContainer<?> container) {
+ mRotator.unrotate(container.getPendingTransaction(), container);
+ if (!mRotatedContainers.contains(container)) {
+ mRotatedContainers.add(container);
+ }
+ }
+
+ /**
+ * Resets the transformation of the window containers which have been rotated. This should
+ * be called when the window has the same rotation as display.
+ */
+ void resetTransform() {
+ for (int i = mRotatedContainers.size() - 1; i >= 0; i--) {
+ final WindowContainer<?> c = mRotatedContainers.get(i);
+ mRotator.finish(c.getPendingTransaction(), c);
+ }
+ }
+ }
+
/**
* Compares two child window of this token and returns -1 if the first is lesser than the
* second in terms of z-order and 1 otherwise.
@@ -274,6 +330,107 @@
return builder;
}
+ boolean hasFixedRotationTransform() {
+ return mFixedRotationTransformState != null;
+ }
+
+ boolean isFinishingFixedRotationTransform() {
+ return mFixedRotationTransformState != null
+ && !mFixedRotationTransformState.mIsTransforming;
+ }
+
+ boolean isFixedRotationTransforming() {
+ return mFixedRotationTransformState != null
+ && mFixedRotationTransformState.mIsTransforming;
+ }
+
+ DisplayInfo getFixedRotationTransformDisplayInfo() {
+ return isFixedRotationTransforming() ? mFixedRotationTransformState.mDisplayInfo : null;
+ }
+
+ DisplayFrames getFixedRotationTransformDisplayFrames() {
+ return isFixedRotationTransforming() ? mFixedRotationTransformState.mDisplayFrames : null;
+ }
+
+ Rect getFixedRotationTransformDisplayBounds() {
+ return isFixedRotationTransforming()
+ ? mFixedRotationTransformState.mRotatedOverrideConfiguration.windowConfiguration
+ .getBounds()
+ : null;
+ }
+
+ InsetsState getFixedRotationTransformInsetsState() {
+ return isFixedRotationTransforming() ? mFixedRotationTransformState.mInsetsState : null;
+ }
+
+ /** Applies the rotated layout environment to this token in the simulated rotated display. */
+ void applyFixedRotationTransform(DisplayInfo info, DisplayFrames displayFrames,
+ Configuration config) {
+ if (mFixedRotationTransformState != null) {
+ return;
+ }
+ final InsetsState insetsState = new InsetsState();
+ mDisplayContent.getDisplayPolicy().simulateLayoutDisplay(displayFrames, insetsState,
+ mDisplayContent.getConfiguration().uiMode);
+ mFixedRotationTransformState = new FixedRotationTransformState(info, displayFrames,
+ insetsState, new Configuration(config), mDisplayContent.getRotation());
+ onConfigurationChanged(getParent().getConfiguration());
+ }
+
+ /** Clears the transformation and continue updating the orientation change of display. */
+ void clearFixedRotationTransform() {
+ if (mFixedRotationTransformState == null) {
+ return;
+ }
+ mFixedRotationTransformState.resetTransform();
+ // Clear the flag so if the display will be updated to the same orientation, the transform
+ // won't take effect. The state is cleared at the end, because it is used to indicate that
+ // other windows can use seamless rotation when applying rotation to display.
+ mFixedRotationTransformState.mIsTransforming = false;
+ final boolean changed =
+ mDisplayContent.continueUpdateOrientationForDiffOrienLaunchingApp(this);
+ // If it is not the launching app or the display is not rotated, make sure the merged
+ // override configuration is restored from parent.
+ if (!changed) {
+ onMergedOverrideConfigurationChanged();
+ }
+ mFixedRotationTransformState = null;
+ }
+
+ @Override
+ void resolveOverrideConfiguration(Configuration newParentConfig) {
+ super.resolveOverrideConfiguration(newParentConfig);
+ if (isFixedRotationTransforming()) {
+ // Apply the rotated configuration to current resolved configuration, so the merged
+ // override configuration can update to the same state.
+ getResolvedOverrideConfiguration().updateFrom(
+ mFixedRotationTransformState.mRotatedOverrideConfiguration);
+ }
+ }
+
+ @Override
+ void updateSurfacePosition() {
+ super.updateSurfacePosition();
+ if (isFixedRotationTransforming()) {
+ // The window is layouted in a simulated rotated display but the real display hasn't
+ // rotated, so here transforms its surface to fit in the real display.
+ mFixedRotationTransformState.transform(this);
+ }
+ }
+
+ /**
+ * Converts the rotated animation frames and insets back to display space for local animation.
+ * It should only be called when {@link #hasFixedRotationTransform} is true.
+ */
+ void unrotateAnimationFrames(Rect outFrame, Rect outInsets, Rect outStableInsets,
+ Rect outSurfaceInsets) {
+ final SeamlessRotator rotator = mFixedRotationTransformState.mRotator;
+ rotator.unrotateFrame(outFrame);
+ rotator.unrotateInsets(outInsets);
+ rotator.unrotateInsets(outStableInsets);
+ rotator.unrotateInsets(outSurfaceInsets);
+ }
+
@CallSuper
@Override
public void dumpDebug(ProtoOutputStream proto, long fieldId,
diff --git a/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java b/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java
index 3b6816a..1a8f2a6 100644
--- a/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java
@@ -995,6 +995,35 @@
}
@Test
+ public void testApplyTopFixedRotationTransform() {
+ mWm.mIsFixedRotationTransformEnabled = true;
+ final Configuration config90 = new Configuration();
+ mDisplayContent.getDisplayRotation().setRotation(ROTATION_90);
+ mDisplayContent.computeScreenConfiguration(config90);
+ mDisplayContent.onRequestedOverrideConfigurationChanged(config90);
+
+ final Configuration config = new Configuration();
+ mDisplayContent.getDisplayRotation().setRotation(Surface.ROTATION_0);
+ mDisplayContent.computeScreenConfiguration(config);
+ mDisplayContent.onRequestedOverrideConfigurationChanged(config);
+
+ final ActivityRecord app = mAppWindow.mActivityRecord;
+ mDisplayContent.prepareAppTransition(WindowManager.TRANSIT_ACTIVITY_OPEN,
+ false /* alwaysKeepCurrent */);
+ mDisplayContent.mOpeningApps.add(app);
+ app.setRequestedOrientation(SCREEN_ORIENTATION_LANDSCAPE);
+
+ assertTrue(app.isFixedRotationTransforming());
+ assertEquals(config.orientation, mDisplayContent.getConfiguration().orientation);
+ assertEquals(config90.orientation, app.getConfiguration().orientation);
+
+ mDisplayContent.mAppTransition.notifyAppTransitionFinishedLocked(app.token);
+
+ assertFalse(app.hasFixedRotationTransform());
+ assertEquals(config90.orientation, mDisplayContent.getConfiguration().orientation);
+ }
+
+ @Test
public void testRemoteRotation() {
DisplayContent dc = createNewDisplay();
diff --git a/services/tests/wmtests/src/com/android/server/wm/DisplayRotationTests.java b/services/tests/wmtests/src/com/android/server/wm/DisplayRotationTests.java
index da807d8..cf7411e 100644
--- a/services/tests/wmtests/src/com/android/server/wm/DisplayRotationTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/DisplayRotationTests.java
@@ -638,7 +638,7 @@
mBuilder.build();
final WindowState win = mock(WindowState.class);
- win.mActivityRecord = mock(ActivityRecord.class);
+ win.mToken = win.mActivityRecord = mock(ActivityRecord.class);
final WindowManager.LayoutParams attrs = new WindowManager.LayoutParams();
attrs.rotationAnimation = WindowManager.LayoutParams.ROTATION_ANIMATION_SEAMLESS;