mirror of
https://github.com/LawnchairLauncher/lawnchair.git
synced 2026-03-03 09:26:51 +00:00
333 lines
14 KiB
Java
333 lines
14 KiB
Java
/*
|
|
* Copyright (C) 2018 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.touchcontrollers;
|
|
|
|
import static com.android.launcher3.AbstractFloatingView.TYPE_ACCESSIBLE;
|
|
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.AnimatorSetBuilder.ANIM_ALL_APPS_FADE;
|
|
import static com.android.launcher3.anim.AnimatorSetBuilder.ANIM_OVERVIEW_FADE;
|
|
import static com.android.launcher3.anim.AnimatorSetBuilder.ANIM_VERTICAL_PROGRESS;
|
|
import static com.android.launcher3.anim.Interpolators.ACCEL;
|
|
import static com.android.launcher3.anim.Interpolators.DEACCEL;
|
|
import static com.android.launcher3.anim.Interpolators.LINEAR;
|
|
import static com.android.launcher3.config.FeatureFlags.UNSTABLE_SPRINGS;
|
|
import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_OVERVIEW_DISABLED;
|
|
|
|
import android.animation.TimeInterpolator;
|
|
import android.animation.ValueAnimator;
|
|
import android.view.MotionEvent;
|
|
import android.view.animation.Interpolator;
|
|
|
|
import com.android.launcher3.AbstractFloatingView;
|
|
import com.android.launcher3.DeviceProfile;
|
|
import com.android.launcher3.Launcher;
|
|
import com.android.launcher3.LauncherState;
|
|
import com.android.launcher3.LauncherStateManager.AnimationComponents;
|
|
import com.android.launcher3.allapps.AllAppsTransitionController;
|
|
import com.android.launcher3.anim.AnimatorPlaybackController;
|
|
import com.android.launcher3.anim.AnimatorSetBuilder;
|
|
import com.android.launcher3.anim.Interpolators;
|
|
import com.android.launcher3.touch.AbstractStateChangeTouchController;
|
|
import com.android.launcher3.touch.SingleAxisSwipeDetector;
|
|
import com.android.launcher3.uioverrides.states.OverviewState;
|
|
import com.android.launcher3.userevent.nano.LauncherLogProto.Action.Touch;
|
|
import com.android.launcher3.userevent.nano.LauncherLogProto.ContainerType;
|
|
import com.android.quickstep.SystemUiProxy;
|
|
import com.android.quickstep.TouchInteractionService;
|
|
import com.android.quickstep.util.LayoutUtils;
|
|
|
|
/**
|
|
* Touch controller for handling various state transitions in portrait UI.
|
|
*/
|
|
public class PortraitStatesTouchController extends AbstractStateChangeTouchController {
|
|
|
|
private static final String TAG = "PortraitStatesTouchCtrl";
|
|
|
|
/**
|
|
* The progress at which all apps content will be fully visible when swiping up from overview.
|
|
*/
|
|
protected static final float ALL_APPS_CONTENT_FADE_THRESHOLD = 0.08f;
|
|
|
|
/**
|
|
* The progress at which recents will begin fading out when swiping up from overview.
|
|
*/
|
|
private static final float RECENTS_FADE_THRESHOLD = 0.88f;
|
|
|
|
private final PortraitOverviewStateTouchHelper mOverviewPortraitStateTouchHelper;
|
|
|
|
private final InterpolatorWrapper mAllAppsInterpolatorWrapper = new InterpolatorWrapper();
|
|
|
|
private final boolean mAllowDragToOverview;
|
|
|
|
// If true, we will finish the current animation instantly on second touch.
|
|
private boolean mFinishFastOnSecondTouch;
|
|
|
|
public PortraitStatesTouchController(Launcher l, boolean allowDragToOverview) {
|
|
super(l, SingleAxisSwipeDetector.VERTICAL);
|
|
mOverviewPortraitStateTouchHelper = new PortraitOverviewStateTouchHelper(l);
|
|
mAllowDragToOverview = allowDragToOverview;
|
|
}
|
|
|
|
@Override
|
|
protected boolean canInterceptTouch(MotionEvent ev) {
|
|
if (mCurrentAnimation != null) {
|
|
if (mFinishFastOnSecondTouch) {
|
|
// TODO: Animate to finish instead.
|
|
mCurrentAnimation.skipToEnd();
|
|
}
|
|
|
|
AllAppsTransitionController allAppsController = mLauncher.getAllAppsController();
|
|
if (ev.getY() >= allAppsController.getShiftRange() * allAppsController.getProgress()) {
|
|
// If we are already animating from a previous state, we can intercept as long as
|
|
// the touch is below the current all apps progress (to allow for double swipe).
|
|
return true;
|
|
}
|
|
// Otherwise, make sure everything is settled and don't intercept so they can scroll
|
|
// recents, dismiss a task, etc.
|
|
if (mAtomicAnim != null) {
|
|
mAtomicAnim.end();
|
|
}
|
|
return false;
|
|
}
|
|
if (mLauncher.isInState(ALL_APPS)) {
|
|
// In all-apps only listen if the container cannot scroll itself
|
|
if (!mLauncher.getAppsView().shouldContainerScroll(ev)) {
|
|
return false;
|
|
}
|
|
} else if (mLauncher.isInState(OVERVIEW)) {
|
|
if (!mOverviewPortraitStateTouchHelper.canInterceptTouch(ev)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
// If we are swiping to all apps instead of overview, allow it from anywhere.
|
|
boolean interceptAnywhere = mLauncher.isInState(NORMAL) && !mAllowDragToOverview;
|
|
// For all other states, only listen if the event originated below the hotseat height
|
|
if (!interceptAnywhere && !isTouchOverHotseat(mLauncher, ev)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (AbstractFloatingView.getTopOpenViewWithType(mLauncher, TYPE_ACCESSIBLE) != null) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
protected LauncherState getTargetState(LauncherState fromState, boolean isDragTowardPositive) {
|
|
if (fromState == ALL_APPS && !isDragTowardPositive) {
|
|
// Should swipe down go to OVERVIEW instead?
|
|
return TouchInteractionService.isConnected() ?
|
|
mLauncher.getStateManager().getLastState() : NORMAL;
|
|
} else if (fromState == OVERVIEW) {
|
|
return isDragTowardPositive ? ALL_APPS : NORMAL;
|
|
} else if (fromState == NORMAL && isDragTowardPositive) {
|
|
int stateFlags = SystemUiProxy.INSTANCE.get(mLauncher).getLastSystemUiStateFlags();
|
|
return mAllowDragToOverview && TouchInteractionService.isConnected()
|
|
&& (stateFlags & SYSUI_STATE_OVERVIEW_DISABLED) == 0
|
|
? OVERVIEW : ALL_APPS;
|
|
}
|
|
return fromState;
|
|
}
|
|
|
|
@Override
|
|
protected int getLogContainerTypeForNormalState(MotionEvent ev) {
|
|
return isTouchOverHotseat(mLauncher, ev) ? ContainerType.HOTSEAT : ContainerType.WORKSPACE;
|
|
}
|
|
|
|
private AnimatorSetBuilder getNormalToOverviewAnimation() {
|
|
mAllAppsInterpolatorWrapper.baseInterpolator = LINEAR;
|
|
|
|
AnimatorSetBuilder builder = new AnimatorSetBuilder();
|
|
builder.setInterpolator(ANIM_VERTICAL_PROGRESS, mAllAppsInterpolatorWrapper);
|
|
return builder;
|
|
}
|
|
|
|
public static AnimatorSetBuilder getOverviewToAllAppsAnimation() {
|
|
AnimatorSetBuilder builder = new AnimatorSetBuilder();
|
|
builder.setInterpolator(ANIM_ALL_APPS_FADE, Interpolators.clampToProgress(ACCEL,
|
|
0, ALL_APPS_CONTENT_FADE_THRESHOLD));
|
|
builder.setInterpolator(ANIM_OVERVIEW_FADE, Interpolators.clampToProgress(DEACCEL,
|
|
RECENTS_FADE_THRESHOLD, 1));
|
|
return builder;
|
|
}
|
|
|
|
private AnimatorSetBuilder getAllAppsToOverviewAnimation() {
|
|
AnimatorSetBuilder builder = new AnimatorSetBuilder();
|
|
builder.setInterpolator(ANIM_ALL_APPS_FADE, Interpolators.clampToProgress(DEACCEL,
|
|
1 - ALL_APPS_CONTENT_FADE_THRESHOLD, 1));
|
|
builder.setInterpolator(ANIM_OVERVIEW_FADE, Interpolators.clampToProgress(ACCEL,
|
|
0f, 1 - RECENTS_FADE_THRESHOLD));
|
|
return builder;
|
|
}
|
|
|
|
private AnimatorSetBuilder getNormalToAllAppsAnimation() {
|
|
AnimatorSetBuilder builder = new AnimatorSetBuilder();
|
|
builder.setInterpolator(ANIM_ALL_APPS_FADE, Interpolators.clampToProgress(ACCEL,
|
|
0, ALL_APPS_CONTENT_FADE_THRESHOLD));
|
|
return builder;
|
|
}
|
|
|
|
private AnimatorSetBuilder getAllAppsToNormalAnimation() {
|
|
AnimatorSetBuilder builder = new AnimatorSetBuilder();
|
|
builder.setInterpolator(ANIM_ALL_APPS_FADE, Interpolators.clampToProgress(DEACCEL,
|
|
1 - ALL_APPS_CONTENT_FADE_THRESHOLD, 1));
|
|
return builder;
|
|
}
|
|
|
|
@Override
|
|
protected AnimatorSetBuilder getAnimatorSetBuilderForStates(LauncherState fromState,
|
|
LauncherState toState) {
|
|
AnimatorSetBuilder builder = new AnimatorSetBuilder();
|
|
if (fromState == NORMAL && toState == OVERVIEW) {
|
|
builder = getNormalToOverviewAnimation();
|
|
} else if (fromState == OVERVIEW && toState == ALL_APPS) {
|
|
builder = getOverviewToAllAppsAnimation();
|
|
} else if (fromState == ALL_APPS && toState == OVERVIEW) {
|
|
builder = getAllAppsToOverviewAnimation();
|
|
} else if (fromState == NORMAL && toState == ALL_APPS) {
|
|
builder = getNormalToAllAppsAnimation();
|
|
} else if (fromState == ALL_APPS && toState == NORMAL) {
|
|
builder = getAllAppsToNormalAnimation();
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
@Override
|
|
protected float initCurrentAnimation(@AnimationComponents int animComponents) {
|
|
float range = getShiftRange();
|
|
long maxAccuracy = (long) (2 * range);
|
|
|
|
float startVerticalShift = mFromState.getVerticalProgress(mLauncher) * range;
|
|
float endVerticalShift = mToState.getVerticalProgress(mLauncher) * range;
|
|
|
|
float totalShift = endVerticalShift - startVerticalShift;
|
|
|
|
final AnimatorSetBuilder builder = totalShift == 0 ? new AnimatorSetBuilder()
|
|
: getAnimatorSetBuilderForStates(mFromState, mToState);
|
|
updateAnimatorBuilderOnReinit(builder);
|
|
|
|
cancelPendingAnim();
|
|
|
|
if (mFromState == OVERVIEW && mToState == NORMAL
|
|
&& mOverviewPortraitStateTouchHelper.shouldSwipeDownReturnToApp()) {
|
|
// Reset the state manager, when changing the interaction mode
|
|
mLauncher.getStateManager().goToState(OVERVIEW, false /* animate */);
|
|
mPendingAnimation = mOverviewPortraitStateTouchHelper
|
|
.createSwipeDownToTaskAppAnimation(maxAccuracy);
|
|
mPendingAnimation.anim.setInterpolator(Interpolators.LINEAR);
|
|
|
|
Runnable onCancelRunnable = () -> {
|
|
cancelPendingAnim();
|
|
clearState();
|
|
};
|
|
mCurrentAnimation = AnimatorPlaybackController.wrap(mPendingAnimation.anim, maxAccuracy,
|
|
onCancelRunnable);
|
|
mLauncher.getStateManager().setCurrentUserControlledAnimation(mCurrentAnimation);
|
|
totalShift = LayoutUtils.getShelfTrackingDistance(mLauncher,
|
|
mLauncher.getDeviceProfile());
|
|
} else {
|
|
mCurrentAnimation = mLauncher.getStateManager()
|
|
.createAnimationToNewWorkspace(mToState, builder, maxAccuracy, this::clearState,
|
|
animComponents);
|
|
}
|
|
|
|
if (totalShift == 0) {
|
|
totalShift = Math.signum(mFromState.ordinal - mToState.ordinal)
|
|
* OverviewState.getDefaultSwipeHeight(mLauncher);
|
|
}
|
|
return 1 / totalShift;
|
|
}
|
|
|
|
/**
|
|
* Give subclasses the chance to update the animation when we re-initialize towards a new state.
|
|
*/
|
|
protected void updateAnimatorBuilderOnReinit(AnimatorSetBuilder builder) {
|
|
}
|
|
|
|
private void cancelPendingAnim() {
|
|
if (mPendingAnimation != null) {
|
|
mPendingAnimation.finish(false, Touch.SWIPE);
|
|
mPendingAnimation = null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void updateSwipeCompleteAnimation(ValueAnimator animator, long expectedDuration,
|
|
LauncherState targetState, float velocity, boolean isFling) {
|
|
super.updateSwipeCompleteAnimation(animator, expectedDuration, targetState,
|
|
velocity, isFling);
|
|
handleFirstSwipeToOverview(animator, expectedDuration, targetState, velocity, isFling);
|
|
}
|
|
|
|
private void handleFirstSwipeToOverview(final ValueAnimator animator,
|
|
final long expectedDuration, final LauncherState targetState, final float velocity,
|
|
final boolean isFling) {
|
|
if (UNSTABLE_SPRINGS.get() && mFromState == OVERVIEW && mToState == ALL_APPS
|
|
&& targetState == OVERVIEW) {
|
|
mFinishFastOnSecondTouch = true;
|
|
} else if (mFromState == NORMAL && mToState == OVERVIEW && targetState == OVERVIEW) {
|
|
mFinishFastOnSecondTouch = true;
|
|
if (isFling && expectedDuration != 0) {
|
|
// Update all apps interpolator to add a bit of overshoot starting from currFraction
|
|
final float currFraction = mCurrentAnimation.getProgressFraction();
|
|
mAllAppsInterpolatorWrapper.baseInterpolator = Interpolators.clampToProgress(
|
|
Interpolators.overshootInterpolatorForVelocity(velocity), currFraction, 1);
|
|
animator.setDuration(Math.min(expectedDuration, ATOMIC_DURATION))
|
|
.setInterpolator(LINEAR);
|
|
}
|
|
} else {
|
|
mFinishFastOnSecondTouch = false;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void onSwipeInteractionCompleted(LauncherState targetState, int logAction) {
|
|
super.onSwipeInteractionCompleted(targetState, logAction);
|
|
if (mStartState == NORMAL && targetState == OVERVIEW) {
|
|
SystemUiProxy.INSTANCE.get(mLauncher).onOverviewShown(true, TAG);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Whether the motion event is over the hotseat.
|
|
*
|
|
* @param launcher the launcher activity
|
|
* @param ev the event to check
|
|
* @return true if the event is over the hotseat
|
|
*/
|
|
static boolean isTouchOverHotseat(Launcher launcher, MotionEvent ev) {
|
|
return (ev.getY() >= getHotseatTop(launcher));
|
|
}
|
|
|
|
public static int getHotseatTop(Launcher launcher) {
|
|
DeviceProfile dp = launcher.getDeviceProfile();
|
|
int hotseatHeight = dp.hotseatBarSizePx + dp.getInsets().bottom;
|
|
return launcher.getDragLayer().getHeight() - hotseatHeight;
|
|
}
|
|
|
|
private static class InterpolatorWrapper implements Interpolator {
|
|
|
|
public TimeInterpolator baseInterpolator = LINEAR;
|
|
|
|
@Override
|
|
public float getInterpolation(float v) {
|
|
return baseInterpolator.getInterpolation(v);
|
|
}
|
|
}
|
|
}
|