Home | History | Annotate | Download | only in stackdivider 
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.systemui.stackdivider;
     18 
     19 import static android.view.PointerIcon.TYPE_HORIZONTAL_DOUBLE_ARROW;
     20 import static android.view.PointerIcon.TYPE_VERTICAL_DOUBLE_ARROW;
     21 
     22 import android.animation.Animator;
     23 import android.animation.AnimatorListenerAdapter;
     24 import android.animation.ValueAnimator;
     25 import android.annotation.Nullable;
     26 import android.app.ActivityManager.StackId;
     27 import android.content.Context;
     28 import android.content.res.Configuration;
     29 import android.graphics.Rect;
     30 import android.graphics.Region.Op;
     31 import android.hardware.display.DisplayManager;
     32 import android.os.Bundle;
     33 import android.os.Handler;
     34 import android.os.Message;
     35 import android.util.AttributeSet;
     36 import android.view.Choreographer;
     37 import android.view.Display;
     38 import android.view.DisplayInfo;
     39 import android.view.GestureDetector;
     40 import android.view.GestureDetector.SimpleOnGestureListener;
     41 import android.view.MotionEvent;
     42 import android.view.PointerIcon;
     43 import android.view.VelocityTracker;
     44 import android.view.View;
     45 import android.view.View.OnTouchListener;
     46 import android.view.ViewConfiguration;
     47 import android.view.ViewTreeObserver.InternalInsetsInfo;
     48 import android.view.ViewTreeObserver.OnComputeInternalInsetsListener;
     49 import android.view.WindowInsets;
     50 import android.view.WindowManager;
     51 import android.view.accessibility.AccessibilityNodeInfo;
     52 import android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction;
     53 import android.view.animation.Interpolator;
     54 import android.view.animation.PathInterpolator;
     55 import android.widget.FrameLayout;
     56 
     57 import com.android.internal.logging.MetricsLogger;
     58 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
     59 import com.android.internal.policy.DividerSnapAlgorithm;
     60 import com.android.internal.policy.DividerSnapAlgorithm.SnapTarget;
     61 import com.android.internal.policy.DockedDividerUtils;
     62 import com.android.internal.view.SurfaceFlingerVsyncChoreographer;
     63 import com.android.systemui.Interpolators;
     64 import com.android.systemui.R;
     65 import com.android.systemui.recents.Recents;
     66 import com.android.systemui.recents.events.EventBus;
     67 import com.android.systemui.recents.events.activity.DockedFirstAnimationFrameEvent;
     68 import com.android.systemui.recents.events.activity.DockedTopTaskEvent;
     69 import com.android.systemui.recents.events.activity.RecentsActivityStartingEvent;
     70 import com.android.systemui.recents.events.activity.UndockingTaskEvent;
     71 import com.android.systemui.recents.events.ui.RecentsGrowingEvent;
     72 import com.android.systemui.recents.misc.SystemServicesProxy;
     73 import com.android.systemui.stackdivider.events.StartedDragingEvent;
     74 import com.android.systemui.stackdivider.events.StoppedDragingEvent;
     75 import com.android.systemui.statusbar.FlingAnimationUtils;
     76 import com.android.systemui.statusbar.phone.NavigationBarGestureHelper;
     77 
     78 /**
     79  * Docked stack divider.
     80  */
     81 public class DividerView extends FrameLayout implements OnTouchListener,
     82         OnComputeInternalInsetsListener {
     83 
     84     static final long TOUCH_ANIMATION_DURATION = 150;
     85     static final long TOUCH_RELEASE_ANIMATION_DURATION = 200;
     86 
     87     public static final int INVALID_RECENTS_GROW_TARGET = -1;
     88 
     89     private static final int LOG_VALUE_RESIZE_50_50 = 0;
     90     private static final int LOG_VALUE_RESIZE_DOCKED_SMALLER = 1;
     91     private static final int LOG_VALUE_RESIZE_DOCKED_LARGER = 2;
     92 
     93     private static final int LOG_VALUE_UNDOCK_MAX_DOCKED = 0;
     94     private static final int LOG_VALUE_UNDOCK_MAX_OTHER = 1;
     95 
     96     private static final int TASK_POSITION_SAME = Integer.MAX_VALUE;
     97     private static final boolean SWAPPING_ENABLED = false;
     98 
     99     /**
    100      * How much the background gets scaled when we are in the minimized dock state.
    101      */
    102     private static final float MINIMIZE_DOCK_SCALE = 0f;
    103     private static final float ADJUSTED_FOR_IME_SCALE = 0.5f;
    104 
    105     private static final PathInterpolator SLOWDOWN_INTERPOLATOR =
    106             new PathInterpolator(0.5f, 1f, 0.5f, 1f);
    107     private static final PathInterpolator DIM_INTERPOLATOR =
    108             new PathInterpolator(.23f, .87f, .52f, -0.11f);
    109     private static final Interpolator IME_ADJUST_INTERPOLATOR =
    110             new PathInterpolator(0.2f, 0f, 0.1f, 1f);
    111 
    112     private static final int MSG_RESIZE_STACK = 0;
    113 
    114     private DividerHandleView mHandle;
    115     private View mBackground;
    116     private MinimizedDockShadow mMinimizedShadow;
    117     private int mStartX;
    118     private int mStartY;
    119     private int mStartPosition;
    120     private int mDockSide;
    121     private final int[] mTempInt2 = new int[2];
    122     private boolean mMoving;
    123     private int mTouchSlop;
    124     private boolean mBackgroundLifted;
    125     private boolean mIsInMinimizeInteraction;
    126     private SnapTarget mSnapTargetBeforeMinimized;
    127 
    128     private int mDividerInsets;
    129     private int mDisplayWidth;
    130     private int mDisplayHeight;
    131     private int mDividerWindowWidth;
    132     private int mDividerSize;
    133     private int mTouchElevation;
    134     private int mLongPressEntraceAnimDuration;
    135 
    136     private final Rect mDockedRect = new Rect();
    137     private final Rect mDockedTaskRect = new Rect();
    138     private final Rect mOtherTaskRect = new Rect();
    139     private final Rect mOtherRect = new Rect();
    140     private final Rect mDockedInsetRect = new Rect();
    141     private final Rect mOtherInsetRect = new Rect();
    142     private final Rect mLastResizeRect = new Rect();
    143     private final Rect mDisplayRect = new Rect();
    144     private final WindowManagerProxy mWindowManagerProxy = WindowManagerProxy.getInstance();
    145     private DividerWindowManager mWindowManager;
    146     private VelocityTracker mVelocityTracker;
    147     private FlingAnimationUtils mFlingAnimationUtils;
    148     private DividerSnapAlgorithm mSnapAlgorithm;
    149     private DividerSnapAlgorithm mMinimizedSnapAlgorithm;
    150     private final Rect mStableInsets = new Rect();
    151 
    152     private boolean mGrowRecents;
    153     private ValueAnimator mCurrentAnimator;
    154     private boolean mEntranceAnimationRunning;
    155     private boolean mExitAnimationRunning;
    156     private int mExitStartPosition;
    157     private GestureDetector mGestureDetector;
    158     private boolean mDockedStackMinimized;
    159     private boolean mHomeStackResizable;
    160     private boolean mAdjustedForIme;
    161     private DividerState mState;
    162     private final SurfaceFlingerVsyncChoreographer mSfChoreographer;
    163 
    164     // The view is removed or in the process of been removed from the system.
    165     private boolean mRemoved;
    166 
    167     private final Handler mHandler = new Handler() {
    168         @Override
    169         public void handleMessage(Message msg) {
    170             switch (msg.what) {
    171                 case MSG_RESIZE_STACK:
    172                     resizeStack(msg.arg1, msg.arg2, (SnapTarget) msg.obj);
    173                     break;
    174                 default:
    175                     super.handleMessage(msg);
    176             }
    177         }
    178     };
    179 
    180     private final AccessibilityDelegate mHandleDelegate = new AccessibilityDelegate() {
    181         @Override
    182         public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfo info) {
    183             super.onInitializeAccessibilityNodeInfo(host, info);
    184             if (isHorizontalDivision()) {
    185                 info.addAction(new AccessibilityAction(R.id.action_move_tl_full,
    186                         mContext.getString(R.string.accessibility_action_divider_top_full)));
    187                 if (mSnapAlgorithm.isFirstSplitTargetAvailable()) {
    188                     info.addAction(new AccessibilityAction(R.id.action_move_tl_70,
    189                             mContext.getString(R.string.accessibility_action_divider_top_70)));
    190                 }
    191                 info.addAction(new AccessibilityAction(R.id.action_move_tl_50,
    192                         mContext.getString(R.string.accessibility_action_divider_top_50)));
    193                 if (mSnapAlgorithm.isLastSplitTargetAvailable()) {
    194                     info.addAction(new AccessibilityAction(R.id.action_move_tl_30,
    195                             mContext.getString(R.string.accessibility_action_divider_top_30)));
    196                 }
    197                 info.addAction(new AccessibilityAction(R.id.action_move_rb_full,
    198                         mContext.getString(R.string.accessibility_action_divider_bottom_full)));
    199             } else {
    200                 info.addAction(new AccessibilityAction(R.id.action_move_tl_full,
    201                         mContext.getString(R.string.accessibility_action_divider_left_full)));
    202                 if (mSnapAlgorithm.isFirstSplitTargetAvailable()) {
    203                     info.addAction(new AccessibilityAction(R.id.action_move_tl_70,
    204                             mContext.getString(R.string.accessibility_action_divider_left_70)));
    205                 }
    206                 info.addAction(new AccessibilityAction(R.id.action_move_tl_50,
    207                         mContext.getString(R.string.accessibility_action_divider_left_50)));
    208                 if (mSnapAlgorithm.isLastSplitTargetAvailable()) {
    209                     info.addAction(new AccessibilityAction(R.id.action_move_tl_30,
    210                             mContext.getString(R.string.accessibility_action_divider_left_30)));
    211                 }
    212                 info.addAction(new AccessibilityAction(R.id.action_move_rb_full,
    213                         mContext.getString(R.string.accessibility_action_divider_right_full)));
    214             }
    215         }
    216 
    217         @Override
    218         public boolean performAccessibilityAction(View host, int action, Bundle args) {
    219             int currentPosition = getCurrentPosition();
    220             SnapTarget nextTarget = null;
    221             switch (action) {
    222                 case R.id.action_move_tl_full:
    223                     nextTarget = mSnapAlgorithm.getDismissEndTarget();
    224                     break;
    225                 case R.id.action_move_tl_70:
    226                     nextTarget = mSnapAlgorithm.getLastSplitTarget();
    227                     break;
    228                 case R.id.action_move_tl_50:
    229                     nextTarget = mSnapAlgorithm.getMiddleTarget();
    230                     break;
    231                 case R.id.action_move_tl_30:
    232                     nextTarget = mSnapAlgorithm.getFirstSplitTarget();
    233                     break;
    234                 case R.id.action_move_rb_full:
    235                     nextTarget = mSnapAlgorithm.getDismissStartTarget();
    236                     break;
    237             }
    238             if (nextTarget != null) {
    239                 startDragging(true /* animate */, false /* touching */);
    240                 stopDragging(currentPosition, nextTarget, 250, Interpolators.FAST_OUT_SLOW_IN);
    241                 return true;
    242             }
    243             return super.performAccessibilityAction(host, action, args);
    244         }
    245     };
    246 
    247     private final Runnable mResetBackgroundRunnable = new Runnable() {
    248         @Override
    249         public void run() {
    250             resetBackground();
    251         }
    252     };
    253 
    254     public DividerView(Context context) {
    255         this(context, null);
    256     }
    257 
    258     public DividerView(Context context, @Nullable AttributeSet attrs) {
    259         this(context, attrs, 0);
    260     }
    261 
    262     public DividerView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
    263         this(context, attrs, defStyleAttr, 0);
    264     }
    265 
    266     public DividerView(Context context, @Nullable AttributeSet attrs, int defStyleAttr,
    267             int defStyleRes) {
    268         super(context, attrs, defStyleAttr, defStyleRes);
    269         mSfChoreographer = new SurfaceFlingerVsyncChoreographer(mHandler, context.getDisplay(),
    270                 Choreographer.getInstance());
    271     }
    272 
    273     @Override
    274     protected void onFinishInflate() {
    275         super.onFinishInflate();
    276         mHandle = findViewById(R.id.docked_divider_handle);
    277         mBackground = findViewById(R.id.docked_divider_background);
    278         mMinimizedShadow = findViewById(R.id.minimized_dock_shadow);
    279         mHandle.setOnTouchListener(this);
    280         mDividerWindowWidth = getResources().getDimensionPixelSize(
    281                 com.android.internal.R.dimen.docked_stack_divider_thickness);
    282         mDividerInsets = getResources().getDimensionPixelSize(
    283                 com.android.internal.R.dimen.docked_stack_divider_insets);
    284         mDividerSize = mDividerWindowWidth - 2 * mDividerInsets;
    285         mTouchElevation = getResources().getDimensionPixelSize(
    286                 R.dimen.docked_stack_divider_lift_elevation);
    287         mLongPressEntraceAnimDuration = getResources().getInteger(
    288                 R.integer.long_press_dock_anim_duration);
    289         mGrowRecents = getResources().getBoolean(R.bool.recents_grow_in_multiwindow);
    290         mTouchSlop = ViewConfiguration.get(mContext).getScaledTouchSlop();
    291         mFlingAnimationUtils = new FlingAnimationUtils(getContext(), 0.3f);
    292         updateDisplayInfo();
    293         boolean landscape = getResources().getConfiguration().orientation
    294                 == Configuration.ORIENTATION_LANDSCAPE;
    295         mHandle.setPointerIcon(PointerIcon.getSystemIcon(getContext(),
    296                 landscape ? TYPE_HORIZONTAL_DOUBLE_ARROW : TYPE_VERTICAL_DOUBLE_ARROW));
    297         getViewTreeObserver().addOnComputeInternalInsetsListener(this);
    298         mHandle.setAccessibilityDelegate(mHandleDelegate);
    299         mGestureDetector = new GestureDetector(mContext, new SimpleOnGestureListener() {
    300             @Override
    301             public boolean onSingleTapUp(MotionEvent e) {
    302                 if (SWAPPING_ENABLED) {
    303                     updateDockSide();
    304                     SystemServicesProxy ssp = Recents.getSystemServices();
    305                     if (mDockSide != WindowManager.DOCKED_INVALID
    306                             && !ssp.isRecentsActivityVisible()) {
    307                         mWindowManagerProxy.swapTasks();
    308                         return true;
    309                     }
    310                 }
    311                 return false;
    312             }
    313         });
    314     }
    315 
    316     @Override
    317     protected void onAttachedToWindow() {
    318         super.onAttachedToWindow();
    319         EventBus.getDefault().register(this);
    320 
    321         // Save the current target if not minimized once attached to window
    322         if (mHomeStackResizable && mDockSide != WindowManager.DOCKED_INVALID
    323                 && !mIsInMinimizeInteraction) {
    324             saveSnapTargetBeforeMinimized(mSnapTargetBeforeMinimized);
    325         }
    326     }
    327 
    328     @Override
    329     protected void onDetachedFromWindow() {
    330         super.onDetachedFromWindow();
    331         EventBus.getDefault().unregister(this);
    332     }
    333 
    334     void onDividerRemoved() {
    335         mRemoved = true;
    336         mHandler.removeMessages(MSG_RESIZE_STACK);
    337     }
    338 
    339     @Override
    340     public WindowInsets onApplyWindowInsets(WindowInsets insets) {
    341         if (mStableInsets.left != insets.getStableInsetLeft()
    342                 || mStableInsets.top != insets.getStableInsetTop()
    343                 || mStableInsets.right != insets.getStableInsetRight()
    344                 || mStableInsets.bottom != insets.getStableInsetBottom()) {
    345             mStableInsets.set(insets.getStableInsetLeft(), insets.getStableInsetTop(),
    346                     insets.getStableInsetRight(), insets.getStableInsetBottom());
    347             if (mSnapAlgorithm != null || mMinimizedSnapAlgorithm != null) {
    348                 mSnapAlgorithm = null;
    349                 mMinimizedSnapAlgorithm = null;
    350                 initializeSnapAlgorithm();
    351             }
    352         }
    353         return super.onApplyWindowInsets(insets);
    354     }
    355 
    356     @Override
    357     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    358         super.onLayout(changed, left, top, right, bottom);
    359         int minimizeLeft = 0;
    360         int minimizeTop = 0;
    361         if (mDockSide == WindowManager.DOCKED_TOP) {
    362             minimizeTop = mBackground.getTop();
    363         } else if (mDockSide == WindowManager.DOCKED_LEFT) {
    364             minimizeLeft = mBackground.getLeft();
    365         } else if (mDockSide == WindowManager.DOCKED_RIGHT) {
    366             minimizeLeft = mBackground.getRight() - mMinimizedShadow.getWidth();
    367         }
    368         mMinimizedShadow.layout(minimizeLeft, minimizeTop,
    369                 minimizeLeft + mMinimizedShadow.getMeasuredWidth(),
    370                 minimizeTop + mMinimizedShadow.getMeasuredHeight());
    371         if (changed) {
    372             mWindowManagerProxy.setTouchRegion(new Rect(mHandle.getLeft(), mHandle.getTop(),
    373                     mHandle.getRight(), mHandle.getBottom()));
    374         }
    375     }
    376 
    377     public void injectDependencies(DividerWindowManager windowManager, DividerState dividerState) {
    378         mWindowManager = windowManager;
    379         mState = dividerState;
    380 
    381         // Set the previous position ratio before minimized state after attaching this divider
    382         if (mStableInsets.isEmpty()) {
    383             SystemServicesProxy.getInstance(mContext).getStableInsets(mStableInsets);
    384         }
    385         int position = (int) (mState.mRatioPositionBeforeMinimized *
    386                 (isHorizontalDivision() ? mDisplayHeight : mDisplayWidth));
    387         mSnapAlgorithm = null;
    388         initializeSnapAlgorithm();
    389 
    390         // Set the snap target before minimized but do not save until divider is attached and not
    391         // minimized because it does not know its minimized state yet.
    392         mSnapTargetBeforeMinimized = mSnapAlgorithm.calculateNonDismissingSnapTarget(position);
    393     }
    394 
    395     public WindowManagerProxy getWindowManagerProxy() {
    396         return mWindowManagerProxy;
    397     }
    398 
    399     public boolean startDragging(boolean animate, boolean touching) {
    400         cancelFlingAnimation();
    401         if (touching) {
    402             mHandle.setTouching(true, animate);
    403         }
    404         mDockSide = mWindowManagerProxy.getDockSide();
    405         initializeSnapAlgorithm();
    406         mWindowManagerProxy.setResizing(true);
    407         if (touching) {
    408             mWindowManager.setSlippery(false);
    409             liftBackground();
    410         }
    411         EventBus.getDefault().send(new StartedDragingEvent());
    412         return mDockSide != WindowManager.DOCKED_INVALID;
    413     }
    414 
    415     public void stopDragging(int position, float velocity, boolean avoidDismissStart,
    416             boolean logMetrics) {
    417         mHandle.setTouching(false, true /* animate */);
    418         fling(position, velocity, avoidDismissStart, logMetrics);
    419         mWindowManager.setSlippery(true);
    420         releaseBackground();
    421     }
    422 
    423     public void stopDragging(int position, SnapTarget target, long duration,
    424             Interpolator interpolator) {
    425         stopDragging(position, target, duration, 0 /* startDelay*/, 0 /* endDelay */, interpolator);
    426     }
    427 
    428     public void stopDragging(int position, SnapTarget target, long duration,
    429             Interpolator interpolator, long endDelay) {
    430         stopDragging(position, target, duration, 0 /* startDelay*/, endDelay, interpolator);
    431     }
    432 
    433     public void stopDragging(int position, SnapTarget target, long duration, long startDelay,
    434             long endDelay, Interpolator interpolator) {
    435         mHandle.setTouching(false, true /* animate */);
    436         flingTo(position, target, duration, startDelay, endDelay, interpolator);
    437         mWindowManager.setSlippery(true);
    438         releaseBackground();
    439     }
    440 
    441     private void stopDragging() {
    442         mHandle.setTouching(false, true /* animate */);
    443         mWindowManager.setSlippery(true);
    444         releaseBackground();
    445     }
    446 
    447     private void updateDockSide() {
    448         mDockSide = mWindowManagerProxy.getDockSide();
    449         mMinimizedShadow.setDockSide(mDockSide);
    450     }
    451 
    452     private void initializeSnapAlgorithm() {
    453         if (mSnapAlgorithm == null) {
    454             mSnapAlgorithm = new DividerSnapAlgorithm(getContext().getResources(), mDisplayWidth,
    455                     mDisplayHeight, mDividerSize, isHorizontalDivision(), mStableInsets);
    456         }
    457         if (mMinimizedSnapAlgorithm == null) {
    458             mMinimizedSnapAlgorithm = new DividerSnapAlgorithm(getContext().getResources(),
    459                     mDisplayWidth, mDisplayHeight, mDividerSize, isHorizontalDivision(),
    460                     mStableInsets, mDockedStackMinimized && mHomeStackResizable);
    461         }
    462     }
    463 
    464     public DividerSnapAlgorithm getSnapAlgorithm() {
    465         initializeSnapAlgorithm();
    466         return mDockedStackMinimized && mHomeStackResizable ? mMinimizedSnapAlgorithm :
    467                 mSnapAlgorithm;
    468     }
    469 
    470     public int getCurrentPosition() {
    471         getLocationOnScreen(mTempInt2);
    472         if (isHorizontalDivision()) {
    473             return mTempInt2[1] + mDividerInsets;
    474         } else {
    475             return mTempInt2[0] + mDividerInsets;
    476         }
    477     }
    478 
    479     @Override
    480     public boolean onTouch(View v, MotionEvent event) {
    481         convertToScreenCoordinates(event);
    482         mGestureDetector.onTouchEvent(event);
    483         final int action = event.getAction() & MotionEvent.ACTION_MASK;
    484         switch (action) {
    485             case MotionEvent.ACTION_DOWN:
    486                 mVelocityTracker = VelocityTracker.obtain();
    487                 mVelocityTracker.addMovement(event);
    488                 mStartX = (int) event.getX();
    489                 mStartY = (int) event.getY();
    490                 boolean result = startDragging(true /* animate */, true /* touching */);
    491                 if (!result) {
    492 
    493                     // Weren't able to start dragging successfully, so cancel it again.
    494                     stopDragging();
    495                 }
    496                 mStartPosition = getCurrentPosition();
    497                 mMoving = false;
    498                 return result;
    499             case MotionEvent.ACTION_MOVE:
    500                 mVelocityTracker.addMovement(event);
    501                 int x = (int) event.getX();
    502                 int y = (int) event.getY();
    503                 boolean exceededTouchSlop =
    504                         isHorizontalDivision() && Math.abs(y - mStartY) > mTouchSlop
    505                                 || (!isHorizontalDivision() && Math.abs(x - mStartX) > mTouchSlop);
    506                 if (!mMoving && exceededTouchSlop) {
    507                     mStartX = x;
    508                     mStartY = y;
    509                     mMoving = true;
    510                 }
    511                 if (mMoving && mDockSide != WindowManager.DOCKED_INVALID) {
    512                     SnapTarget snapTarget = getSnapAlgorithm().calculateSnapTarget(
    513                             mStartPosition, 0 /* velocity */, false /* hardDismiss */);
    514                     resizeStackDelayed(calculatePosition(x, y), mStartPosition, snapTarget);
    515                 }
    516                 break;
    517             case MotionEvent.ACTION_UP:
    518             case MotionEvent.ACTION_CANCEL:
    519                 mVelocityTracker.addMovement(event);
    520 
    521                 x = (int) event.getRawX();
    522                 y = (int) event.getRawY();
    523 
    524                 mVelocityTracker.computeCurrentVelocity(1000);
    525                 int position = calculatePosition(x, y);
    526                 stopDragging(position, isHorizontalDivision() ? mVelocityTracker.getYVelocity()
    527                         : mVelocityTracker.getXVelocity(), false /* avoidDismissStart */,
    528                         true /* log */);
    529                 mMoving = false;
    530                 break;
    531         }
    532         return true;
    533     }
    534 
    535     private void logResizeEvent(SnapTarget snapTarget) {
    536         if (snapTarget == mSnapAlgorithm.getDismissStartTarget()) {
    537             MetricsLogger.action(
    538                     mContext, MetricsEvent.ACTION_WINDOW_UNDOCK_MAX, dockSideTopLeft(mDockSide)
    539                             ? LOG_VALUE_UNDOCK_MAX_OTHER
    540                             : LOG_VALUE_UNDOCK_MAX_DOCKED);
    541         } else if (snapTarget == mSnapAlgorithm.getDismissEndTarget()) {
    542             MetricsLogger.action(
    543                     mContext, MetricsEvent.ACTION_WINDOW_UNDOCK_MAX, dockSideBottomRight(mDockSide)
    544                             ? LOG_VALUE_UNDOCK_MAX_OTHER
    545                             : LOG_VALUE_UNDOCK_MAX_DOCKED);
    546         } else if (snapTarget == mSnapAlgorithm.getMiddleTarget()) {
    547             MetricsLogger.action(mContext, MetricsEvent.ACTION_WINDOW_DOCK_RESIZE,
    548                     LOG_VALUE_RESIZE_50_50);
    549         } else if (snapTarget == mSnapAlgorithm.getFirstSplitTarget()) {
    550             MetricsLogger.action(mContext, MetricsEvent.ACTION_WINDOW_DOCK_RESIZE,
    551                     dockSideTopLeft(mDockSide)
    552                             ? LOG_VALUE_RESIZE_DOCKED_SMALLER
    553                             : LOG_VALUE_RESIZE_DOCKED_LARGER);
    554         } else if (snapTarget == mSnapAlgorithm.getLastSplitTarget()) {
    555             MetricsLogger.action(mContext, MetricsEvent.ACTION_WINDOW_DOCK_RESIZE,
    556                     dockSideTopLeft(mDockSide)
    557                             ? LOG_VALUE_RESIZE_DOCKED_LARGER
    558                             : LOG_VALUE_RESIZE_DOCKED_SMALLER);
    559         }
    560     }
    561 
    562     private void convertToScreenCoordinates(MotionEvent event) {
    563         event.setLocation(event.getRawX(), event.getRawY());
    564     }
    565 
    566     private void fling(int position, float velocity, boolean avoidDismissStart,
    567             boolean logMetrics) {
    568         DividerSnapAlgorithm currentSnapAlgorithm = getSnapAlgorithm();
    569         SnapTarget snapTarget = currentSnapAlgorithm.calculateSnapTarget(position, velocity);
    570         if (avoidDismissStart && snapTarget == currentSnapAlgorithm.getDismissStartTarget()) {
    571             snapTarget = currentSnapAlgorithm.getFirstSplitTarget();
    572         }
    573         if (logMetrics) {
    574             logResizeEvent(snapTarget);
    575         }
    576         ValueAnimator anim = getFlingAnimator(position, snapTarget, 0 /* endDelay */);
    577         mFlingAnimationUtils.apply(anim, position, snapTarget.position, velocity);
    578         anim.start();
    579     }
    580 
    581     private void flingTo(int position, SnapTarget target, long duration, long startDelay,
    582             long endDelay, Interpolator interpolator) {
    583         ValueAnimator anim = getFlingAnimator(position, target, endDelay);
    584         anim.setDuration(duration);
    585         anim.setStartDelay(startDelay);
    586         anim.setInterpolator(interpolator);
    587         anim.start();
    588     }
    589 
    590     private ValueAnimator getFlingAnimator(int position, final SnapTarget snapTarget,
    591             final long endDelay) {
    592         if (mCurrentAnimator != null) {
    593             cancelFlingAnimation();
    594             updateDockSide();
    595         }
    596         final boolean taskPositionSameAtEnd = snapTarget.flag == SnapTarget.FLAG_NONE;
    597         ValueAnimator anim = ValueAnimator.ofInt(position, snapTarget.position);
    598         anim.addUpdateListener(animation -> resizeStackDelayed((int) animation.getAnimatedValue(),
    599                 taskPositionSameAtEnd && animation.getAnimatedFraction() == 1f
    600                         ? TASK_POSITION_SAME
    601                         : snapTarget.taskPosition,
    602                 snapTarget));
    603         Runnable endAction = () -> {
    604             commitSnapFlags(snapTarget);
    605             mWindowManagerProxy.setResizing(false);
    606             updateDockSide();
    607             mCurrentAnimator = null;
    608             mEntranceAnimationRunning = false;
    609             mExitAnimationRunning = false;
    610             EventBus.getDefault().send(new StoppedDragingEvent());
    611 
    612             // Record last snap target the divider moved to
    613             if (mHomeStackResizable && !mIsInMinimizeInteraction) {
    614                 saveSnapTargetBeforeMinimized(snapTarget);
    615             }
    616         };
    617         Runnable notCancelledEndAction = () -> {
    618             // Reset minimized divider position after unminimized state animation finishes
    619             if (!mDockedStackMinimized && mIsInMinimizeInteraction) {
    620                 mIsInMinimizeInteraction = false;
    621             }
    622         };
    623         anim.addListener(new AnimatorListenerAdapter() {
    624 
    625             private boolean mCancelled;
    626 
    627             @Override
    628             public void onAnimationCancel(Animator animation) {
    629                 mHandler.removeMessages(MSG_RESIZE_STACK);
    630                 mCancelled = true;
    631             }
    632 
    633             @Override
    634             public void onAnimationEnd(Animator animation) {
    635                 long delay = 0;
    636                 if (endDelay != 0) {
    637                     delay = endDelay;
    638                 } else if (mCancelled) {
    639                     delay = 0;
    640                 } else if (mSfChoreographer.getSurfaceFlingerOffsetMs() > 0) {
    641                     delay = mSfChoreographer.getSurfaceFlingerOffsetMs();
    642                 }
    643                 if (delay == 0) {
    644                     if (!mCancelled) {
    645                         notCancelledEndAction.run();
    646                     }
    647                     endAction.run();
    648                 } else {
    649                     if (!mCancelled) {
    650                         mHandler.postDelayed(notCancelledEndAction, delay);
    651                     }
    652                     mHandler.postDelayed(endAction, delay);
    653                 }
    654             }
    655         });
    656         mCurrentAnimator = anim;
    657         return anim;
    658     }
    659 
    660     private void cancelFlingAnimation() {
    661         if (mCurrentAnimator != null) {
    662             mCurrentAnimator.cancel();
    663         }
    664     }
    665 
    666     private void commitSnapFlags(SnapTarget target) {
    667         if (target.flag == SnapTarget.FLAG_NONE) {
    668             return;
    669         }
    670         boolean dismissOrMaximize;
    671         if (target.flag == SnapTarget.FLAG_DISMISS_START) {
    672             dismissOrMaximize = mDockSide == WindowManager.DOCKED_LEFT
    673                     || mDockSide == WindowManager.DOCKED_TOP;
    674         } else {
    675             dismissOrMaximize = mDockSide == WindowManager.DOCKED_RIGHT
    676                     || mDockSide == WindowManager.DOCKED_BOTTOM;
    677         }
    678         if (dismissOrMaximize) {
    679             mWindowManagerProxy.dismissDockedStack();
    680         } else {
    681             mWindowManagerProxy.maximizeDockedStack();
    682         }
    683         mWindowManagerProxy.setResizeDimLayer(false, -1, 0f);
    684     }
    685 
    686     private void liftBackground() {
    687         if (mBackgroundLifted) {
    688             return;
    689         }
    690         if (isHorizontalDivision()) {
    691             mBackground.animate().scaleY(1.4f);
    692         } else {
    693             mBackground.animate().scaleX(1.4f);
    694         }
    695         mBackground.animate()
    696                 .setInterpolator(Interpolators.TOUCH_RESPONSE)
    697                 .setDuration(TOUCH_ANIMATION_DURATION)
    698                 .translationZ(mTouchElevation)
    699                 .start();
    700 
    701         // Lift handle as well so it doesn't get behind the background, even though it doesn't
    702         // cast shadow.
    703         mHandle.animate()
    704                 .setInterpolator(Interpolators.TOUCH_RESPONSE)
    705                 .setDuration(TOUCH_ANIMATION_DURATION)
    706                 .translationZ(mTouchElevation)
    707                 .start();
    708         mBackgroundLifted = true;
    709     }
    710 
    711     private void releaseBackground() {
    712         if (!mBackgroundLifted) {
    713             return;
    714         }
    715         mBackground.animate()
    716                 .setInterpolator(Interpolators.FAST_OUT_SLOW_IN)
    717                 .setDuration(TOUCH_RELEASE_ANIMATION_DURATION)
    718                 .translationZ(0)
    719                 .scaleX(1f)
    720                 .scaleY(1f)
    721                 .start();
    722         mHandle.animate()
    723                 .setInterpolator(Interpolators.FAST_OUT_SLOW_IN)
    724                 .setDuration(TOUCH_RELEASE_ANIMATION_DURATION)
    725                 .translationZ(0)
    726                 .start();
    727         mBackgroundLifted = false;
    728     }
    729 
    730 
    731     public void setMinimizedDockStack(boolean minimized, boolean isHomeStackResizable) {
    732         mHomeStackResizable = isHomeStackResizable;
    733         updateDockSide();
    734         if (!minimized) {
    735             resetBackground();
    736         } else if (!isHomeStackResizable) {
    737             if (mDockSide == WindowManager.DOCKED_TOP) {
    738                 mBackground.setPivotY(0);
    739                 mBackground.setScaleY(MINIMIZE_DOCK_SCALE);
    740             } else if (mDockSide == WindowManager.DOCKED_LEFT
    741                     || mDockSide == WindowManager.DOCKED_RIGHT) {
    742                 mBackground.setPivotX(mDockSide == WindowManager.DOCKED_LEFT
    743                         ? 0
    744                         : mBackground.getWidth());
    745                 mBackground.setScaleX(MINIMIZE_DOCK_SCALE);
    746             }
    747         }
    748         mMinimizedShadow.setAlpha(minimized ? 1f : 0f);
    749         if (!isHomeStackResizable) {
    750             mHandle.setAlpha(minimized ? 0f : 1f);
    751             mDockedStackMinimized = minimized;
    752         } else if (mDockedStackMinimized != minimized) {
    753             mMinimizedSnapAlgorithm = null;
    754             mDockedStackMinimized = minimized;
    755             initializeSnapAlgorithm();
    756             if (mIsInMinimizeInteraction != minimized) {
    757                 if (minimized) {
    758                     mIsInMinimizeInteraction = true;
    759                     resizeStack(mMinimizedSnapAlgorithm.getMiddleTarget());
    760                 } else {
    761                     resizeStack(mSnapTargetBeforeMinimized);
    762                     mIsInMinimizeInteraction = false;
    763                 }
    764             }
    765         }
    766     }
    767 
    768     public void setMinimizedDockStack(boolean minimized, long animDuration,
    769             boolean isHomeStackResizable) {
    770         mHomeStackResizable = isHomeStackResizable;
    771         updateDockSide();
    772         if (!isHomeStackResizable) {
    773             mMinimizedShadow.animate()
    774                     .alpha(minimized ? 1f : 0f)
    775                     .setInterpolator(Interpolators.ALPHA_IN)
    776                     .setDuration(animDuration)
    777                     .start();
    778             mHandle.animate()
    779                     .setInterpolator(Interpolators.FAST_OUT_SLOW_IN)
    780                     .setDuration(animDuration)
    781                     .alpha(minimized ? 0f : 1f)
    782                     .start();
    783             if (mDockSide == WindowManager.DOCKED_TOP) {
    784                 mBackground.setPivotY(0);
    785                 mBackground.animate()
    786                         .scaleY(minimized ? MINIMIZE_DOCK_SCALE : 1f);
    787             } else if (mDockSide == WindowManager.DOCKED_LEFT
    788                     || mDockSide == WindowManager.DOCKED_RIGHT) {
    789                 mBackground.setPivotX(mDockSide == WindowManager.DOCKED_LEFT
    790                         ? 0
    791                         : mBackground.getWidth());
    792                 mBackground.animate()
    793                         .scaleX(minimized ? MINIMIZE_DOCK_SCALE : 1f);
    794             }
    795             mDockedStackMinimized = minimized;
    796         } else if (mDockedStackMinimized != minimized) {
    797             mIsInMinimizeInteraction = true;
    798             mMinimizedSnapAlgorithm = null;
    799             mDockedStackMinimized = minimized;
    800             initializeSnapAlgorithm();
    801             stopDragging(minimized
    802                             ? mSnapTargetBeforeMinimized.position
    803                             : getCurrentPosition(),
    804                     minimized
    805                             ? mMinimizedSnapAlgorithm.getMiddleTarget()
    806                             : mSnapTargetBeforeMinimized,
    807                     animDuration, Interpolators.FAST_OUT_SLOW_IN, 0);
    808             setAdjustedForIme(false, animDuration);
    809         }
    810         if (!minimized) {
    811             mBackground.animate().withEndAction(mResetBackgroundRunnable);
    812         }
    813         mBackground.animate()
    814                 .setInterpolator(Interpolators.FAST_OUT_SLOW_IN)
    815                 .setDuration(animDuration)
    816                 .start();
    817     }
    818 
    819     public void setAdjustedForIme(boolean adjustedForIme) {
    820         updateDockSide();
    821         mHandle.setAlpha(adjustedForIme ? 0f : 1f);
    822         if (!adjustedForIme) {
    823             resetBackground();
    824         } else if (mDockSide == WindowManager.DOCKED_TOP) {
    825             mBackground.setPivotY(0);
    826             mBackground.setScaleY(ADJUSTED_FOR_IME_SCALE);
    827         }
    828         mAdjustedForIme = adjustedForIme;
    829     }
    830 
    831     public void setAdjustedForIme(boolean adjustedForIme, long animDuration) {
    832         updateDockSide();
    833         mHandle.animate()
    834                 .setInterpolator(IME_ADJUST_INTERPOLATOR)
    835                 .setDuration(animDuration)
    836                 .alpha(adjustedForIme ? 0f : 1f)
    837                 .start();
    838         if (mDockSide == WindowManager.DOCKED_TOP) {
    839             mBackground.setPivotY(0);
    840             mBackground.animate()
    841                     .scaleY(adjustedForIme ? ADJUSTED_FOR_IME_SCALE : 1f);
    842         }
    843         if (!adjustedForIme) {
    844             mBackground.animate().withEndAction(mResetBackgroundRunnable);
    845         }
    846         mBackground.animate()
    847                 .setInterpolator(IME_ADJUST_INTERPOLATOR)
    848                 .setDuration(animDuration)
    849                 .start();
    850         mAdjustedForIme = adjustedForIme;
    851     }
    852 
    853     private void saveSnapTargetBeforeMinimized(SnapTarget target) {
    854         mSnapTargetBeforeMinimized = target;
    855         mState.mRatioPositionBeforeMinimized = (float) target.position /
    856                 (isHorizontalDivision() ? mDisplayHeight : mDisplayWidth);
    857     }
    858 
    859     private void resetBackground() {
    860         mBackground.setPivotX(mBackground.getWidth() / 2);
    861         mBackground.setPivotY(mBackground.getHeight() / 2);
    862         mBackground.setScaleX(1f);
    863         mBackground.setScaleY(1f);
    864         mMinimizedShadow.setAlpha(0f);
    865     }
    866 
    867     @Override
    868     protected void onConfigurationChanged(Configuration newConfig) {
    869         super.onConfigurationChanged(newConfig);
    870         updateDisplayInfo();
    871     }
    872 
    873     public void notifyDockSideChanged(int newDockSide) {
    874         mDockSide = newDockSide;
    875         mMinimizedShadow.setDockSide(mDockSide);
    876         requestLayout();
    877     }
    878 
    879     private void updateDisplayInfo() {
    880         final DisplayManager displayManager =
    881                 (DisplayManager) mContext.getSystemService(Context.DISPLAY_SERVICE);
    882         Display display = displayManager.getDisplay(Display.DEFAULT_DISPLAY);
    883         final DisplayInfo info = new DisplayInfo();
    884         display.getDisplayInfo(info);
    885         mDisplayWidth = info.logicalWidth;
    886         mDisplayHeight = info.logicalHeight;
    887         mSnapAlgorithm = null;
    888         mMinimizedSnapAlgorithm = null;
    889         initializeSnapAlgorithm();
    890     }
    891 
    892     private int calculatePosition(int touchX, int touchY) {
    893         return isHorizontalDivision() ? calculateYPosition(touchY) : calculateXPosition(touchX);
    894     }
    895 
    896     public boolean isHorizontalDivision() {
    897         return getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT;
    898     }
    899 
    900     private int calculateXPosition(int touchX) {
    901         return mStartPosition + touchX - mStartX;
    902     }
    903 
    904     private int calculateYPosition(int touchY) {
    905         return mStartPosition + touchY - mStartY;
    906     }
    907 
    908     private void alignTopLeft(Rect containingRect, Rect rect) {
    909         int width = rect.width();
    910         int height = rect.height();
    911         rect.set(containingRect.left, containingRect.top,
    912                 containingRect.left + width, containingRect.top + height);
    913     }
    914 
    915     private void alignBottomRight(Rect containingRect, Rect rect) {
    916         int width = rect.width();
    917         int height = rect.height();
    918         rect.set(containingRect.right - width, containingRect.bottom - height,
    919                 containingRect.right, containingRect.bottom);
    920     }
    921 
    922     public void calculateBoundsForPosition(int position, int dockSide, Rect outRect) {
    923         DockedDividerUtils.calculateBoundsForPosition(position, dockSide, outRect, mDisplayWidth,
    924                 mDisplayHeight, mDividerSize);
    925     }
    926 
    927     public void resizeStackDelayed(int position, int taskPosition, SnapTarget taskSnapTarget) {
    928         Message message = mHandler.obtainMessage(MSG_RESIZE_STACK, position, taskPosition,
    929                 taskSnapTarget);
    930         message.setAsynchronous(true);
    931         mSfChoreographer.scheduleAtSfVsync(mHandler, message);
    932     }
    933 
    934     private void resizeStack(SnapTarget taskSnapTarget) {
    935         resizeStack(taskSnapTarget.position, taskSnapTarget.position, taskSnapTarget);
    936     }
    937 
    938     public void resizeStack(int position, int taskPosition, SnapTarget taskSnapTarget) {
    939         if (mRemoved) {
    940             // This divider view has been removed so shouldn't have any additional influence.
    941             return;
    942         }
    943         calculateBoundsForPosition(position, mDockSide, mDockedRect);
    944 
    945         if (mDockedRect.equals(mLastResizeRect) && !mEntranceAnimationRunning) {
    946             return;
    947         }
    948 
    949         // Make sure shadows are updated
    950         if (mBackground.getZ() > 0f) {
    951             mBackground.invalidate();
    952         }
    953 
    954         mLastResizeRect.set(mDockedRect);
    955         if (mHomeStackResizable && mIsInMinimizeInteraction) {
    956             calculateBoundsForPosition(mSnapTargetBeforeMinimized.position, mDockSide,
    957                     mDockedTaskRect);
    958             calculateBoundsForPosition(mSnapTargetBeforeMinimized.position,
    959                     DockedDividerUtils.invertDockSide(mDockSide), mOtherTaskRect);
    960             mWindowManagerProxy.resizeDockedStack(mDockedRect, mDockedTaskRect, mDockedTaskRect,
    961                     mOtherTaskRect, null);
    962             return;
    963         }
    964 
    965         if (mEntranceAnimationRunning && taskPosition != TASK_POSITION_SAME) {
    966             if (mCurrentAnimator != null) {
    967                 calculateBoundsForPosition(taskPosition, mDockSide, mDockedTaskRect);
    968             } else {
    969                 calculateBoundsForPosition(isHorizontalDivision() ? mDisplayHeight : mDisplayWidth,
    970                         mDockSide, mDockedTaskRect);
    971             }
    972             calculateBoundsForPosition(taskPosition, DockedDividerUtils.invertDockSide(mDockSide),
    973                     mOtherTaskRect);
    974             mWindowManagerProxy.resizeDockedStack(mDockedRect, mDockedTaskRect, null,
    975                     mOtherTaskRect, null);
    976         } else if (mExitAnimationRunning && taskPosition != TASK_POSITION_SAME) {
    977             calculateBoundsForPosition(taskPosition,
    978                     mDockSide, mDockedTaskRect);
    979             calculateBoundsForPosition(mExitStartPosition,
    980                     DockedDividerUtils.invertDockSide(mDockSide), mOtherTaskRect);
    981             mOtherInsetRect.set(mOtherTaskRect);
    982             applyExitAnimationParallax(mOtherTaskRect, position);
    983             mWindowManagerProxy.resizeDockedStack(mDockedRect, mDockedTaskRect, null,
    984                     mOtherTaskRect, mOtherInsetRect);
    985         } else if (taskPosition != TASK_POSITION_SAME) {
    986             calculateBoundsForPosition(position, DockedDividerUtils.invertDockSide(mDockSide),
    987                     mOtherRect);
    988             int dockSideInverted = DockedDividerUtils.invertDockSide(mDockSide);
    989             int taskPositionDocked =
    990                     restrictDismissingTaskPosition(taskPosition, mDockSide, taskSnapTarget);
    991             int taskPositionOther =
    992                     restrictDismissingTaskPosition(taskPosition, dockSideInverted, taskSnapTarget);
    993             calculateBoundsForPosition(taskPositionDocked, mDockSide, mDockedTaskRect);
    994             calculateBoundsForPosition(taskPositionOther, dockSideInverted, mOtherTaskRect);
    995             mDisplayRect.set(0, 0, mDisplayWidth, mDisplayHeight);
    996             alignTopLeft(mDockedRect, mDockedTaskRect);
    997             alignTopLeft(mOtherRect, mOtherTaskRect);
    998             mDockedInsetRect.set(mDockedTaskRect);
    999             mOtherInsetRect.set(mOtherTaskRect);
   1000             if (dockSideTopLeft(mDockSide)) {
   1001                 alignTopLeft(mDisplayRect, mDockedInsetRect);
   1002                 alignBottomRight(mDisplayRect, mOtherInsetRect);
   1003             } else {
   1004                 alignBottomRight(mDisplayRect, mDockedInsetRect);
   1005                 alignTopLeft(mDisplayRect, mOtherInsetRect);
   1006             }
   1007             applyDismissingParallax(mDockedTaskRect, mDockSide, taskSnapTarget, position,
   1008                     taskPositionDocked);
   1009             applyDismissingParallax(mOtherTaskRect, dockSideInverted, taskSnapTarget, position,
   1010                     taskPositionOther);
   1011             mWindowManagerProxy.resizeDockedStack(mDockedRect, mDockedTaskRect, mDockedInsetRect,
   1012                     mOtherTaskRect, mOtherInsetRect);
   1013         } else {
   1014             mWindowManagerProxy.resizeDockedStack(mDockedRect, null, null, null, null);
   1015         }
   1016         SnapTarget closestDismissTarget = getSnapAlgorithm().getClosestDismissTarget(position);
   1017         float dimFraction = getDimFraction(position, closestDismissTarget);
   1018         mWindowManagerProxy.setResizeDimLayer(dimFraction != 0f,
   1019                 getStackIdForDismissTarget(closestDismissTarget),
   1020                 dimFraction);
   1021     }
   1022 
   1023     private void applyExitAnimationParallax(Rect taskRect, int position) {
   1024         if (mDockSide == WindowManager.DOCKED_TOP) {
   1025             taskRect.offset(0, (int) ((position - mExitStartPosition) * 0.25f));
   1026         } else if (mDockSide == WindowManager.DOCKED_LEFT) {
   1027             taskRect.offset((int) ((position - mExitStartPosition) * 0.25f), 0);
   1028         } else if (mDockSide == WindowManager.DOCKED_RIGHT) {
   1029             taskRect.offset((int) ((mExitStartPosition - position) * 0.25f), 0);
   1030         }
   1031     }
   1032 
   1033     private float getDimFraction(int position, SnapTarget dismissTarget) {
   1034         if (mEntranceAnimationRunning) {
   1035             return 0f;
   1036         }
   1037         float fraction = getSnapAlgorithm().calculateDismissingFraction(position);
   1038         fraction = Math.max(0, Math.min(fraction, 1f));
   1039         fraction = DIM_INTERPOLATOR.getInterpolation(fraction);
   1040         if (hasInsetsAtDismissTarget(dismissTarget)) {
   1041 
   1042             // Less darkening with system insets.
   1043             fraction *= 0.8f;
   1044         }
   1045         return fraction;
   1046     }
   1047 
   1048     /**
   1049      * @return true if and only if there are system insets at the location of the dismiss target
   1050      */
   1051     private boolean hasInsetsAtDismissTarget(SnapTarget dismissTarget) {
   1052         if (isHorizontalDivision()) {
   1053             if (dismissTarget == getSnapAlgorithm().getDismissStartTarget()) {
   1054                 return mStableInsets.top != 0;
   1055             } else {
   1056                 return mStableInsets.bottom != 0;
   1057             }
   1058         } else {
   1059             if (dismissTarget == getSnapAlgorithm().getDismissStartTarget()) {
   1060                 return mStableInsets.left != 0;
   1061             } else {
   1062                 return mStableInsets.right != 0;
   1063             }
   1064         }
   1065     }
   1066 
   1067     /**
   1068      * When the snap target is dismissing one side, make sure that the dismissing side doesn't get
   1069      * 0 size.
   1070      */
   1071     private int restrictDismissingTaskPosition(int taskPosition, int dockSide,
   1072             SnapTarget snapTarget) {
   1073         if (snapTarget.flag == SnapTarget.FLAG_DISMISS_START && dockSideTopLeft(dockSide)) {
   1074             return Math.max(mSnapAlgorithm.getFirstSplitTarget().position, mStartPosition);
   1075         } else if (snapTarget.flag == SnapTarget.FLAG_DISMISS_END
   1076                 && dockSideBottomRight(dockSide)) {
   1077             return Math.min(mSnapAlgorithm.getLastSplitTarget().position, mStartPosition);
   1078         } else {
   1079             return taskPosition;
   1080         }
   1081     }
   1082 
   1083     /**
   1084      * Applies a parallax to the task when dismissing.
   1085      */
   1086     private void applyDismissingParallax(Rect taskRect, int dockSide, SnapTarget snapTarget,
   1087             int position, int taskPosition) {
   1088         float fraction = Math.min(1, Math.max(0,
   1089                 mSnapAlgorithm.calculateDismissingFraction(position)));
   1090         SnapTarget dismissTarget = null;
   1091         SnapTarget splitTarget = null;
   1092         int start = 0;
   1093         if (position <= mSnapAlgorithm.getLastSplitTarget().position
   1094                 && dockSideTopLeft(dockSide)) {
   1095             dismissTarget = mSnapAlgorithm.getDismissStartTarget();
   1096             splitTarget = mSnapAlgorithm.getFirstSplitTarget();
   1097             start = taskPosition;
   1098         } else if (position >= mSnapAlgorithm.getLastSplitTarget().position
   1099                 && dockSideBottomRight(dockSide)) {
   1100             dismissTarget = mSnapAlgorithm.getDismissEndTarget();
   1101             splitTarget = mSnapAlgorithm.getLastSplitTarget();
   1102             start = splitTarget.position;
   1103         }
   1104         if (dismissTarget != null && fraction > 0f
   1105                 && isDismissing(splitTarget, position, dockSide)) {
   1106             fraction = calculateParallaxDismissingFraction(fraction, dockSide);
   1107             int offsetPosition = (int) (start +
   1108                     fraction * (dismissTarget.position - splitTarget.position));
   1109             int width = taskRect.width();
   1110             int height = taskRect.height();
   1111             switch (dockSide) {
   1112                 case WindowManager.DOCKED_LEFT:
   1113                     taskRect.left = offsetPosition - width;
   1114                     taskRect.right = offsetPosition;
   1115                     break;
   1116                 case WindowManager.DOCKED_RIGHT:
   1117                     taskRect.left = offsetPosition + mDividerSize;
   1118                     taskRect.right = offsetPosition + width + mDividerSize;
   1119                     break;
   1120                 case WindowManager.DOCKED_TOP:
   1121                     taskRect.top = offsetPosition - height;
   1122                     taskRect.bottom = offsetPosition;
   1123                     break;
   1124                 case WindowManager.DOCKED_BOTTOM:
   1125                     taskRect.top = offsetPosition + mDividerSize;
   1126                     taskRect.bottom = offsetPosition + height + mDividerSize;
   1127                     break;
   1128             }
   1129         }
   1130     }
   1131 
   1132     /**
   1133      * @return for a specified {@code fraction}, this returns an adjusted value that simulates a
   1134      *         slowing down parallax effect
   1135      */
   1136     private static float calculateParallaxDismissingFraction(float fraction, int dockSide) {
   1137         float result = SLOWDOWN_INTERPOLATOR.getInterpolation(fraction) / 3.5f;
   1138 
   1139         // Less parallax at the top, just because.
   1140         if (dockSide == WindowManager.DOCKED_TOP) {
   1141             result /= 2f;
   1142         }
   1143         return result;
   1144     }
   1145 
   1146     private static boolean isDismissing(SnapTarget snapTarget, int position, int dockSide) {
   1147         if (dockSide == WindowManager.DOCKED_TOP || dockSide == WindowManager.DOCKED_LEFT) {
   1148             return position < snapTarget.position;
   1149         } else {
   1150             return position > snapTarget.position;
   1151         }
   1152     }
   1153 
   1154     private int getStackIdForDismissTarget(SnapTarget dismissTarget) {
   1155         if ((dismissTarget.flag == SnapTarget.FLAG_DISMISS_START && dockSideTopLeft(mDockSide))
   1156                 || (dismissTarget.flag == SnapTarget.FLAG_DISMISS_END
   1157                         && dockSideBottomRight(mDockSide))) {
   1158             return StackId.DOCKED_STACK_ID;
   1159         } else {
   1160             return StackId.RECENTS_STACK_ID;
   1161         }
   1162     }
   1163 
   1164     /**
   1165      * @return true if and only if {@code dockSide} is top or left
   1166      */
   1167     private static boolean dockSideTopLeft(int dockSide) {
   1168         return dockSide == WindowManager.DOCKED_TOP || dockSide == WindowManager.DOCKED_LEFT;
   1169     }
   1170 
   1171     /**
   1172      * @return true if and only if {@code dockSide} is bottom or right
   1173      */
   1174     private static boolean dockSideBottomRight(int dockSide) {
   1175         return dockSide == WindowManager.DOCKED_BOTTOM || dockSide == WindowManager.DOCKED_RIGHT;
   1176     }
   1177 
   1178     @Override
   1179     public void onComputeInternalInsets(InternalInsetsInfo inoutInfo) {
   1180         inoutInfo.setTouchableInsets(InternalInsetsInfo.TOUCHABLE_INSETS_REGION);
   1181         inoutInfo.touchableRegion.set(mHandle.getLeft(), mHandle.getTop(), mHandle.getRight(),
   1182                 mHandle.getBottom());
   1183         inoutInfo.touchableRegion.op(mBackground.getLeft(), mBackground.getTop(),
   1184                 mBackground.getRight(), mBackground.getBottom(), Op.UNION);
   1185     }
   1186 
   1187     /**
   1188      * Checks whether recents will grow when invoked. This happens in multi-window when recents is
   1189      * very small. When invoking recents, we shrink the docked stack so recents has more space.
   1190      *
   1191      * @return the position of the divider when recents grows, or
   1192      *         {@link #INVALID_RECENTS_GROW_TARGET} if recents won't grow
   1193      */
   1194     public int growsRecents() {
   1195         boolean result = mGrowRecents
   1196                 && mDockSide == WindowManager.DOCKED_TOP
   1197                 && getCurrentPosition() == getSnapAlgorithm().getLastSplitTarget().position;
   1198         if (result) {
   1199             return getSnapAlgorithm().getMiddleTarget().position;
   1200         } else {
   1201             return INVALID_RECENTS_GROW_TARGET;
   1202         }
   1203     }
   1204 
   1205     public final void onBusEvent(RecentsActivityStartingEvent recentsActivityStartingEvent) {
   1206         if (mGrowRecents && mDockSide == WindowManager.DOCKED_TOP
   1207                 && getSnapAlgorithm().getMiddleTarget() != getSnapAlgorithm().getLastSplitTarget()
   1208                 && getCurrentPosition() == getSnapAlgorithm().getLastSplitTarget().position) {
   1209             mState.growAfterRecentsDrawn = true;
   1210             startDragging(false /* animate */, false /* touching */);
   1211         }
   1212     }
   1213 
   1214     public final void onBusEvent(DockedFirstAnimationFrameEvent event) {
   1215         saveSnapTargetBeforeMinimized(mSnapAlgorithm.getMiddleTarget());
   1216     }
   1217 
   1218     public final void onBusEvent(DockedTopTaskEvent event) {
   1219         if (event.dragMode == NavigationBarGestureHelper.DRAG_MODE_NONE) {
   1220             mState.growAfterRecentsDrawn = false;
   1221             mState.animateAfterRecentsDrawn = true;
   1222             startDragging(false /* animate */, false /* touching */);
   1223         }
   1224         updateDockSide();
   1225         int position = DockedDividerUtils.calculatePositionForBounds(event.initialRect,
   1226                 mDockSide, mDividerSize);
   1227         mEntranceAnimationRunning = true;
   1228 
   1229         resizeStack(position, mSnapAlgorithm.getMiddleTarget().position,
   1230                 mSnapAlgorithm.getMiddleTarget());
   1231     }
   1232 
   1233     public void onRecentsDrawn() {
   1234         if (mState.animateAfterRecentsDrawn) {
   1235             mState.animateAfterRecentsDrawn = false;
   1236             updateDockSide();
   1237 
   1238             mHandler.post(() -> {
   1239                 // Delay switching resizing mode because this might cause jank in recents animation
   1240                 // that's longer than this animation.
   1241                 stopDragging(getCurrentPosition(), mSnapAlgorithm.getMiddleTarget(),
   1242                         mLongPressEntraceAnimDuration, Interpolators.FAST_OUT_SLOW_IN,
   1243                         200 /* endDelay */);
   1244             });
   1245         }
   1246         if (mState.growAfterRecentsDrawn) {
   1247             mState.growAfterRecentsDrawn = false;
   1248             updateDockSide();
   1249             EventBus.getDefault().send(new RecentsGrowingEvent());
   1250             stopDragging(getCurrentPosition(), mSnapAlgorithm.getMiddleTarget(), 336,
   1251                     Interpolators.FAST_OUT_SLOW_IN);
   1252         }
   1253     }
   1254 
   1255     public final void onBusEvent(UndockingTaskEvent undockingTaskEvent) {
   1256         int dockSide = mWindowManagerProxy.getDockSide();
   1257         if (dockSide != WindowManager.DOCKED_INVALID && (mHomeStackResizable
   1258                 || !mDockedStackMinimized)) {
   1259             startDragging(false /* animate */, false /* touching */);
   1260             SnapTarget target = dockSideTopLeft(dockSide)
   1261                     ? mSnapAlgorithm.getDismissEndTarget()
   1262                     : mSnapAlgorithm.getDismissStartTarget();
   1263 
   1264             // Don't start immediately - give a little bit time to settle the drag resize change.
   1265             mExitAnimationRunning = true;
   1266             mExitStartPosition = getCurrentPosition();
   1267             stopDragging(mExitStartPosition, target, 336 /* duration */, 100 /* startDelay */,
   1268                     0 /* endDelay */, Interpolators.FAST_OUT_SLOW_IN);
   1269         }
   1270     }
   1271 }
   1272