Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5b09708e authored by Tony Huang's avatar Tony Huang
Browse files

[Re-land]Improve enter split transition

Improve enter split transition by two part changes.
1. Enter split with resizing animation:
   We directly show split but no animation before, it might looks
   bad to user because UI change too many things in few frames.

2. Fix flicker cause by black screen when split active:
   When we start intent on side stage task, the top split root task
   will go to top and current top one task will be set as invisible
   then cause black screen due to split root task is full screen.
   Solve this by use new wct api setForceTranslucent to make split
   root task as translucent when split inactive. We need to reset
   it when split active otherwise it cause flicker when back to home.

   Except above change, we also need to set side stage bounds to
   area outside of screen otherwise it still cause flicker because it
   will show a flash of shadow when launch intent on side stage.

   This solution should be removed after shell transition fully
   landing because in shell transition we could make those transitions
   be done in one transition.

3. Fix b/243634747 caused by the previous CL. We should ensure split top
   root is non-translucnet after split active by any flow.

4. Fix b/243735702 which occured on the previous CL. Because sync
   transcation might apply after the animation, we could remove apply
   when split active but only apply by the animator.

Fix: 223325631
Fix: 243634747
Fix: 243735702
Test: manual
Test: pass existing tests
Change-Id: Id8822aafe9eb0d6d5b0282cea256db622b9730d0
parent cd1952c8
Loading
Loading
Loading
Loading
+46 −8
Original line number Diff line number Diff line
@@ -80,7 +80,10 @@ public final class SplitLayout implements DisplayInsetsController.OnInsetsChange
    public static final int PARALLAX_DISMISSING = 1;
    public static final int PARALLAX_ALIGN_CENTER = 2;

    private static final int FLING_ANIMATION_DURATION = 250;
    private static final int FLING_RESIZE_DURATION = 250;
    private static final int FLING_SWITCH_DURATION = 350;
    private static final int FLING_ENTER_DURATION = 350;
    private static final int FLING_EXIT_DURATION = 350;

    private final int mDividerWindowWidth;
    private final int mDividerInsets;
@@ -93,6 +96,9 @@ public final class SplitLayout implements DisplayInsetsController.OnInsetsChange
    private final Rect mBounds1 = new Rect();
    // Bounds2 final position should be always at bottom or right
    private final Rect mBounds2 = new Rect();
    // The temp bounds outside of display bounds for side stage when split screen inactive to avoid
    // flicker next time active split screen.
    private final Rect mInvisibleBounds = new Rect();
    private final Rect mWinBounds1 = new Rect();
    private final Rect mWinBounds2 = new Rect();
    private final SplitLayoutHandler mSplitLayoutHandler;
@@ -141,6 +147,8 @@ public final class SplitLayout implements DisplayInsetsController.OnInsetsChange
        resetDividerPosition();

        mDimNonImeSide = resources.getBoolean(R.bool.config_dimNonImeAttachedSide);

        updateInvisibleRect();
    }

    private int getDividerInsets(Resources resources, Display display) {
@@ -239,6 +247,12 @@ public final class SplitLayout implements DisplayInsetsController.OnInsetsChange
        rect.offset(-mRootBounds.left, -mRootBounds.top);
    }

    /** Gets bounds size equal to root bounds but outside of screen, used for position side stage
     * when split inactive to avoid flicker when next time active. */
    public void getInvisibleBounds(Rect rect) {
        rect.set(mInvisibleBounds);
    }

    /** Returns leash of the current divider bar. */
    @Nullable
    public SurfaceControl getDividerLeash() {
@@ -258,6 +272,14 @@ public final class SplitLayout implements DisplayInsetsController.OnInsetsChange
                : (float) ((mBounds1.bottom + mBounds2.top) / 2f) / mBounds2.bottom));
    }

    private void updateInvisibleRect() {
        mInvisibleBounds.set(mRootBounds.left, mRootBounds.top,
                isLandscape() ? mRootBounds.right / 2 : mRootBounds.right,
                isLandscape() ? mRootBounds.bottom : mRootBounds.bottom / 2);
        mInvisibleBounds.offset(isLandscape() ? mRootBounds.right : 0,
                isLandscape() ? 0 : mRootBounds.bottom);
    }

    /** Applies new configuration, returns {@code false} if there's no effect to the layout. */
    public boolean updateConfiguration(Configuration configuration) {
        // Update the split bounds when necessary. Besides root bounds changed, split bounds need to
@@ -283,6 +305,7 @@ public final class SplitLayout implements DisplayInsetsController.OnInsetsChange
        mRotation = rotation;
        mDividerSnapAlgorithm = getSnapAlgorithm(mContext, mRootBounds, null);
        initDividerPosition(mTempRect);
        updateInvisibleRect();

        return true;
    }
@@ -405,6 +428,13 @@ public final class SplitLayout implements DisplayInsetsController.OnInsetsChange
        mFreezeDividerWindow = freezeDividerWindow;
    }

    /** Update current layout as divider put on start or end position. */
    public void setDividerAtBorder(boolean start) {
        final int pos = start ? mDividerSnapAlgorithm.getDismissStartTarget().position
                : mDividerSnapAlgorithm.getDismissEndTarget().position;
        setDividePosition(pos, false /* applyLayoutChange */);
    }

    /**
     * Updates bounds with the passing position. Usually used to update recording bounds while
     * performing animation or dragging divider bar to resize the splits.
@@ -449,17 +479,17 @@ public final class SplitLayout implements DisplayInsetsController.OnInsetsChange
    public void snapToTarget(int currentPosition, DividerSnapAlgorithm.SnapTarget snapTarget) {
        switch (snapTarget.flag) {
            case FLAG_DISMISS_START:
                flingDividePosition(currentPosition, snapTarget.position,
                flingDividePosition(currentPosition, snapTarget.position, FLING_RESIZE_DURATION,
                        () -> mSplitLayoutHandler.onSnappedToDismiss(false /* bottomOrRight */,
                                EXIT_REASON_DRAG_DIVIDER));
                break;
            case FLAG_DISMISS_END:
                flingDividePosition(currentPosition, snapTarget.position,
                flingDividePosition(currentPosition, snapTarget.position, FLING_RESIZE_DURATION,
                        () -> mSplitLayoutHandler.onSnappedToDismiss(true /* bottomOrRight */,
                                EXIT_REASON_DRAG_DIVIDER));
                break;
            default:
                flingDividePosition(currentPosition, snapTarget.position,
                flingDividePosition(currentPosition, snapTarget.position, FLING_RESIZE_DURATION,
                        () -> setDividePosition(snapTarget.position, true /* applyLayoutChange */));
                break;
        }
@@ -514,12 +544,20 @@ public final class SplitLayout implements DisplayInsetsController.OnInsetsChange
    public void flingDividerToDismiss(boolean toEnd, int reason) {
        final int target = toEnd ? mDividerSnapAlgorithm.getDismissEndTarget().position
                : mDividerSnapAlgorithm.getDismissStartTarget().position;
        flingDividePosition(getDividePosition(), target,
        flingDividePosition(getDividePosition(), target, FLING_EXIT_DURATION,
                () -> mSplitLayoutHandler.onSnappedToDismiss(toEnd, reason));
    }

    /** Fling divider from current position to center position. */
    public void flingDividerToCenter() {
        final int pos = mDividerSnapAlgorithm.getMiddleTarget().position;
        flingDividePosition(getDividePosition(), pos, FLING_ENTER_DURATION,
                () -> setDividePosition(pos, true /* applyLayoutChange */));
    }

    @VisibleForTesting
    void flingDividePosition(int from, int to, @Nullable Runnable flingFinishedCallback) {
    void flingDividePosition(int from, int to, int duration,
            @Nullable Runnable flingFinishedCallback) {
        if (from == to) {
            // No animation run, still callback to stop resizing.
            mSplitLayoutHandler.onLayoutSizeChanged(this);
@@ -529,7 +567,7 @@ public final class SplitLayout implements DisplayInsetsController.OnInsetsChange
        }
        ValueAnimator animator = ValueAnimator
                .ofInt(from, to)
                .setDuration(FLING_ANIMATION_DURATION);
                .setDuration(duration);
        animator.setInterpolator(Interpolators.FAST_OUT_SLOW_IN);
        animator.addUpdateListener(
                animation -> updateDivideBounds((int) animation.getAnimatedValue()));
@@ -586,7 +624,7 @@ public final class SplitLayout implements DisplayInsetsController.OnInsetsChange

        AnimatorSet set = new AnimatorSet();
        set.playTogether(animator1, animator2, animator3);
        set.setDuration(FLING_ANIMATION_DURATION);
        set.setDuration(FLING_SWITCH_DURATION);
        set.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
+37 −20
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
import static android.content.Intent.FLAG_ACTIVITY_MULTIPLE_TASK;
import static android.content.res.Configuration.SMALLEST_SCREEN_WIDTH_DP_UNDEFINED;
import static android.view.Display.DEFAULT_DISPLAY;
import static android.view.RemoteAnimationTarget.MODE_OPENING;
import static android.view.WindowManager.LayoutParams.TYPE_DOCK_DIVIDER;
@@ -488,13 +489,6 @@ public class StageCoordinator implements SplitLayout.SplitLayoutHandler,
        final WindowContainerTransaction wct = new WindowContainerTransaction();
        options = resolveStartStage(STAGE_TYPE_UNDEFINED, position, options, wct);

        // If split still not active, apply windows bounds first to avoid surface reset to
        // wrong pos by SurfaceAnimator from wms.
        // TODO(b/223325631): check  is it still necessary after improve enter transition done.
        if (!mMainStage.isActive()) {
            updateWindowBounds(mSplitLayout, wct);
        }

        wct.sendPendingIntent(intent, fillInIntent, options);
        mSyncQueue.queue(transition, WindowManager.TRANSIT_OPEN, wct);
    }
@@ -519,6 +513,7 @@ public class StageCoordinator implements SplitLayout.SplitLayoutHandler,
        mSplitLayout.setDivideRatio(splitRatio);
        updateWindowBounds(mSplitLayout, wct);
        wct.reorder(mRootTaskInfo.token, true);
        wct.setForceTranslucent(mRootTaskInfo.token, false);

        // Make sure the launch options will put tasks in the corresponding split roots
        addActivityOptions(mainOptions, mMainStage);
@@ -628,6 +623,7 @@ public class StageCoordinator implements SplitLayout.SplitLayoutHandler,
        }
        updateWindowBounds(mSplitLayout, wct);
        wct.reorder(mRootTaskInfo.token, true);
        wct.setForceTranslucent(mRootTaskInfo.token, false);

        // Make sure the launch options will put tasks in the corresponding split roots
        addActivityOptions(mainOptions, mMainStage);
@@ -640,8 +636,8 @@ public class StageCoordinator implements SplitLayout.SplitLayoutHandler,
        } else {
            wct.startTask(sideTaskId, sideOptions);
        }
        // Using legacy transitions, so we can't use blast sync since it conflicts.
        mTaskOrganizer.applyTransaction(wct);

        mSyncQueue.queue(wct);
        mSyncQueue.runInSync(t -> {
            setDividerVisibility(true, t);
            updateSurfaceBounds(mSplitLayout, t, false /* applyResizingOffset */);
@@ -893,10 +889,13 @@ public class StageCoordinator implements SplitLayout.SplitLayoutHandler,
        mShouldUpdateRecents = false;
        mIsDividerRemoteAnimating = false;

        mSplitLayout.getInvisibleBounds(mTempRect1);
        if (childrenToTop == null) {
            mSideStage.removeAllTasks(wct, false /* toTop */);
            mMainStage.deactivate(wct, false /* toTop */);
            wct.reorder(mRootTaskInfo.token, false /* onTop */);
            wct.setForceTranslucent(mRootTaskInfo.token, true);
            wct.setBounds(mSideStage.mRootTaskInfo.token, mTempRect1);
            onTransitionAnimationComplete();
        } else {
            // Expand to top side split as full screen for fading out decor animation and dismiss
@@ -907,27 +906,32 @@ public class StageCoordinator implements SplitLayout.SplitLayoutHandler,
                    ? mSideStage : mMainStage;
            tempFullStage.resetBounds(wct);
            wct.setSmallestScreenWidthDp(tempFullStage.mRootTaskInfo.token,
                    mRootTaskInfo.configuration.smallestScreenWidthDp);
                    SMALLEST_SCREEN_WIDTH_DP_UNDEFINED);
            dismissStage.dismiss(wct, false /* toTop */);
        }
        mSyncQueue.queue(wct);
        mSyncQueue.runInSync(t -> {
            t.setWindowCrop(mMainStage.mRootLeash, null)
                    .setWindowCrop(mSideStage.mRootLeash, null);
            t.setPosition(mMainStage.mRootLeash, 0, 0)
                    .setPosition(mSideStage.mRootLeash, 0, 0);
            t.hide(mMainStage.mDimLayer).hide(mSideStage.mDimLayer);
            setDividerVisibility(false, t);

            if (childrenToTop == null) {
                t.setPosition(mSideStage.mRootLeash, mTempRect1.left, mTempRect1.right);
            } else {
                // In this case, exit still under progress, fade out the split decor after first WCT
                // done and do remaining WCT after animation finished.
            if (childrenToTop != null) {
                childrenToTop.fadeOutDecor(() -> {
                    WindowContainerTransaction finishedWCT = new WindowContainerTransaction();
                    mIsExiting = false;
                    childrenToTop.dismiss(finishedWCT, true /* toTop */);
                    finishedWCT.reorder(mRootTaskInfo.token, false /* toTop */);
                    mTaskOrganizer.applyTransaction(finishedWCT);
                    finishedWCT.setForceTranslucent(mRootTaskInfo.token, true);
                    finishedWCT.setBounds(mSideStage.mRootTaskInfo.token, mTempRect1);
                    mSyncQueue.queue(finishedWCT);
                    mSyncQueue.runInSync(at -> {
                        at.setPosition(mSideStage.mRootLeash, mTempRect1.left, mTempRect1.right);
                    });
                    onTransitionAnimationComplete();
                });
            }
@@ -996,6 +1000,7 @@ public class StageCoordinator implements SplitLayout.SplitLayoutHandler,
        mMainStage.activate(wct, true /* includingTopTask */);
        updateWindowBounds(mSplitLayout, wct);
        wct.reorder(mRootTaskInfo.token, true);
        wct.setForceTranslucent(mRootTaskInfo.token, false);
    }

    void finishEnterSplitScreen(SurfaceControl.Transaction t) {
@@ -1221,7 +1226,13 @@ public class StageCoordinator implements SplitLayout.SplitLayoutHandler,
        // Make the stages adjacent to each other so they occlude what's behind them.
        wct.setAdjacentRoots(mMainStage.mRootTaskInfo.token, mSideStage.mRootTaskInfo.token);
        wct.setLaunchAdjacentFlagRoot(mSideStage.mRootTaskInfo.token);
        mTaskOrganizer.applyTransaction(wct);
        wct.setForceTranslucent(mRootTaskInfo.token, true);
        mSplitLayout.getInvisibleBounds(mTempRect1);
        wct.setBounds(mSideStage.mRootTaskInfo.token, mTempRect1);
        mSyncQueue.queue(wct);
        mSyncQueue.runInSync(t -> {
            t.setPosition(mSideStage.mRootLeash, mTempRect1.left, mTempRect1.top);
        });
    }

    private void onRootTaskVanished() {
@@ -1377,10 +1388,15 @@ public class StageCoordinator implements SplitLayout.SplitLayoutHandler,
            // TODO (b/238697912) : Add the validation to prevent entering non-recovered status
            final WindowContainerTransaction wct = new WindowContainerTransaction();
            mSplitLayout.init();
            prepareEnterSplitScreen(wct);
            mSplitLayout.setDividerAtBorder(mSideStagePosition == SPLIT_POSITION_TOP_OR_LEFT);
            mMainStage.activate(wct, true /* includingTopTask */);
            updateWindowBounds(mSplitLayout, wct);
            wct.reorder(mRootTaskInfo.token, true);
            wct.setForceTranslucent(mRootTaskInfo.token, false);
            mSyncQueue.queue(wct);
            mSyncQueue.runInSync(t ->
                    updateSurfaceBounds(mSplitLayout, t, false /* applyResizingOffset */));
            mSyncQueue.runInSync(t -> {
                mSplitLayout.flingDividerToCenter();
            });
        }
        if (mMainStageListener.mHasChildren && mSideStageListener.mHasChildren) {
            mShouldUpdateRecents = true;
@@ -1822,6 +1838,7 @@ public class StageCoordinator implements SplitLayout.SplitLayoutHandler,
            // properly for the animation itself.
            mSplitLayout.release();
            mSplitLayout.resetDividerPosition();
            mSideStagePosition = SPLIT_POSITION_BOTTOM_OR_RIGHT;
            mTopStageAfterFoldDismiss = STAGE_TYPE_UNDEFINED;
        }
    }
+2 −1
Original line number Diff line number Diff line
@@ -159,7 +159,8 @@ public class SplitLayoutTests extends ShellTestCase {
    }

    private void waitDividerFlingFinished() {
        verify(mSplitLayout).flingDividePosition(anyInt(), anyInt(), mRunnableCaptor.capture());
        verify(mSplitLayout).flingDividePosition(anyInt(), anyInt(), anyInt(),
                mRunnableCaptor.capture());
        mRunnableCaptor.getValue().run();
    }