Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

System Bars animation for fixed rotation transform

Browse Source 
Fade out system bars when the fixed transform is starting and fade them
in once its finished.

Bug: 150676212
Test: Manual: open and close a landscape application, and open and
      immediately cancel opening animation.
Test:  atest WmTests:com.android.server.wm.DisplayContentTests#
       testApplyTopFixedRotationTransform

Change-Id: I24d33b947193e8b87f13b497c0b32e3794f2b070
This commit is contained in:
Vadim Caen
2020-04-23 18:26:50 +02:00
parent 17b76b76bf
commit dca5b93bf9
6 changed files with 236 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
services/core/java/com/android/server/wm/DisplayContent.java
View File

@@ -499,6 +499,8 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
*/
ActivityRecord mFixedRotationLaunchingApp;
FixedRotationAnimationController mFixedRotationAnimationController;
final FixedRotationTransitionListener mFixedRotationTransitionListener =
new FixedRotationTransitionListener();
@@ -1528,6 +1530,11 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
}
private void startFixedRotationTransform(WindowToken token, int rotation) {
if (mFixedRotationAnimationController == null) {
mFixedRotationAnimationController = new FixedRotationAnimationController(
this);
}
mFixedRotationAnimationController.hide(rotation);
mTmpConfiguration.unset();
final DisplayInfo info = computeScreenConfiguration(mTmpConfiguration, rotation);
final WmDisplayCutout cutout = calculateDisplayCutoutForRotation(rotation);
@@ -1549,6 +1556,13 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
}
}
void finishFixedRotationAnimation() {
if (mFixedRotationAnimationController != null
&& mFixedRotationAnimationController.show()) {
mFixedRotationAnimationController = null;
}
}
/**
* Update rotation of the display.
*

2
services/core/java/com/android/server/wm/DisplayRotation.java
View File

@@ -560,6 +560,7 @@ public class DisplayRotation {
}, true /* traverseTopToBottom */);
mSeamlessRotationCount = 0;
mRotatingSeamlessly = false;
mDisplayContent.finishFixedRotationAnimation();
}
private void prepareSeamlessRotation() {
@@ -646,6 +647,7 @@ public class DisplayRotation {
"Performing post-rotate rotation after seamless rotation");
// Finish seamless rotation.
mRotatingSeamlessly = false;
mDisplayContent.finishFixedRotationAnimation();
updateRotationAndSendNewConfigIfChanged();
}

197
services/core/java/com/android/server/wm/FixedRotationAnimationController.java Normal file
View File

@@ -0,0 +1,197 @@
/*
* Copyright (C) 2020 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 com.android.server.wm.AnimationSpecProto.WINDOW;
import static com.android.server.wm.SurfaceAnimator.ANIMATION_TYPE_FIXED_TRANSFORM;
import static com.android.server.wm.WindowAnimationSpecProto.ANIMATION;
import android.content.res.Configuration;
import android.util.proto.ProtoOutputStream;
import android.view.SurfaceControl;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.view.animation.Transformation;
import com.android.internal.R;
import java.io.PrintWriter;
import java.util.ArrayList;
/**
* Controller to fade out and in system ui when applying a fixed rotation transform to a window
* token.
*
* The system bars will be fade out when the fixed rotation transform starts and will be fade in
* once all surfaces have been rotated.
*/
public class FixedRotationAnimationController {
private final WindowManagerService mWmService;
private boolean mShowRequested = true;
private int mTargetRotation = Configuration.ORIENTATION_UNDEFINED;
private final ArrayList<WindowState> mAnimatedWindowStates = new ArrayList<>(2);
private final Runnable[] mDeferredFinishCallbacks;
public FixedRotationAnimationController(DisplayContent displayContent) {
mWmService = displayContent.mWmService;
addAnimatedWindow(displayContent.getDisplayPolicy().getStatusBar());
addAnimatedWindow(displayContent.getDisplayPolicy().getNavigationBar());
mDeferredFinishCallbacks = new Runnable[mAnimatedWindowStates.size()];
}
private void addAnimatedWindow(WindowState windowState) {
if (windowState != null) {
mAnimatedWindowStates.add(windowState);
}
}
/**
* Show the previously hidden {@link WindowToken} if their surfaces have already been rotated.
*
* @return True if the show animation has been started, in which case the caller no longer needs
* this {@link FixedRotationAnimationController}.
*/
boolean show() {
if (!mShowRequested && readyToShow()) {
mShowRequested = true;
for (int i = mAnimatedWindowStates.size() - 1; i >= 0; i--) {
WindowState windowState = mAnimatedWindowStates.get(i);
fadeWindowToken(true, windowState.getParent(), i);
}
return true;
}
return false;
}
void hide(int targetRotation) {
mTargetRotation = targetRotation;
if (mShowRequested) {
mShowRequested = false;
for (int i = mAnimatedWindowStates.size() - 1; i >= 0; i--) {
WindowState windowState = mAnimatedWindowStates.get(i);
fadeWindowToken(false /* show */, windowState.getParent(), i);
}
}
}
void cancel() {
for (int i = mAnimatedWindowStates.size() - 1; i >= 0; i--) {
WindowState windowState = mAnimatedWindowStates.get(i);
mShowRequested = true;
fadeWindowToken(true /* show */, windowState.getParent(), i);
}
}
private void fadeWindowToken(boolean show, WindowContainer<WindowToken> windowToken,
int index) {
Animation animation = AnimationUtils.loadAnimation(mWmService.mContext,
show ? R.anim.fade_in : R.anim.fade_out);
LocalAnimationAdapter.AnimationSpec windowAnimationSpec = createAnimationSpec(animation);
FixedRotationAnimationAdapter animationAdapter = new FixedRotationAnimationAdapter(
windowAnimationSpec, windowToken.getSurfaceAnimationRunner(), show, index);
// We deferred the end of the animation when hiding the token, so we need to end it now that
// it's shown again.
SurfaceAnimator.OnAnimationFinishedCallback finishedCallback = show ? (t, r) -> {
if (mDeferredFinishCallbacks[index] != null) {
mDeferredFinishCallbacks[index].run();
mDeferredFinishCallbacks[index] = null;
}
} : null;
windowToken.startAnimation(windowToken.getPendingTransaction(), animationAdapter,
mShowRequested, ANIMATION_TYPE_FIXED_TRANSFORM, finishedCallback);
}
/**
* Check if all the mAnimatedWindowState's surfaces have been rotated to the
* mTargetRotation.
*/
private boolean readyToShow() {
for (int i = mAnimatedWindowStates.size() - 1; i >= 0; i--) {
WindowState windowState = mAnimatedWindowStates.get(i);
if (windowState.getConfiguration().windowConfiguration.getRotation()
!= mTargetRotation || windowState.mPendingSeamlessRotate != null) {
return false;
}
}
return true;
}
private LocalAnimationAdapter.AnimationSpec createAnimationSpec(Animation animation) {
return new LocalAnimationAdapter.AnimationSpec() {
Transformation mTransformation = new Transformation();
@Override
public boolean getShowWallpaper() {
return true;
}
@Override
public long getDuration() {
return animation.getDuration();
}
@Override
public void apply(SurfaceControl.Transaction t, SurfaceControl leash,
long currentPlayTime) {
mTransformation.clear();
animation.getTransformation(currentPlayTime, mTransformation);
t.setAlpha(leash, mTransformation.getAlpha());
}
@Override
public void dump(PrintWriter pw, String prefix) {
pw.print(prefix);
pw.println(animation);
}
@Override
public void dumpDebugInner(ProtoOutputStream proto) {
final long token = proto.start(WINDOW);
proto.write(ANIMATION, animation.toString());
proto.end(token);
}
};
}
private class FixedRotationAnimationAdapter extends LocalAnimationAdapter {
private final boolean mShow;
private final int mIndex;
FixedRotationAnimationAdapter(AnimationSpec windowAnimationSpec,
SurfaceAnimationRunner surfaceAnimationRunner, boolean show, int index) {
super(windowAnimationSpec, surfaceAnimationRunner);
mShow = show;
mIndex = index;
}
@Override
public boolean shouldDeferAnimationFinish(Runnable endDeferFinishCallback) {
// We defer the end of the hide animation to ensure the tokens stay hidden until
// we show them again.
if (!mShow) {
mDeferredFinishCallbacks[mIndex] = endDeferFinishCallback;
return true;
}
return false;
}
}
}

9
services/core/java/com/android/server/wm/SurfaceAnimator.java
View File

@@ -488,6 +488,12 @@ class SurfaceAnimator {
*/
static final int ANIMATION_TYPE_INSETS_CONTROL = 1 << 5;
/**
* Animation when a fixed rotation transform is applied to a window token.
* @hide
*/
static final int ANIMATION_TYPE_FIXED_TRANSFORM = 1 << 6;
/**
* Bitmask to include all animation types. This is NOT an {@link AnimationType}
* @hide
@@ -505,7 +511,8 @@ class SurfaceAnimator {
ANIMATION_TYPE_DIMMER,
ANIMATION_TYPE_RECENTS,
ANIMATION_TYPE_WINDOW_ANIMATION,
ANIMATION_TYPE_INSETS_CONTROL
ANIMATION_TYPE_INSETS_CONTROL,
ANIMATION_TYPE_FIXED_TRANSFORM
})
@Retention(RetentionPolicy.SOURCE)
@interface AnimationType {}

3
services/core/java/com/android/server/wm/WindowToken.java
View File

@@ -642,6 +642,9 @@ class WindowToken extends WindowContainer<WindowState> {
final int originalRotation = getWindowConfiguration().getRotation();
onConfigurationChanged(parent.getConfiguration());
onCancelFixedRotationTransform(originalRotation);
if (mDisplayContent.mFixedRotationAnimationController != null) {
mDisplayContent.mFixedRotationAnimationController.cancel();
}
}
/**

12
services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java
View File

@@ -57,6 +57,7 @@ import static com.android.dx.mockito.inline.extended.ExtendedMockito.same;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.times;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.verify;
import static com.android.server.wm.SurfaceAnimator.ANIMATION_TYPE_FIXED_TRANSFORM;
import static com.android.server.wm.WindowContainer.POSITION_TOP;
import static com.android.server.wm.WindowManagerService.UPDATE_FOCUS_NORMAL;
@@ -1059,6 +1060,8 @@ public class DisplayContentTests extends WindowTestsBase {
@Test
public void testApplyTopFixedRotationTransform() {
mWm.mIsFixedRotationTransformEnabled = true;
mDisplayContent.getDisplayPolicy().addWindowLw(mStatusBarWindow, mStatusBarWindow.mAttrs);
mDisplayContent.getDisplayPolicy().addWindowLw(mNavBarWindow, mNavBarWindow.mAttrs);
final Configuration config90 = new Configuration();
mDisplayContent.computeScreenConfiguration(config90, ROTATION_90);
@@ -1079,6 +1082,12 @@ public class DisplayContentTests extends WindowTestsBase {
ROTATION_0 /* oldRotation */, ROTATION_90 /* newRotation */,
false /* forceUpdate */));
assertNotNull(mDisplayContent.mFixedRotationAnimationController);
assertTrue(mStatusBarWindow.getParent().isAnimating(WindowContainer.AnimationFlags.PARENTS,
ANIMATION_TYPE_FIXED_TRANSFORM));
assertTrue(mNavBarWindow.getParent().isAnimating(WindowContainer.AnimationFlags.PARENTS,
ANIMATION_TYPE_FIXED_TRANSFORM));
final Rect outFrame = new Rect();
final Rect outInsets = new Rect();
final Rect outStableInsets = new Rect();
@@ -1131,6 +1140,9 @@ public class DisplayContentTests extends WindowTestsBase {
assertFalse(app.hasFixedRotationTransform());
assertFalse(app2.hasFixedRotationTransform());
assertEquals(config90.orientation, mDisplayContent.getConfiguration().orientation);
mDisplayContent.finishFixedRotationAnimation();
assertNull(mDisplayContent.mFixedRotationAnimationController);
}
@Test