mirror of
https://github.com/LawnchairLauncher/lawnchair.git
synced 2026-02-20 03:08:19 +00:00
fc564f1477
Previously we were ending the atomic animation with the assumption that it should be complete/almost complete by the time you drag to the next state. However, it is very easy to drag quickly enough where that assumption doesn't hold, and thus you just see the atomic animation pop to the end (i.e. recents showing without animation). Now instead of ending the atomic animation, we let it continue. But because the new state animation will have an atomic component that interferes with the still playing atomic animation, we have to control the atomic component separately; we control the non-atomic components until the atomic animation ends, at which point we create a separate controller to control the atomic components. Bug: 76449024 Change-Id: Ia4bf19e26d0838f952d9e500fbdd8aba19856a41
489 lines
20 KiB
Java
489 lines
20 KiB
Java
/*
|
|
* Copyright (C) 2019 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.touch;
|
|
|
|
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.LauncherStateManager.ANIM_ALL;
|
|
import static com.android.launcher3.LauncherStateManager.ATOMIC_COMPONENT;
|
|
import static com.android.launcher3.LauncherStateManager.NON_ATOMIC_COMPONENT;
|
|
import static com.android.launcher3.Utilities.SINGLE_FRAME_MS;
|
|
import static com.android.launcher3.anim.Interpolators.scrollInterpolatorForVelocity;
|
|
|
|
import android.animation.Animator;
|
|
import android.animation.AnimatorListenerAdapter;
|
|
import android.animation.AnimatorSet;
|
|
import android.animation.ValueAnimator;
|
|
import android.view.HapticFeedbackConstants;
|
|
import android.view.MotionEvent;
|
|
|
|
import com.android.launcher3.Launcher;
|
|
import com.android.launcher3.LauncherState;
|
|
import com.android.launcher3.LauncherStateManager.AnimationComponents;
|
|
import com.android.launcher3.LauncherStateManager.AnimationConfig;
|
|
import com.android.launcher3.LauncherStateManager.StateHandler;
|
|
import com.android.launcher3.Utilities;
|
|
import com.android.launcher3.anim.AnimationSuccessListener;
|
|
import com.android.launcher3.anim.AnimatorPlaybackController;
|
|
import com.android.launcher3.anim.AnimatorSetBuilder;
|
|
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.PendingAnimation;
|
|
import com.android.launcher3.util.TouchController;
|
|
|
|
/**
|
|
* TouchController for handling state changes
|
|
*/
|
|
public abstract class AbstractStateChangeTouchController
|
|
implements TouchController, SwipeDetector.Listener {
|
|
|
|
private static final String TAG = "ASCTouchController";
|
|
|
|
// Progress after which the transition is assumed to be a success in case user does not fling
|
|
public static final float SUCCESS_TRANSITION_PROGRESS = 0.5f;
|
|
|
|
/**
|
|
* Play an atomic recents animation when the progress from NORMAL to OVERVIEW reaches this.
|
|
*/
|
|
public static final float ATOMIC_OVERVIEW_ANIM_THRESHOLD = 0.5f;
|
|
private static final long ATOMIC_NORMAL_TO_OVERVIEW_DURATION = 120;
|
|
private static final long ATOMIC_OVERVIEW_TO_NORMAL_DURATION = 200;
|
|
|
|
protected final Launcher mLauncher;
|
|
protected final SwipeDetector mDetector;
|
|
|
|
private boolean mNoIntercept;
|
|
protected int mStartContainerType;
|
|
|
|
protected LauncherState mFromState;
|
|
protected LauncherState mToState;
|
|
protected AnimatorPlaybackController mCurrentAnimation;
|
|
protected PendingAnimation mPendingAnimation;
|
|
|
|
private float mStartProgress;
|
|
// Ratio of transition process [0, 1] to drag displacement (px)
|
|
private float mProgressMultiplier;
|
|
private float mDisplacementShift;
|
|
private boolean mCanBlockFling;
|
|
private boolean mBlockFling;
|
|
|
|
private AnimatorSet mAtomicAnim;
|
|
private boolean mPassedOverviewAtomicThreshold;
|
|
// mAtomicAnim plays the atomic components of the state animations when we pass the threshold.
|
|
// However, if we reinit to transition to a new state (e.g. OVERVIEW -> ALL_APPS) before the
|
|
// atomic animation finishes, we only control the non-atomic components so that we don't
|
|
// interfere with the atomic animation. When the atomic animation ends, we start controlling
|
|
// the atomic components as well, using this controller.
|
|
private AnimatorPlaybackController mAtomicComponentsController;
|
|
private float mAtomicComponentsStartProgress;
|
|
|
|
public AbstractStateChangeTouchController(Launcher l, SwipeDetector.Direction dir) {
|
|
mLauncher = l;
|
|
mDetector = new SwipeDetector(l, this, dir);
|
|
}
|
|
|
|
protected abstract boolean canInterceptTouch(MotionEvent ev);
|
|
|
|
@Override
|
|
public final 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) {
|
|
directionsToDetectScroll = SwipeDetector.DIRECTION_BOTH;
|
|
ignoreSlopWhenSettling = true;
|
|
} else {
|
|
directionsToDetectScroll = getSwipeDirection();
|
|
if (directionsToDetectScroll == 0) {
|
|
mNoIntercept = true;
|
|
return false;
|
|
}
|
|
}
|
|
mDetector.setDetectableScrollConditions(
|
|
directionsToDetectScroll, ignoreSlopWhenSettling);
|
|
}
|
|
|
|
if (mNoIntercept) {
|
|
return false;
|
|
}
|
|
|
|
onControllerTouchEvent(ev);
|
|
return mDetector.isDraggingOrSettling();
|
|
}
|
|
|
|
private int getSwipeDirection() {
|
|
LauncherState fromState = mLauncher.getStateManager().getState();
|
|
int swipeDirection = 0;
|
|
if (getTargetState(fromState, true /* isDragTowardPositive */) != fromState) {
|
|
swipeDirection |= SwipeDetector.DIRECTION_POSITIVE;
|
|
}
|
|
if (getTargetState(fromState, false /* isDragTowardPositive */) != fromState) {
|
|
swipeDirection |= SwipeDetector.DIRECTION_NEGATIVE;
|
|
}
|
|
return swipeDirection;
|
|
}
|
|
|
|
@Override
|
|
public final boolean onControllerTouchEvent(MotionEvent ev) {
|
|
return mDetector.onTouchEvent(ev);
|
|
}
|
|
|
|
protected float getShiftRange() {
|
|
return mLauncher.getAllAppsController().getShiftRange();
|
|
}
|
|
|
|
/**
|
|
* Returns the state to go to from fromState given the drag direction. If there is no state in
|
|
* that direction, returns fromState.
|
|
*/
|
|
protected abstract LauncherState getTargetState(LauncherState fromState,
|
|
boolean isDragTowardPositive);
|
|
|
|
protected abstract float initCurrentAnimation(@AnimationComponents int animComponents);
|
|
|
|
/**
|
|
* Returns the container that the touch started from when leaving NORMAL state.
|
|
*/
|
|
protected abstract int getLogContainerTypeForNormalState();
|
|
|
|
private boolean reinitCurrentAnimation(boolean reachedToState, boolean isDragTowardPositive) {
|
|
LauncherState newFromState = mFromState == null ? mLauncher.getStateManager().getState()
|
|
: reachedToState ? mToState : mFromState;
|
|
LauncherState newToState = getTargetState(newFromState, isDragTowardPositive);
|
|
|
|
if (newFromState == mFromState && newToState == mToState || (newFromState == newToState)) {
|
|
return false;
|
|
}
|
|
|
|
if (reachedToState) {
|
|
logReachedState(Touch.SWIPE);
|
|
}
|
|
if (newFromState == ALL_APPS) {
|
|
mStartContainerType = ContainerType.ALLAPPS;
|
|
} else if (newFromState == NORMAL) {
|
|
mStartContainerType = getLogContainerTypeForNormalState();
|
|
} else if (newFromState == OVERVIEW){
|
|
mStartContainerType = ContainerType.TASKSWITCHER;
|
|
}
|
|
|
|
mFromState = newFromState;
|
|
mToState = newToState;
|
|
|
|
mStartProgress = 0;
|
|
mPassedOverviewAtomicThreshold = false;
|
|
if (mCurrentAnimation != null) {
|
|
mCurrentAnimation.setOnCancelRunnable(null);
|
|
}
|
|
int animComponents = goingBetweenNormalAndOverview(mFromState, mToState)
|
|
? NON_ATOMIC_COMPONENT : ANIM_ALL;
|
|
if (mAtomicAnim != null) {
|
|
// Control the non-atomic components until the atomic animation finishes, then control
|
|
// the atomic components as well.
|
|
animComponents = NON_ATOMIC_COMPONENT;
|
|
mAtomicAnim.addListener(new AnimationSuccessListener() {
|
|
@Override
|
|
public void onAnimationSuccess(Animator animation) {
|
|
cancelAtomicComponentsController();
|
|
mAtomicComponentsStartProgress = mCurrentAnimation.getProgressFraction();
|
|
long duration = (long) (getShiftRange() * 2);
|
|
mAtomicComponentsController = AnimatorPlaybackController.wrap(
|
|
createAtomicAnimForState(mToState, duration), duration);
|
|
mAtomicComponentsController.dispatchOnStart();
|
|
}
|
|
});
|
|
}
|
|
if (goingBetweenNormalAndOverview(mFromState, mToState)) {
|
|
cancelAtomicComponentsController();
|
|
}
|
|
mProgressMultiplier = initCurrentAnimation(animComponents);
|
|
mCurrentAnimation.dispatchOnStart();
|
|
return true;
|
|
}
|
|
|
|
private boolean goingBetweenNormalAndOverview(LauncherState fromState, LauncherState toState) {
|
|
return (fromState == NORMAL || fromState == OVERVIEW)
|
|
&& (toState == NORMAL || toState == OVERVIEW)
|
|
&& mPendingAnimation == null;
|
|
}
|
|
|
|
@Override
|
|
public void onDragStart(boolean start) {
|
|
if (mCurrentAnimation == null) {
|
|
mFromState = mToState = null;
|
|
mAtomicComponentsController = null;
|
|
reinitCurrentAnimation(false, mDetector.wasInitialTouchPositive());
|
|
mDisplacementShift = 0;
|
|
} else {
|
|
mCurrentAnimation.pause();
|
|
mStartProgress = mCurrentAnimation.getProgressFraction();
|
|
}
|
|
mCanBlockFling = mFromState == NORMAL;
|
|
mBlockFling = false;
|
|
}
|
|
|
|
@Override
|
|
public boolean onDrag(float displacement, float velocity) {
|
|
float deltaProgress = mProgressMultiplier * (displacement - mDisplacementShift);
|
|
float progress = deltaProgress + mStartProgress;
|
|
updateProgress(progress);
|
|
boolean isDragTowardPositive = (displacement - mDisplacementShift) < 0;
|
|
if (progress <= 0) {
|
|
if (reinitCurrentAnimation(false, isDragTowardPositive)) {
|
|
mDisplacementShift = displacement;
|
|
mBlockFling = mCanBlockFling;
|
|
}
|
|
} else if (progress >= 1) {
|
|
if (reinitCurrentAnimation(true, isDragTowardPositive)) {
|
|
mDisplacementShift = displacement;
|
|
mBlockFling = mCanBlockFling;
|
|
}
|
|
} else if (Math.abs(velocity) < SwipeDetector.RELEASE_VELOCITY_PX_MS) {
|
|
// We prevent flinging after passing a state, but allow it if the user pauses briefly.
|
|
mBlockFling = false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
protected void updateProgress(float fraction) {
|
|
mCurrentAnimation.setPlayFraction(fraction);
|
|
if (mAtomicComponentsController != null) {
|
|
mAtomicComponentsController.setPlayFraction(fraction - mAtomicComponentsStartProgress);
|
|
}
|
|
maybeUpdateAtomicAnim(mFromState, mToState, fraction);
|
|
}
|
|
|
|
/**
|
|
* When going between normal and overview states, see if we passed the overview threshold and
|
|
* play the appropriate atomic animation if so.
|
|
*/
|
|
private void maybeUpdateAtomicAnim(LauncherState fromState, LauncherState toState,
|
|
float progress) {
|
|
if (!goingBetweenNormalAndOverview(fromState, toState)) {
|
|
return;
|
|
}
|
|
float threshold = toState == OVERVIEW ? ATOMIC_OVERVIEW_ANIM_THRESHOLD
|
|
: 1f - ATOMIC_OVERVIEW_ANIM_THRESHOLD;
|
|
boolean passedThreshold = progress >= threshold;
|
|
if (passedThreshold != mPassedOverviewAtomicThreshold) {
|
|
LauncherState targetState = passedThreshold ? toState : fromState;
|
|
mPassedOverviewAtomicThreshold = passedThreshold;
|
|
if (mAtomicAnim != null) {
|
|
mAtomicAnim.cancel();
|
|
}
|
|
long duration = targetState == OVERVIEW ? ATOMIC_NORMAL_TO_OVERVIEW_DURATION
|
|
: ATOMIC_OVERVIEW_TO_NORMAL_DURATION;
|
|
mAtomicAnim = createAtomicAnimForState(targetState, duration);
|
|
mAtomicAnim.addListener(new AnimatorListenerAdapter() {
|
|
@Override
|
|
public void onAnimationEnd(Animator animation) {
|
|
mAtomicAnim = null;
|
|
}
|
|
});
|
|
mAtomicAnim.start();
|
|
mLauncher.getDragLayer().performHapticFeedback(HapticFeedbackConstants.CONTEXT_CLICK);
|
|
}
|
|
}
|
|
|
|
private AnimatorSet createAtomicAnimForState(LauncherState targetState, long duration) {
|
|
AnimatorSetBuilder builder = new AnimatorSetBuilder();
|
|
AnimationConfig config = new AnimationConfig();
|
|
config.animComponents = ATOMIC_COMPONENT;
|
|
config.duration = duration;
|
|
for (StateHandler handler : mLauncher.getStateManager().getStateHandlers()) {
|
|
handler.setStateWithAnimation(targetState, builder, config);
|
|
}
|
|
return builder.build();
|
|
}
|
|
|
|
@Override
|
|
public void onDragEnd(float velocity, boolean fling) {
|
|
final int logAction;
|
|
final LauncherState targetState;
|
|
final float progress = mCurrentAnimation.getProgressFraction();
|
|
|
|
boolean blockedFling = fling && mBlockFling;
|
|
if (blockedFling) {
|
|
fling = false;
|
|
}
|
|
|
|
if (fling) {
|
|
logAction = Touch.FLING;
|
|
targetState =
|
|
Float.compare(Math.signum(velocity), Math.signum(mProgressMultiplier)) == 0
|
|
? mToState : mFromState;
|
|
// snap to top or bottom using the release velocity
|
|
} else {
|
|
logAction = Touch.SWIPE;
|
|
targetState = (progress > SUCCESS_TRANSITION_PROGRESS) ? mToState : mFromState;
|
|
}
|
|
|
|
final float endProgress;
|
|
final float startProgress;
|
|
final long duration;
|
|
// Increase the duration if we prevented the fling, as we are going against a high velocity.
|
|
final long durationMultiplier = blockedFling && targetState == mFromState ? 6 : 1;
|
|
|
|
if (targetState == mToState) {
|
|
endProgress = 1;
|
|
if (progress >= 1) {
|
|
duration = 0;
|
|
startProgress = 1;
|
|
} else {
|
|
startProgress = Utilities.boundToRange(
|
|
progress + velocity * SINGLE_FRAME_MS * mProgressMultiplier, 0f, 1f);
|
|
duration = SwipeDetector.calculateDuration(velocity,
|
|
endProgress - Math.max(progress, 0)) * durationMultiplier;
|
|
}
|
|
} else {
|
|
// Let the state manager know that the animation didn't go to the target state,
|
|
// but don't cancel ourselves (we already clean up when the animation completes).
|
|
Runnable onCancel = mCurrentAnimation.getOnCancelRunnable();
|
|
mCurrentAnimation.setOnCancelRunnable(null);
|
|
mCurrentAnimation.dispatchOnCancel();
|
|
mCurrentAnimation.setOnCancelRunnable(onCancel);
|
|
|
|
endProgress = 0;
|
|
if (progress <= 0) {
|
|
duration = 0;
|
|
startProgress = 0;
|
|
} else {
|
|
startProgress = Utilities.boundToRange(
|
|
progress + velocity * SINGLE_FRAME_MS * mProgressMultiplier, 0f, 1f);
|
|
duration = SwipeDetector.calculateDuration(velocity,
|
|
Math.min(progress, 1) - endProgress) * durationMultiplier;
|
|
}
|
|
}
|
|
|
|
mCurrentAnimation.setEndAction(() -> onSwipeInteractionCompleted(targetState, logAction));
|
|
ValueAnimator anim = mCurrentAnimation.getAnimationPlayer();
|
|
anim.setFloatValues(startProgress, endProgress);
|
|
maybeUpdateAtomicAnim(mFromState, targetState, targetState == mToState ? 1f : 0f);
|
|
updateSwipeCompleteAnimation(anim, Math.max(duration, getRemainingAtomicDuration()),
|
|
targetState, velocity, fling);
|
|
mCurrentAnimation.dispatchOnStart();
|
|
anim.start();
|
|
if (mAtomicAnim == null) {
|
|
startAtomicComponentsAnim(endProgress, anim.getDuration());
|
|
} else {
|
|
mAtomicAnim.addListener(new AnimationSuccessListener() {
|
|
@Override
|
|
public void onAnimationSuccess(Animator animator) {
|
|
startAtomicComponentsAnim(endProgress, anim.getDuration());
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Animates the atomic components from the current progress to the final progress.
|
|
*
|
|
* Note that this only applies when we are controlling the atomic components separately from
|
|
* the non-atomic components, which only happens if we reinit before the atomic animation
|
|
* finishes.
|
|
*/
|
|
private void startAtomicComponentsAnim(float toProgress, long duration) {
|
|
if (mAtomicComponentsController != null) {
|
|
ValueAnimator atomicAnim = mAtomicComponentsController.getAnimationPlayer();
|
|
atomicAnim.setFloatValues(mAtomicComponentsController.getProgressFraction(), toProgress);
|
|
atomicAnim.setDuration(duration);
|
|
atomicAnim.start();
|
|
atomicAnim.addListener(new AnimatorListenerAdapter() {
|
|
@Override
|
|
public void onAnimationEnd(Animator animation) {
|
|
mAtomicComponentsController = null;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
private long getRemainingAtomicDuration() {
|
|
if (mAtomicAnim == null) {
|
|
return 0;
|
|
}
|
|
if (Utilities.ATLEAST_OREO) {
|
|
return mAtomicAnim.getTotalDuration() - mAtomicAnim.getCurrentPlayTime();
|
|
} else {
|
|
long remainingDuration = 0;
|
|
for (Animator anim : mAtomicAnim.getChildAnimations()) {
|
|
remainingDuration = Math.max(remainingDuration, anim.getDuration());
|
|
}
|
|
return remainingDuration;
|
|
}
|
|
}
|
|
|
|
protected void updateSwipeCompleteAnimation(ValueAnimator animator, long expectedDuration,
|
|
LauncherState targetState, float velocity, boolean isFling) {
|
|
animator.setDuration(expectedDuration)
|
|
.setInterpolator(scrollInterpolatorForVelocity(velocity));
|
|
}
|
|
|
|
protected int getDirectionForLog() {
|
|
return mToState.ordinal > mFromState.ordinal ? Direction.UP : Direction.DOWN;
|
|
}
|
|
|
|
protected void onSwipeInteractionCompleted(LauncherState targetState, int logAction) {
|
|
clearState();
|
|
boolean shouldGoToTargetState = true;
|
|
if (mPendingAnimation != null) {
|
|
boolean reachedTarget = mToState == targetState;
|
|
mPendingAnimation.finish(reachedTarget, logAction);
|
|
mPendingAnimation = null;
|
|
shouldGoToTargetState = !reachedTarget;
|
|
}
|
|
if (shouldGoToTargetState) {
|
|
if (targetState != mFromState) {
|
|
logReachedState(logAction);
|
|
}
|
|
mLauncher.getStateManager().goToState(targetState, false /* animated */);
|
|
}
|
|
}
|
|
|
|
private void logReachedState(int logAction) {
|
|
// Transition complete. log the action
|
|
mLauncher.getUserEventDispatcher().logStateChangeAction(logAction,
|
|
getDirectionForLog(),
|
|
mStartContainerType,
|
|
mFromState.containerType,
|
|
mToState.containerType,
|
|
mLauncher.getWorkspace().getCurrentPage());
|
|
}
|
|
|
|
protected void clearState() {
|
|
mCurrentAnimation = null;
|
|
cancelAtomicComponentsController();
|
|
mDetector.finishedScrolling();
|
|
mDetector.setDetectableScrollConditions(0, false);
|
|
}
|
|
|
|
private void cancelAtomicComponentsController() {
|
|
if (mAtomicComponentsController != null) {
|
|
mAtomicComponentsController.getAnimationPlayer().cancel();
|
|
mAtomicComponentsController = null;
|
|
}
|
|
}
|
|
}
|