path: root/quickstep/src/com/android/launcher3/uioverrides/TwoStepSwipeController.java

/*
 * Copyright (C) 2017 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.launcher3.uioverrides;

import static com.android.launcher3.LauncherState.ALL_APPS;
import static com.android.launcher3.LauncherState.NORMAL;
import static com.android.launcher3.LauncherState.OVERVIEW;
import static com.android.launcher3.anim.Interpolators.scrollInterpolatorForVelocity;
import static com.android.launcher3.anim.SpringAnimationHandler.Y_DIRECTION;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.AnimatorSet;
import android.animation.ValueAnimator;
import android.animation.ValueAnimator.AnimatorUpdateListener;
import android.support.animation.SpringAnimation;
import android.util.Log;
import android.view.MotionEvent;
import android.view.animation.Interpolator;

import com.android.launcher3.AbstractFloatingView;
import com.android.launcher3.Launcher;
import com.android.launcher3.LauncherState;
import com.android.launcher3.LauncherStateManager;
import com.android.launcher3.LauncherStateManager.AnimationConfig;
import com.android.launcher3.LauncherStateManager.StateHandler;
import com.android.launcher3.Utilities;
import com.android.launcher3.allapps.AllAppsContainerView;
import com.android.launcher3.anim.AnimationSuccessListener;
import com.android.launcher3.anim.AnimatorPlaybackController;
import com.android.launcher3.anim.AnimatorSetBuilder;
import com.android.launcher3.anim.Interpolators;
import com.android.launcher3.anim.SpringAnimationHandler;
import com.android.launcher3.touch.SwipeDetector;
import com.android.launcher3.userevent.nano.LauncherLogProto.Action.Direction;
import com.android.launcher3.userevent.nano.LauncherLogProto.Action.Touch;
import com.android.launcher3.userevent.nano.LauncherLogProto.ContainerType;
import com.android.launcher3.util.FloatRange;
import com.android.launcher3.util.TouchController;

import java.util.ArrayList;

/**
 * Handles vertical touch gesture on the DragLayer
 */
public class TwoStepSwipeController extends AnimatorListenerAdapter
        implements TouchController, SwipeDetector.Listener {

    private static final String TAG = "TwoStepSwipeController";

    private static final float RECATCH_REJECTION_FRACTION = .0875f;
    private static final int SINGLE_FRAME_MS = 16;
    private static final long QUICK_SNAP_TO_OVERVIEW_DURATION = 250;

    // Progress after which the transition is assumed to be a success in case user does not fling
    private static final float SUCCESS_TRANSITION_PROGRESS = 0.5f;

    /**
     * Index of the vertical swipe handles in {@link LauncherStateManager#getStateHandlers()}.
     */
    private static final int SWIPE_HANDLER_INDEX = 0;

    /**
     * Index of various UI handlers in {@link LauncherStateManager#getStateHandlers()} not related
     * to vertical swipe.
     */
    private static final int OTHER_HANDLERS_START_INDEX = SWIPE_HANDLER_INDEX + 1;

    // Swipe progress range (when starting from NORMAL state) where OVERVIEW state is allowed
    private static final float MIN_PROGRESS_TO_OVERVIEW = 0.1f;
    private static final float MAX_PROGRESS_TO_OVERVIEW = 0.4f;

    private static final int FLAG_OVERVIEW_DISABLED_OUT_OF_RANGE = 1 << 0;
    private static final int FLAG_OVERVIEW_DISABLED_FLING = 1 << 1;
    private static final int FLAG_OVERVIEW_DISABLED_CANCEL_STATE = 1 << 2;

    private final Launcher mLauncher;
    private final SwipeDetector mDetector;

    private boolean mNoIntercept;
    private int mStartContainerType;

    private DragPauseDetector mDragPauseDetector;
    private FloatRange mOverviewProgressRange;
    private TaggedAnimatorSetBuilder mTaggedAnimatorSetBuilder;
    private AnimatorSet mQuickOverviewAnimation;
    private boolean mAnimatingToOverview;
    private TwoStateAnimationController mTwoStateAnimationController;

    private AnimatorPlaybackController mCurrentAnimation;
    private LauncherState mToState;

    private float mStartProgress;
    // Ratio of transition process [0, 1] to drag displacement (px)
    private float mProgressMultiplier;

    private SpringAnimationHandler[] mSpringHandlers;

    public TwoStepSwipeController(Launcher l) {
        mLauncher = l;
        mDetector = new SwipeDetector(l, this, SwipeDetector.VERTICAL);
    }

    private boolean canInterceptTouch(MotionEvent ev) {
        if (!mLauncher.isInState(NORMAL) && !mLauncher.isInState(ALL_APPS)) {
            // Don't listen for the swipe gesture if we are already in some other state.
            return false;
        }
        if (mAnimatingToOverview) {
            return false;
        }
        if (mCurrentAnimation != null) {
            // If we are already animating from a previous state, we can intercept.
            return true;
        }
        if (mLauncher.isInState(ALL_APPS) && !mLauncher.getAppsView().shouldContainerScroll(ev)) {
            return false;
        }
        if (AbstractFloatingView.getTopOpenView(mLauncher) != null) {
            return false;
        }

        return true;
    }

    @Override
    public void onAnimationCancel(Animator animation) {
        if (mCurrentAnimation != null && animation == mCurrentAnimation.getOriginalTarget()) {
            Log.e(TAG, "Who dare cancel the animation when I am in control", new Exception());
            clearState();
        }
    }

    private void initSprings() {
        AllAppsContainerView appsView = mLauncher.getAppsView();

        SpringAnimationHandler handler = appsView.getSpringAnimationHandler();
        if (handler == null) {
            mSpringHandlers = new SpringAnimationHandler[0];
            return;
        }

        ArrayList<SpringAnimationHandler> handlers = new ArrayList<>();
        handlers.add(handler);

        SpringAnimation searchSpring = appsView.getSearchUiManager().getSpringForFling();
        if (searchSpring != null) {
            SpringAnimationHandler searchHandler =
                    new SpringAnimationHandler(Y_DIRECTION, handler.getFactory());
            searchHandler.add(searchSpring, true /* setDefaultValues */);
            handlers.add(searchHandler);
        }

        mSpringHandlers = handlers.toArray(new SpringAnimationHandler[handlers.size()]);
    }

    @Override
    public boolean onControllerInterceptTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            mNoIntercept = !canInterceptTouch(ev);
            if (mNoIntercept) {
                return false;
            }

            // Now figure out which direction scroll events the controller will start
            // calling the callbacks.
            final int directionsToDetectScroll;
            boolean ignoreSlopWhenSettling = false;

            if (mCurrentAnimation != null) {
                if (mCurrentAnimation.getProgressFraction() > 1 - RECATCH_REJECTION_FRACTION) {
                    directionsToDetectScroll = SwipeDetector.DIRECTION_POSITIVE;
                } else if (mCurrentAnimation.getProgressFraction() < RECATCH_REJECTION_FRACTION ) {
                    directionsToDetectScroll = SwipeDetector.DIRECTION_NEGATIVE;
                } else {
                    directionsToDetectScroll = SwipeDetector.DIRECTION_BOTH;
                    ignoreSlopWhenSettling = true;
                }
            } else {
                if (mLauncher.isInState(ALL_APPS)) {
                    directionsToDetectScroll = SwipeDetector.DIRECTION_NEGATIVE;
                    mStartContainerType = ContainerType.ALLAPPS;
                } else {
                    directionsToDetectScroll = SwipeDetector.DIRECTION_POSITIVE;
                    mStartContainerType = mLauncher.getDragLayer().isEventOverHotseat(ev) ?
                            ContainerType.HOTSEAT : ContainerType.WORKSPACE;
                }
            }

            mDetector.setDetectableScrollConditions(
                    directionsToDetectScroll, ignoreSlopWhenSettling);

            if (mSpringHandlers == null) {
                initSprings();
            }
        }

        if (mNoIntercept) {
            return false;
        }

        onControllerTouchEvent(ev);
        return mDetector.isDraggingOrSettling();
    }

    @Override
    public boolean onControllerTouchEvent(MotionEvent ev) {
        for (SpringAnimationHandler h : mSpringHandlers) {
            h.addMovement(ev);
        }
        return mDetector.onTouchEvent(ev);
    }

    @Override
    public void onDragStart(boolean start) {
        if (mCurrentAnimation == null) {
            float range = getShiftRange();
            long maxAccuracy = (long) (2 * range);

            mDragPauseDetector = new DragPauseDetector(this::onDragPauseDetected);
            mDragPauseDetector.addDisabledFlags(FLAG_OVERVIEW_DISABLED_OUT_OF_RANGE);
            mOverviewProgressRange = new FloatRange();
            mOverviewProgressRange.start = mLauncher.isInState(NORMAL)
                    ? MIN_PROGRESS_TO_OVERVIEW
                    : 1 - MAX_PROGRESS_TO_OVERVIEW;
            mOverviewProgressRange.end = mOverviewProgressRange.start
                    + MAX_PROGRESS_TO_OVERVIEW - MIN_PROGRESS_TO_OVERVIEW;

            // Build current animation
            mToState = mLauncher.isInState(ALL_APPS) ? NORMAL : ALL_APPS;
            mTaggedAnimatorSetBuilder = new TaggedAnimatorSetBuilder();
            mCurrentAnimation = mLauncher.getStateManager().createAnimationToNewWorkspace(
                    mToState, mTaggedAnimatorSetBuilder, maxAccuracy);

            mCurrentAnimation.getTarget().addListener(this);
            mStartProgress = 0;
            mProgressMultiplier = (mLauncher.isInState(ALL_APPS) ? 1 : -1) / range;
            mCurrentAnimation.dispatchOnStart();
        } else {
            mCurrentAnimation.pause();
            mStartProgress = mCurrentAnimation.getProgressFraction();

            mDragPauseDetector.clearDisabledFlags(FLAG_OVERVIEW_DISABLED_FLING);
            updatePauseDetectorRangeFlag();
        }

        for (SpringAnimationHandler h : mSpringHandlers) {
            h.skipToEnd();
        }
    }

    private float getShiftRange() {
        return mLauncher.getAllAppsController().getShiftRange();
    }

    @Override
    public boolean onDrag(float displacement, float velocity) {
        float deltaProgress = mProgressMultiplier * displacement;
        mCurrentAnimation.setPlayFraction(deltaProgress + mStartProgress);

        updatePauseDetectorRangeFlag();
        mDragPauseDetector.onDrag(velocity);

        return true;
    }

    private void updatePauseDetectorRangeFlag() {
        if (mOverviewProgressRange.contains(mCurrentAnimation.getProgressFraction())) {
            mDragPauseDetector.clearDisabledFlags(FLAG_OVERVIEW_DISABLED_OUT_OF_RANGE);
        } else {
            mDragPauseDetector.addDisabledFlags(FLAG_OVERVIEW_DISABLED_OUT_OF_RANGE);
        }
    }

    @Override
    public void onDragEnd(float velocity, boolean fling) {
        if (!fling && mDragPauseDetector.isEnabled() && mDragPauseDetector.isTriggered()) {
            snapToOverview(velocity);
            return;
        }

        mDragPauseDetector.addDisabledFlags(FLAG_OVERVIEW_DISABLED_FLING);

        final long animationDuration;
        final int logAction;
        final LauncherState targetState;
        final float progress = mCurrentAnimation.getProgressFraction();

        if (fling) {
            logAction = Touch.FLING;
            if (velocity < 0) {
                targetState = ALL_APPS;
                animationDuration = SwipeDetector.calculateDuration(velocity,
                        mToState == ALL_APPS ? (1 - progress) : progress);
            } else {
                targetState = NORMAL;
                animationDuration = SwipeDetector.calculateDuration(velocity,
                        mToState == ALL_APPS ? progress : (1 - progress));
            }
            // snap to top or bottom using the release velocity
        } else {
            logAction = Touch.SWIPE;
            if (progress > SUCCESS_TRANSITION_PROGRESS) {
                targetState = mToState;
                animationDuration = SwipeDetector.calculateDuration(velocity, 1 - progress);
            } else {
                targetState = mToState == ALL_APPS ? NORMAL : ALL_APPS;
                animationDuration = SwipeDetector.calculateDuration(velocity, progress);
            }
        }

        if (fling && targetState == ALL_APPS) {
            for (SpringAnimationHandler h : mSpringHandlers) {
                // The icons are moving upwards, so we go to 0 from 1. (y-axis 1 is below 0.)
                h.animateToFinalPosition(0 /* pos */, 1 /* startValue */);
            }
        }
        mCurrentAnimation.setEndAction(() -> onSwipeInteractionCompleted(targetState, logAction));

        float nextFrameProgress = Utilities.boundToRange(
                progress + velocity * SINGLE_FRAME_MS / getShiftRange(), 0f, 1f);

        ValueAnimator anim = mCurrentAnimation.getAnimationPlayer();
        anim.setFloatValues(nextFrameProgress, targetState == mToState ? 1f : 0f);
        anim.setDuration(animationDuration);
        anim.setInterpolator(scrollInterpolatorForVelocity(velocity));
        anim.start();
    }

    private void onSwipeInteractionCompleted(LauncherState targetState, int logAction) {
        if (targetState == mToState) {
            // Transition complete. log the action
            mLauncher.getUserEventDispatcher().logActionOnContainer(logAction,
                    mToState == ALL_APPS ? Direction.UP : Direction.DOWN,
                    mStartContainerType, mLauncher.getWorkspace().getCurrentPage());
        }
        clearState();

        // TODO: mQuickOverviewAnimation might still be running in which changing a state instantly
        // may cause a jump. Animate the state change with a short duration in this case?
        mLauncher.getStateManager().goToState(targetState, false /* animated */);
    }

    private void snapToOverview(float velocity) {
        mAnimatingToOverview = true;

        final float progress = mCurrentAnimation.getProgressFraction();
        float endProgress = mToState == NORMAL ? 1f : 0f;
        long animationDuration = SwipeDetector.calculateDuration(
                velocity, Math.abs(endProgress - progress));
        float nextFrameProgress = Utilities.boundToRange(
                progress + velocity * SINGLE_FRAME_MS / getShiftRange(), 0f, 1f);

        mCurrentAnimation.setEndAction(() -> {
            // TODO: Add logging
            clearState();
            mLauncher.getStateManager().goToState(OVERVIEW, true /* animated */);
        });

        if (mTwoStateAnimationController != null) {
            mTwoStateAnimationController.goBackToStart(endProgress);
        }

        ValueAnimator anim = mCurrentAnimation.getAnimationPlayer();
        anim.setFloatValues(nextFrameProgress, endProgress);
        anim.setDuration(animationDuration);
        anim.setInterpolator(scrollInterpolatorForVelocity(velocity));
        anim.start();
    }

    private void onDragPauseDetected() {
        final ValueAnimator twoStepAnimator = ValueAnimator.ofFloat(0, 1);
        twoStepAnimator.setDuration(mCurrentAnimation.getDuration());
        StateHandler[] handlers = mLauncher.getStateManager().getStateHandlers();

        // Change the current animation to only play the vertical handle
        AnimatorSet anim = new AnimatorSet();
        anim.playTogether(mTaggedAnimatorSetBuilder.getAnimationsForTag(
                handlers[SWIPE_HANDLER_INDEX]));
        anim.play(twoStepAnimator);
        mCurrentAnimation = mCurrentAnimation.cloneFor(anim);

        AnimatorSetBuilder builder = new AnimatorSetBuilder();
        AnimationConfig config = new AnimationConfig();
        config.duration = QUICK_SNAP_TO_OVERVIEW_DURATION;
        for (int i = OTHER_HANDLERS_START_INDEX; i < handlers.length; i++) {
            handlers[i].setStateWithAnimation(OVERVIEW, builder, config);
        }
        mQuickOverviewAnimation = builder.build();
        mQuickOverviewAnimation.addListener(new AnimationSuccessListener() {
            @Override
            public void onAnimationSuccess(Animator animator) {
                onQuickOverviewAnimationComplete(twoStepAnimator);
            }
        });
        mQuickOverviewAnimation.start();
    }

    private void onQuickOverviewAnimationComplete(ValueAnimator twoStepAnimator) {
        if (mAnimatingToOverview) {
            return;
        }

        // The remaining state handlers are on the OVERVIEW state. Create two animations, one
        // towards the NORMAL state and one towards ALL_APPS state and control them based on the
        // swipe progress.
        AnimationConfig config = new AnimationConfig();
        config.duration = (long) (2 * getShiftRange());
        config.userControlled = true;

        LauncherState fromState = mToState == ALL_APPS ? NORMAL : ALL_APPS;
        AnimatorSetBuilder builderToTargetState = new AnimatorSetBuilder();
        AnimatorSetBuilder builderToSourceState = new AnimatorSetBuilder();

        StateHandler[] handlers = mLauncher.getStateManager().getStateHandlers();
        for (int i = OTHER_HANDLERS_START_INDEX; i < handlers.length; i++) {
            handlers[i].setStateWithAnimation(mToState, builderToTargetState, config);
            handlers[i].setStateWithAnimation(fromState, builderToSourceState, config);
        }

        mTwoStateAnimationController = new TwoStateAnimationController(
                AnimatorPlaybackController.wrap(builderToSourceState.build(), config.duration),
                AnimatorPlaybackController.wrap(builderToTargetState.build(), config.duration),
                twoStepAnimator.getAnimatedFraction());
        twoStepAnimator.addUpdateListener(mTwoStateAnimationController);
    }

    private void clearState() {
        mCurrentAnimation = null;
        mTaggedAnimatorSetBuilder = null;
        if (mDragPauseDetector != null) {
            mDragPauseDetector.addDisabledFlags(FLAG_OVERVIEW_DISABLED_CANCEL_STATE);
        }
        mDragPauseDetector = null;

        if (mQuickOverviewAnimation != null) {
            mQuickOverviewAnimation.cancel();
            mQuickOverviewAnimation = null;
        }
        mTwoStateAnimationController = null;
        mAnimatingToOverview = false;

        mDetector.finishedScrolling();
    }

    /**
     * {@link AnimatorUpdateListener} which interpolates two animations based the progress
     */
    private static class TwoStateAnimationController implements AnimatorUpdateListener {

        private final AnimatorPlaybackController mControllerTowardsStart;
        private final AnimatorPlaybackController mControllerTowardsEnd;

        private Interpolator mInterpolator = Interpolators.LINEAR;
        private float mStartFraction;
        private float mLastFraction;

        TwoStateAnimationController(AnimatorPlaybackController controllerTowardsStart,
                AnimatorPlaybackController controllerTowardsEnd, float startFraction) {
            mControllerTowardsStart = controllerTowardsStart;
            mControllerTowardsEnd = controllerTowardsEnd;
            mLastFraction = mStartFraction = startFraction;
        }

        @Override
        public void onAnimationUpdate(ValueAnimator valueAnimator) {
            mLastFraction = mInterpolator.getInterpolation(valueAnimator.getAnimatedFraction());
            if (mLastFraction > mStartFraction) {
                if (mStartFraction >= 1) {
                    mControllerTowardsEnd.setPlayFraction(0);
                } else {
                    mControllerTowardsEnd.setPlayFraction(
                            (mLastFraction - mStartFraction) / (1 - mStartFraction));
                }
            } else {
                if (mStartFraction <= 0) {
                    mControllerTowardsStart.setPlayFraction(0);
                } else {
                    mControllerTowardsStart.setPlayFraction(
                            (mStartFraction - mLastFraction) / mStartFraction);
                }
            }
        }

        /**
         * Changes the interpolator such that from this point ({@link #mLastFraction}), the
         * animation run towards {@link #mStartFraction}. This allows us to animate the UI back
         * to the original point.
         * @param endFraction expected end point for this animation. Should either be 0 or 1.
         */
        public void goBackToStart(float endFraction) {
            if (mLastFraction == mStartFraction || mLastFraction == endFraction) {
                mInterpolator = (v) -> mStartFraction;
            } else if (mLastFraction > mStartFraction && endFraction < mStartFraction) {
                mInterpolator = (v) -> Math.max(v, mStartFraction);
            } else if (mLastFraction < mStartFraction && endFraction > mStartFraction) {
                mInterpolator = (v) -> Math.min(mStartFraction, v);
            } else {
                final float start = mLastFraction;
                final float range = endFraction - mLastFraction;
                mInterpolator = (v) ->
                        SwipeDetector.interpolate(start, mStartFraction, (v - start) / range);
            }
        }
    }
}