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

Commit b9abae9f authored by Sunny Goyal's avatar Sunny Goyal
Browse files

Using taskView simulator for animation a task to recentsView 

Also applying transform params in DeviceLockedInputConsumer directly
instead of going through AppWindowAnimationHelper

Bug: 156398988
Bug: 155816922
Change-Id: I791e1a9feb07c4fb787130f8d040a4f404faf734
parent 9027a045

quickstep/recents_ui_overrides/src/com/android/launcher3/uioverrides/RecentsViewStateController.java

+1 −1
Original line number Diff line number Diff line
@@ -71,7 +71,7 @@ public final class RecentsViewStateController extends 
            builder.addOnFrameCallback(mRecentsView::loadVisibleTaskData);

            mRecentsView.updateEmptyMessage();

        } else {

            builder.getAnim().addListener(

            builder.addListener(

                    AnimationSuccessListener.forRunnable(mRecentsView::resetTaskVisuals));

        }

quickstep/recents_ui_overrides/src/com/android/quickstep/AppToOverviewAnimationProvider.java

+39 −63
Original line number Diff line number Diff line
@@ -18,29 +18,26 @@ package com.android.quickstep; 
import static com.android.launcher3.LauncherState.BACKGROUND_APP;

import static com.android.launcher3.LauncherState.OVERVIEW;

import static com.android.launcher3.anim.Interpolators.TOUCH_RESPONSE_INTERPOLATOR;

import static com.android.launcher3.anim.Interpolators.clampToProgress;

import static com.android.launcher3.statehandlers.DepthController.DEPTH;

import static com.android.systemui.shared.system.RemoteAnimationTargetCompat.MODE_CLOSING;

import static com.android.systemui.shared.system.RemoteAnimationTargetCompat.MODE_OPENING;



import android.animation.Animator;

import android.animation.AnimatorSet;

import android.animation.ObjectAnimator;

import android.animation.ValueAnimator;

import android.graphics.Rect;

import android.util.Log;

import android.view.View;

import android.view.animation.Interpolator;



import com.android.launcher3.AbstractFloatingView;

import com.android.launcher3.anim.AnimationSuccessListener;

import com.android.launcher3.anim.PendingAnimation;

import com.android.launcher3.statehandlers.DepthController;

import com.android.launcher3.statemanager.StatefulActivity;

import com.android.quickstep.util.AppWindowAnimationHelper;

import com.android.quickstep.util.RemoteAnimationProvider;

import com.android.quickstep.util.TaskViewSimulator;

import com.android.quickstep.util.TransformParams;

import com.android.quickstep.views.RecentsView;

import com.android.systemui.shared.system.RemoteAnimationTargetCompat;

import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat;

import com.android.systemui.shared.system.TransactionCompat;



/**

 * Provider for the atomic (for 3-button mode) remote window animation from the app to the overview.
@@ -97,32 +94,25 @@ final class AppToOverviewAnimationProvider<T extends StatefulActivity<?>> extend 
    @Override

    public AnimatorSet createWindowAnimation(RemoteAnimationTargetCompat[] appTargets,

            RemoteAnimationTargetCompat[] wallpaperTargets) {

        if (mRecentsView != null) {

            mRecentsView.setRunningTaskIconScaledDown(true);

        PendingAnimation pa = new PendingAnimation(RECENTS_LAUNCH_DURATION);

        if (mActivity == null) {

            Log.e(TAG, "Animation created, before activity");

            return pa.buildAnim();

        }



        AnimatorSet anim = new AnimatorSet();

        anim.addListener(new AnimationSuccessListener() {

        mRecentsView.setRunningTaskIconScaledDown(true);

        pa.addListener(new AnimationSuccessListener() {

            @Override

            public void onAnimationSuccess(Animator animator) {

                mActivityInterface.onSwipeUpToRecentsComplete();

                if (mRecentsView != null) {

                mRecentsView.animateUpRunningTaskIconScale();

            }

            }

        });

        if (mActivity == null) {

            Log.e(TAG, "Animation created, before activity");

            anim.play(ValueAnimator.ofInt(0, 1).setDuration(RECENTS_LAUNCH_DURATION));

            return anim;

        }



        DepthController depthController = mActivityInterface.getDepthController();

        if (depthController != null) {

            anim.play(ObjectAnimator.ofFloat(depthController, DEPTH,

                    BACKGROUND_APP.getDepth(mActivity),

                    OVERVIEW.getDepth(mActivity))

                    .setDuration(RECENTS_LAUNCH_DURATION));

            pa.addFloat(depthController, DEPTH, BACKGROUND_APP.getDepth(mActivity),

                    OVERVIEW.getDepth(mActivity), TOUCH_RESPONSE_INTERPOLATOR);

        }



        RemoteAnimationTargets targets = new RemoteAnimationTargets(appTargets,
@@ -132,53 +122,39 @@ final class AppToOverviewAnimationProvider<T extends StatefulActivity<?>> extend 
        RemoteAnimationTargetCompat runningTaskTarget = targets.findTask(mTargetTaskId);

        if (runningTaskTarget == null) {

            Log.e(TAG, "No closing app");

            anim.play(ValueAnimator.ofInt(0, 1).setDuration(RECENTS_LAUNCH_DURATION));

            return anim;

            return pa.buildAnim();

        }



        final AppWindowAnimationHelper clipHelper = new AppWindowAnimationHelper(

            mRecentsView.getPagedViewOrientedState(), mActivity);



        // At this point, the activity is already started and laid-out. Get the home-bounds

        // relative to the screen using the rootView of the activity.

        int loc[] = new int[2];

        View rootView = mActivity.getRootView();

        rootView.getLocationOnScreen(loc);

        Rect homeBounds = new Rect(loc[0], loc[1],

                loc[0] + rootView.getWidth(), loc[1] + rootView.getHeight());

        clipHelper.updateSource(homeBounds, runningTaskTarget);



        Rect targetRect = new Rect();

        mActivityInterface.getSwipeUpDestinationAndLength(mActivity.getDeviceProfile(), mActivity,

                targetRect);

        clipHelper.updateTargetRect(targetRect);

        clipHelper.prepareAnimation(mActivity.getDeviceProfile());

        TaskViewSimulator tsv = new TaskViewSimulator(mActivity, mRecentsView.getSizeStrategy());

        tsv.setDp(mActivity.getDeviceProfile());

        tsv.setPreview(runningTaskTarget);

        tsv.setLayoutRotation(mRecentsView.getPagedViewOrientedState().getTouchRotation(),

                mRecentsView.getPagedViewOrientedState().getDisplayRotation());



        TransformParams params = new TransformParams()

                .setSyncTransactionApplier(new SyncRtSurfaceTransactionApplierCompat(rootView));

        ValueAnimator valueAnimator = ValueAnimator.ofFloat(0, 1);

        valueAnimator.setDuration(RECENTS_LAUNCH_DURATION);

        valueAnimator.setInterpolator(TOUCH_RESPONSE_INTERPOLATOR);

        valueAnimator.addUpdateListener((v) -> {

            params.setProgress((float) v.getAnimatedValue()).setTargetSet(targets);

            clipHelper.applyTransform(params);

        });

                .setTargetSet(targets)

                .setSyncTransactionApplier(

                        new SyncRtSurfaceTransactionApplierCompat(mActivity.getRootView()));



        AnimatedFloat recentsAlpha = new AnimatedFloat(() -> { });

        params.setBaseAlphaCallback((t, a) -> recentsAlpha.value);



        Interpolator taskInterpolator;

        if (targets.isAnimatingHome()) {

            // If we are animating home, fade in the opening targets

            RemoteAnimationTargets openingSet = new RemoteAnimationTargets(appTargets,

                    wallpaperTargets, MODE_OPENING);



            TransactionCompat transaction = new TransactionCompat();

            valueAnimator.addUpdateListener((v) -> {

                for (RemoteAnimationTargetCompat app : openingSet.apps) {

                    transaction.setAlpha(app.leash, (float) v.getAnimatedValue());

            taskInterpolator = TOUCH_RESPONSE_INTERPOLATOR;

            pa.addFloat(recentsAlpha, AnimatedFloat.VALUE, 0, 1, TOUCH_RESPONSE_INTERPOLATOR);

        } else {

            // When animation from app to recents, the recents layer is drawn on top of the app. To

            // prevent the overlap, we animate the task first and then quickly fade in the recents.

            taskInterpolator = clampToProgress(TOUCH_RESPONSE_INTERPOLATOR, 0, 0.8f);

            pa.addFloat(recentsAlpha, AnimatedFloat.VALUE, 0, 1,

                    clampToProgress(TOUCH_RESPONSE_INTERPOLATOR, 0.8f, 1));

        }

                transaction.apply();

            });

        }

        anim.play(valueAnimator);

        return anim;



        pa.addFloat(params, TransformParams.PROGRESS, 0, 1, taskInterpolator);

        tsv.addAppToOverviewAnim(pa, taskInterpolator);

        pa.addOnFrameCallback(() -> tsv.apply(params));

        return pa.buildAnim();

    }



    /**

quickstep/recents_ui_overrides/src/com/android/quickstep/BaseSwipeUpHandler.java

+9 −24
Original line number Diff line number Diff line
@@ -15,8 +15,6 @@ 
 */

package com.android.quickstep;



import static com.android.launcher3.LauncherState.BACKGROUND_APP;

import static com.android.launcher3.LauncherState.OVERVIEW;

import static com.android.launcher3.anim.Interpolators.ACCEL_1_5;

import static com.android.launcher3.anim.Interpolators.DEACCEL;

import static com.android.launcher3.config.FeatureFlags.ENABLE_QUICKSTEP_LIVE_TILE;
@@ -25,8 +23,6 @@ import static com.android.launcher3.util.VibratorWrapper.OVERVIEW_HAPTIC; 
import static com.android.launcher3.views.FloatingIconView.SHAPE_PROGRESS_DURATION;



import android.animation.Animator;

import android.animation.AnimatorSet;

import android.animation.ObjectAnimator;

import android.annotation.TargetApi;

import android.content.Context;

import android.content.Intent;
@@ -49,6 +45,7 @@ import com.android.launcher3.InvariantDeviceProfile; 
import com.android.launcher3.Utilities;

import com.android.launcher3.anim.AnimationSuccessListener;

import com.android.launcher3.anim.AnimatorPlaybackController;

import com.android.launcher3.anim.PendingAnimation;

import com.android.launcher3.statemanager.StatefulActivity;

import com.android.launcher3.touch.PagedOrientationHandler;

import com.android.launcher3.util.VibratorWrapper;
@@ -377,18 +374,9 @@ public abstract class BaseSwipeUpHandler<T extends StatefulActivity<?>, Q extend 
            mDragLengthFactorStartPullback = mDragLengthFactorMaxPullback = 1;

        }



        AnimatorSet anim = new AnimatorSet();

        anim.setDuration(mTransitionDragLength * 2);

        anim.setInterpolator(t -> t * mDragLengthFactor);

        anim.play(ObjectAnimator.ofFloat(mTaskViewSimulator.recentsViewScale,

                AnimatedFloat.VALUE,

                mTaskViewSimulator.getFullScreenScale(), 1));

        anim.play(ObjectAnimator.ofFloat(mTaskViewSimulator.fullScreenProgress,

                AnimatedFloat.VALUE,

                BACKGROUND_APP.getOverviewFullscreenProgress(),

                OVERVIEW.getOverviewFullscreenProgress()));

        mWindowTransitionController =

                AnimatorPlaybackController.wrap(anim, mTransitionDragLength * 2);

        PendingAnimation pa = new PendingAnimation(mTransitionDragLength * 2);

        mTaskViewSimulator.addAppToOverviewAnim(pa, t -> t * mDragLengthFactor);

        mWindowTransitionController = pa.createPlaybackController();

    }



    /**
@@ -651,15 +639,12 @@ public abstract class BaseSwipeUpHandler<T extends StatefulActivity<?>, Q extend 
        }



        @Override

        public void onBuildParams(Builder builder, RemoteAnimationTargetCompat app, int targetMode,

                TransformParams params) {

            if (app.mode == targetMode

                    && app.activityType != RemoteAnimationTargetCompat.ACTIVITY_TYPE_HOME) {

        public void onBuildTargetParams(

                Builder builder, RemoteAnimationTargetCompat app, TransformParams params) {

            builder.withMatrix(mMatrix)

                    .withWindowCrop(mCropRect)

                    .withCornerRadius(params.getCornerRadius());

        }

        }



        @Override

        public void onCancel() {

quickstep/recents_ui_overrides/src/com/android/quickstep/inputconsumers/DeviceLockedInputConsumer.java

+35 −39
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ package com.android.quickstep.inputconsumers; 
import static android.view.MotionEvent.ACTION_CANCEL;

import static android.view.MotionEvent.ACTION_POINTER_DOWN;

import static android.view.MotionEvent.ACTION_UP;



import static com.android.launcher3.Utilities.squaredHypot;

import static com.android.launcher3.Utilities.squaredTouchSlop;

import static com.android.quickstep.LauncherSwipeHandler.MIN_PROGRESS_FOR_OVERVIEW;
@@ -26,21 +27,22 @@ import static com.android.quickstep.util.ActiveGestureLog.INTENT_EXTRA_LOG_TRACE 


import android.animation.Animator;

import android.animation.AnimatorListenerAdapter;

import android.animation.ValueAnimator;

import android.animation.ObjectAnimator;

import android.content.Context;

import android.content.Intent;

import android.graphics.Matrix;

import android.graphics.Point;

import android.graphics.PointF;

import android.graphics.Rect;

import android.view.MotionEvent;

import android.view.VelocityTracker;

import android.view.ViewConfiguration;



import com.android.launcher3.R;

import com.android.launcher3.Utilities;

import com.android.launcher3.anim.Interpolators;

import com.android.launcher3.testing.TestLogging;

import com.android.launcher3.testing.TestProtocol;

import com.android.launcher3.util.DefaultDisplay;

import com.android.quickstep.AnimatedFloat;

import com.android.quickstep.GestureState;

import com.android.quickstep.InputConsumer;

import com.android.quickstep.MultiStateCallback;
@@ -49,18 +51,19 @@ import com.android.quickstep.RecentsAnimationController; 
import com.android.quickstep.RecentsAnimationDeviceState;

import com.android.quickstep.RecentsAnimationTargets;

import com.android.quickstep.TaskAnimationManager;

import com.android.quickstep.util.AppWindowAnimationHelper;

import com.android.quickstep.util.TransformParams;

import com.android.quickstep.util.TransformParams.BuilderProxy;

import com.android.systemui.shared.recents.model.ThumbnailData;

import com.android.systemui.shared.system.ActivityManagerWrapper;

import com.android.systemui.shared.system.InputMonitorCompat;

import com.android.systemui.shared.system.RemoteAnimationTargetCompat;

import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat.SurfaceParams.Builder;



/**

 * A dummy input consumer used when the device is still locked, e.g. from secure camera.

 */

public class DeviceLockedInputConsumer implements InputConsumer,

        RecentsAnimationCallbacks.RecentsAnimationListener {

        RecentsAnimationCallbacks.RecentsAnimationListener, BuilderProxy {



    private static final String[] STATE_NAMES = DEBUG_STATES ? new String[2] : null;

    private static int getFlagForIndex(int index, String name) {
@@ -83,19 +86,20 @@ public class DeviceLockedInputConsumer implements InputConsumer, 
    private final InputMonitorCompat mInputMonitorCompat;



    private final PointF mTouchDown = new PointF();

    private final AppWindowAnimationHelper mAppWindowAnimationHelper;

    private final TransformParams mTransformParams;

    private final Point mDisplaySize;

    private final MultiStateCallback mStateCallback;



    private final Point mDisplaySize;

    private final Matrix mMatrix = new Matrix();

    private final float mMaxTranslationY;



    private VelocityTracker mVelocityTracker;

    private float mProgress;

    private final AnimatedFloat mProgress = new AnimatedFloat(this::applyTransform);



    private boolean mThresholdCrossed = false;

    private boolean mHomeLaunched = false;



    private RecentsAnimationController mRecentsAnimationController;

    private RecentsAnimationTargets mRecentsAnimationTargets;



    public DeviceLockedInputConsumer(Context context, RecentsAnimationDeviceState deviceState,

            TaskAnimationManager taskAnimationManager, GestureState gestureState,
@@ -105,9 +109,10 @@ public class DeviceLockedInputConsumer implements InputConsumer, 
        mTaskAnimationManager = taskAnimationManager;

        mGestureState = gestureState;

        mTouchSlopSquared = squaredTouchSlop(context);

        mAppWindowAnimationHelper = new AppWindowAnimationHelper(context);

        mTransformParams = new TransformParams();

        mInputMonitorCompat = inputMonitorCompat;

        mMaxTranslationY = context.getResources().getDimensionPixelSize(

                R.dimen.device_locked_y_offset);



        // Do not use DeviceProfile as the user data might be locked

        mDisplaySize = DefaultDisplay.INSTANCE.get(context).getInfo().realSize;
@@ -158,9 +163,7 @@ public class DeviceLockedInputConsumer implements InputConsumer, 
                    }

                } else {

                    float dy = Math.max(mTouchDown.y - y, 0);

                    mProgress = dy / mDisplaySize.y;

                    mTransformParams.setProgress(mProgress);

                    mAppWindowAnimationHelper.applyTransform(mTransformParams);

                    mProgress.updateValue(dy / mDisplaySize.y);

                }

                break;

            }
@@ -189,20 +192,13 @@ public class DeviceLockedInputConsumer implements InputConsumer, 
                // Is fling

                dismissTask = velocityY < 0;

            } else {

                dismissTask = mProgress >= (1 - MIN_PROGRESS_FOR_OVERVIEW);

                dismissTask = mProgress.value >= (1 - MIN_PROGRESS_FOR_OVERVIEW);

            }



            // Animate back to fullscreen before finishing

            ValueAnimator animator = ValueAnimator.ofFloat(mTransformParams.getProgress(), 0f);

            ObjectAnimator animator = mProgress.animateToValue(mProgress.value, 0);

            animator.setDuration(100);

            animator.setInterpolator(Interpolators.ACCEL);

            animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

                @Override

                public void onAnimationUpdate(ValueAnimator valueAnimator) {

                    mTransformParams.setProgress((float) valueAnimator.getAnimatedValue());

                    mAppWindowAnimationHelper.applyTransform(mTransformParams);

                }

            });

            animator.addListener(new AnimatorListenerAdapter() {

                @Override

                public void onAnimationEnd(Animator animation) {
@@ -239,29 +235,15 @@ public class DeviceLockedInputConsumer implements InputConsumer, 
    public void onRecentsAnimationStart(RecentsAnimationController controller,

            RecentsAnimationTargets targets) {

        mRecentsAnimationController = controller;

        mRecentsAnimationTargets = targets;



        Rect displaySize = new Rect(0, 0, mDisplaySize.x, mDisplaySize.y);

        RemoteAnimationTargetCompat targetCompat = targets.findTask(

                mGestureState.getRunningTaskId());

        if (targetCompat != null) {

            mAppWindowAnimationHelper.updateSource(displaySize, targetCompat);

        }



        // Offset the surface slightly

        displaySize.offset(0, mContext.getResources().getDimensionPixelSize(

                R.dimen.device_locked_y_offset));

        mTransformParams.setTargetSet(mRecentsAnimationTargets);

        mAppWindowAnimationHelper.updateTargetRect(displaySize);

        mAppWindowAnimationHelper.applyTransform(mTransformParams);



        mTransformParams.setTargetSet(targets);

        applyTransform();

        mStateCallback.setState(STATE_TARGET_RECEIVED);

    }



    @Override

    public void onRecentsAnimationCanceled(ThumbnailData thumbnailData) {

        mRecentsAnimationController = null;

        mRecentsAnimationTargets = null;

        mTransformParams.setTargetSet(null);

    }



    private void endRemoteAnimation() {
@@ -273,6 +255,20 @@ public class DeviceLockedInputConsumer implements InputConsumer, 
        }

    }



    private void applyTransform() {

        mTransformParams.setProgress(mProgress.value);

        if (mTransformParams.getTargetSet() != null) {

            mTransformParams.applySurfaceParams(mTransformParams.createSurfaceParams(this));

        }

    }



    @Override

    public void onBuildTargetParams(

            Builder builder, RemoteAnimationTargetCompat app, TransformParams params) {

        mMatrix.setTranslate(0, mProgress.value * mMaxTranslationY);

        builder.withMatrix(mMatrix);

    }



    @Override

    public void onConsumerAboutToBeSwitched() {

        mStateCallback.setState(STATE_HANDLER_INVALIDATED);

quickstep/recents_ui_overrides/src/com/android/quickstep/util/AppWindowAnimationHelper.java

+0 −27
Original line number Diff line number Diff line
@@ -77,7 +77,6 @@ public class AppWindowAnimationHelper implements TransformParams.BuilderProxy { 
    private final Matrix mTmpMatrix = new Matrix();

    private final Rect mTmpRect = new Rect();

    private final RectF mTmpRectF = new RectF();

    private final RectF mCurrentRectWithInsets = new RectF();

    private RecentsOrientedState mOrientedState;

    // Corner radius of windows, in pixels

    private final float mWindowCornerRadius;
@@ -88,9 +87,6 @@ public class AppWindowAnimationHelper implements TransformParams.BuilderProxy { 
    // Whether or not to actually use the rounded cornders on windows

    private boolean mUseRoundedCornersOnWindows;



    // Corner radius currently applied to transformed window.

    private float mCurrentCornerRadius;



    public AppWindowAnimationHelper(RecentsOrientedState orientedState, Context context) {

        Resources res = context.getResources();

        mOrientedState = orientedState;
@@ -100,10 +96,6 @@ public class AppWindowAnimationHelper implements TransformParams.BuilderProxy { 
        mUseRoundedCornersOnWindows = mSupportsRoundedCornersOnWindows;

    }



    public AppWindowAnimationHelper(Context context) {

        this(null, context);

    }



    private void updateSourceStack(RemoteAnimationTargetCompat target) {

        mSourceInsets.set(target.contentInsets);

        mSourceStackBounds.set(target.screenSpaceBounds);
@@ -112,15 +104,6 @@ public class AppWindowAnimationHelper implements TransformParams.BuilderProxy { 
        mSourceStackBounds.offsetTo(target.position.x, target.position.y);

    }



    public void updateSource(Rect homeStackBounds, RemoteAnimationTargetCompat target) {

        updateSourceStack(target);

        updateHomeBounds(homeStackBounds);

    }



    public void updateHomeBounds(Rect homeStackBounds) {

        mHomeStackBounds.set(homeStackBounds);

    }



    public void updateTargetRect(Rect targetRect) {

        mSourceRect.set(mSourceInsets.left, mSourceInsets.top,

                mSourceStackBounds.width() - mSourceInsets.right,
@@ -205,7 +188,6 @@ public class AppWindowAnimationHelper implements TransformParams.BuilderProxy { 
                    cornerRadius = mapRange(boundToRange(params.getProgress(), 0, 1),

                            windowCornerRadius, mTaskCornerRadius);

                }

                mCurrentCornerRadius = cornerRadius;

            }



            builder.withMatrix(mTmpMatrix)
@@ -241,11 +223,6 @@ public class AppWindowAnimationHelper implements TransformParams.BuilderProxy { 
                mSourceStackBounds.height() - (mSourceWindowClipInsets.bottom * progress);

    }



    public RectF getCurrentRectWithInsets() {

        mTmpMatrix.mapRect(mCurrentRectWithInsets, mCurrentClipRectF);

        return mCurrentRectWithInsets;

    }



    public void fromTaskThumbnailView(TaskThumbnailView ttv, RecentsView rv,

            @Nullable RemoteAnimationTargetCompat target) {

        BaseDraggingActivity activity = BaseDraggingActivity.fromContext(ttv.getContext());
@@ -317,8 +294,4 @@ public class AppWindowAnimationHelper implements TransformParams.BuilderProxy { 
        return mTargetRect;

    }



    public float getCurrentCornerRadius() {

        return mCurrentCornerRadius;

    }



}