520 lines
21 KiB
Java
520 lines
21 KiB
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, false /* 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);
|
|
}
|
|
}
|
|
}
|
|
}
|