content: /*
   * 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 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.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 static com.android.launcher3.AbstractFloatingView.TYPE_ACCESSIBLE;
  import static com.android.launcher3.LauncherState.*;
  import static com.android.launcher3.anim.AnimatorSetBuilder.*;
  import static com.android.launcher3.anim.Interpolators.*;
  import static com.android.launcher3.config.FeatureFlags.QUICKSTEP_SPRINGS;
  
  /**
   * 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 InterpolatorWrapper mAllAppsInterpolatorWrapper = new InterpolatorWrapper();
  
      private final boolean mAllowDragToOverview;
  
      // If true, we will finish the current animation instantly on second touch.
      private boolean mFinishFastOnSecondTouch;
  
      private boolean mBlockTouch;
  
      public PortraitStatesTouchController(Launcher l, boolean allowDragToOverview) {
          super(l, SingleAxisSwipeDetector.VERTICAL);
          mAllowDragToOverview = allowDragToOverview;
      }
  
      protected void setBlockTouch(boolean blockTouch) {
          mBlockTouch = blockTouch;
      }
  
      @Override
      protected boolean canInterceptTouch(MotionEvent ev) {
          if (mBlockTouch) {
              return false;
          }
          if (mCurrentAnimation != null) {
              if (mFinishFastOnSecondTouch) {
                  // TODO: Animate to finish instead.
                  mCurrentAnimation.skipToEnd();
              }
  
              // If we are already animating from a previous state, we can intercept.
              return true;
          }
          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 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) {
              return mLauncher.getStateManager().getLastState();
          } else if (fromState == OVERVIEW) {
              return isDragTowardPositive ? ALL_APPS : NORMAL;
          } else if (fromState == NORMAL && isDragTowardPositive) {
              return mAllowDragToOverview ? 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,
                  0, 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();
  
          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 (QUICKSTEP_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) {
              mLauncher.getStateManager().goToState(NORMAL, true /* animate */);
          }
      }
  
      /**
       * 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);
          }
      }
  }
  