xref: /frameworks/base/packages/SystemUI/src/com/android/systemui/pip/phone/PipTouchHandler.java

/*
 * Copyright (C) 2016 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.systemui.pip.phone;

import static android.app.ActivityManager.StackId.PINNED_STACK_ID;
import static android.view.WindowManager.INPUT_CONSUMER_PIP;

import static com.android.systemui.Interpolators.FAST_OUT_LINEAR_IN;
import static com.android.systemui.Interpolators.FAST_OUT_SLOW_IN;
import static com.android.systemui.Interpolators.LINEAR_OUT_SLOW_IN;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ValueAnimator;
import android.animation.ValueAnimator.AnimatorUpdateListener;
import android.app.ActivityManager.StackInfo;
import android.app.IActivityManager;
import android.content.Context;
import android.graphics.Point;
import android.graphics.PointF;
import android.graphics.Rect;
import android.os.Looper;
import android.os.RemoteException;
import android.util.Log;
import android.view.IPinnedStackController;
import android.view.IWindowManager;
import android.view.InputChannel;
import android.view.InputEvent;
import android.view.InputEventReceiver;
import android.view.MotionEvent;
import android.view.ViewConfiguration;

import com.android.internal.os.BackgroundThread;
import com.android.internal.policy.PipMotionHelper;
import com.android.internal.policy.PipSnapAlgorithm;
import com.android.systemui.statusbar.FlingAnimationUtils;
import com.android.systemui.tuner.TunerService;

/**
 * Manages all the touch handling for PIP on the Phone, including moving, dismissing and expanding
 * the PIP.
 */
public class PipTouchHandler implements TunerService.Tunable {
    private static final String TAG = "PipTouchHandler";
    private static final boolean DEBUG_ALLOW_OUT_OF_BOUNDS_STACK = false;

    private static final String TUNER_KEY_DRAG_TO_DISMISS = "pip_drag_to_dismiss";
    private static final String TUNER_KEY_ALLOW_MINIMIZE = "pip_allow_minimize";

    private static final int SNAP_STACK_DURATION = 225;
    private static final int DISMISS_STACK_DURATION = 375;
    private static final int EXPAND_STACK_DURATION = 225;
    private static final int MINIMIZE_STACK_MAX_DURATION = 200;

    // The fraction of the stack width that the user has to drag offscreen to minimize the PIP
    private static final float MINIMIZE_OFFSCREEN_FRACTION = 0.15f;

    private final Context mContext;
    private final IActivityManager mActivityManager;
    private final IWindowManager mWindowManager;
    private final ViewConfiguration mViewConfig;
    private final PipMenuListener mMenuListener = new PipMenuListener();
    private IPinnedStackController mPinnedStackController;

    private PipInputEventReceiver mInputEventReceiver;
    private PipMenuActivityController mMenuController;
    private PipDismissViewController mDismissViewController;
    private final PipSnapAlgorithm mSnapAlgorithm;
    private PipMotionHelper mMotionHelper;

    // Allow dragging the PIP to a location to close it
    private boolean mEnableDragToDismiss = false;
    // Allow the PIP to be "docked" slightly offscreen
    private boolean mEnableMinimizing = true;

    private final Rect mStableInsets = new Rect();
    private final Rect mPinnedStackBounds = new Rect();
    private final Rect mBoundedPinnedStackBounds = new Rect();
    private ValueAnimator mPinnedStackBoundsAnimator = null;
    private ValueAnimator.AnimatorUpdateListener mUpdatePinnedStackBoundsListener =
            new AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            mPinnedStackBounds.set((Rect) animation.getAnimatedValue());
        }
    };

    // Behaviour states
    private boolean mIsTappingThrough;
    private boolean mIsMinimized;

    // Touch state
    private final PipTouchState mTouchState;
    private final FlingAnimationUtils mFlingAnimationUtils;
    private final PipTouchGesture[] mGestures;

    // Temporary vars
    private final Rect mTmpBounds = new Rect();

    /**
     * Input handler used for Pip windows.
     */
    private final class PipInputEventReceiver extends InputEventReceiver {

        public PipInputEventReceiver(InputChannel inputChannel, Looper looper) {
            super(inputChannel, looper);
        }

        @Override
        public void onInputEvent(InputEvent event) {
            boolean handled = true;
            try {
                // To be implemented for input handling over Pip windows
                if (event instanceof MotionEvent) {
                    MotionEvent ev = (MotionEvent) event;
                    handled = handleTouchEvent(ev);
                }
            } finally {
                finishInputEvent(event, handled);
            }
        }
    }

    /**
     * A listener for the PIP menu activity.
     */
    private class PipMenuListener implements PipMenuActivityController.Listener {
        @Override
        public void onPipMenuVisibilityChanged(boolean visible) {
            if (!visible) {
                mIsTappingThrough = false;
                registerInputConsumer();
            } else {
                unregisterInputConsumer();
            }
        }

        @Override
        public void onPipExpand() {
            if (!mIsMinimized) {
                expandPinnedStackToFullscreen();
            }
        }

        @Override
        public void onPipMinimize() {
            setMinimizedState(true);
            animateToClosestMinimizedTarget();
        }

        @Override
        public void onPipDismiss() {
            BackgroundThread.getHandler().post(PipTouchHandler.this::dismissPinnedStack);
        }
    }

    public PipTouchHandler(Context context, PipMenuActivityController menuController,
            IActivityManager activityManager, IWindowManager windowManager) {

        // Initialize the Pip input consumer
        mContext = context;
        mActivityManager = activityManager;
        mWindowManager = windowManager;
        mViewConfig = ViewConfiguration.get(context);
        mMenuController = menuController;
        mMenuController.addListener(mMenuListener);
        mDismissViewController = new PipDismissViewController(context);
        mSnapAlgorithm = new PipSnapAlgorithm(mContext);
        mTouchState = new PipTouchState(mViewConfig);
        mFlingAnimationUtils = new FlingAnimationUtils(context, 2f);
        mGestures = new PipTouchGesture[] {
                mDragToDismissGesture, mTapThroughGesture, mMinimizeGesture, mDefaultMovementGesture
        };
        mMotionHelper = new PipMotionHelper(BackgroundThread.getHandler());
        registerInputConsumer();
        setSnapToEdge(true);

        // Register any tuner settings changes
        TunerService.get(context).addTunable(this, TUNER_KEY_DRAG_TO_DISMISS,
                TUNER_KEY_ALLOW_MINIMIZE);
    }

    @Override
    public void onTuningChanged(String key, String newValue) {
        if (newValue == null) {
            // Reset back to default
            mEnableDragToDismiss = false;
            mEnableMinimizing = true;
            setMinimizedState(false);
            return;
        }
        switch (key) {
            case TUNER_KEY_DRAG_TO_DISMISS:
                mEnableDragToDismiss = Integer.parseInt(newValue) != 0;
                break;
            case TUNER_KEY_ALLOW_MINIMIZE:
                mEnableMinimizing = Integer.parseInt(newValue) != 0;
                break;
        }
    }

    public void onActivityPinned() {
        // Reset some states once we are pinned
        if (mIsTappingThrough) {
            mIsTappingThrough = false;
            registerInputConsumer();
        }
        if (mIsMinimized) {
            setMinimizedState(false);
        }
    }

    public void onConfigurationChanged() {
        mSnapAlgorithm.onConfigurationChanged();
        updateBoundedPinnedStackBounds(false /* updatePinnedStackBounds */);
    }

    public void onMinimizedStateChanged(boolean isMinimized) {
        mIsMinimized = isMinimized;
    }

    public void onSnapToEdgeStateChanged(boolean isSnapToEdge) {
        mSnapAlgorithm.setSnapToEdge(isSnapToEdge);
    }

    private boolean handleTouchEvent(MotionEvent ev) {
        // Skip touch handling until we are bound to the controller
        if (mPinnedStackController == null) {
            return true;
        }

        // Update the touch state
        mTouchState.onTouchEvent(ev);

        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN: {
                // Cancel any existing animations on the pinned stack
                if (mPinnedStackBoundsAnimator != null) {
                    mPinnedStackBoundsAnimator.cancel();
                }

                updateBoundedPinnedStackBounds(true /* updatePinnedStackBounds */);
                for (PipTouchGesture gesture : mGestures) {
                    gesture.onDown(mTouchState);
                }
                try {
                    mPinnedStackController.setInInteractiveMode(true);
                } catch (RemoteException e) {
                    Log.e(TAG, "Could not set dragging state", e);
                }
                break;
            }
            case MotionEvent.ACTION_MOVE: {
                for (PipTouchGesture gesture : mGestures) {
                    if (gesture.onMove(mTouchState)) {
                        break;
                    }
                }
                break;
            }
            case MotionEvent.ACTION_UP: {
                // Update the movement bounds again if the state has changed since the user started
                // dragging (ie. when the IME shows)
                updateBoundedPinnedStackBounds(false /* updatePinnedStackBounds */);

                for (PipTouchGesture gesture : mGestures) {
                    if (gesture.onUp(mTouchState)) {
                        break;
                    }
                }

                // Fall through to clean up
            }
            case MotionEvent.ACTION_CANCEL: {
                try {
                    mPinnedStackController.setInInteractiveMode(false);
                } catch (RemoteException e) {
                    Log.e(TAG, "Could not set dragging state", e);
                }
                break;
            }
        }
        return !mIsTappingThrough;
    }

    /**
     * @return whether the current touch state is a horizontal drag offscreen.
     */
    private boolean isDraggingOffscreen(PipTouchState touchState) {
        PointF lastDelta = touchState.getLastTouchDelta();
        PointF downDelta = touchState.getDownTouchDelta();
        float left = mPinnedStackBounds.left + lastDelta.x;
        return !(mBoundedPinnedStackBounds.left <= left && left <= mBoundedPinnedStackBounds.right)
                && Math.abs(downDelta.x) > Math.abs(downDelta.y);
    }

    /**
     * Registers the input consumer.
     */
    private void registerInputConsumer() {
        if (mInputEventReceiver == null) {
            final InputChannel inputChannel = new InputChannel();
            try {
                mWindowManager.destroyInputConsumer(INPUT_CONSUMER_PIP);
                mWindowManager.createInputConsumer(INPUT_CONSUMER_PIP, inputChannel);
            } catch (RemoteException e) {
                Log.e(TAG, "Failed to create PIP input consumer", e);
            }
            mInputEventReceiver = new PipInputEventReceiver(inputChannel, Looper.myLooper());
        }
    }

    /**
     * Unregisters the input consumer.
     */
    private void unregisterInputConsumer() {
        if (mInputEventReceiver != null) {
            try {
                mWindowManager.destroyInputConsumer(INPUT_CONSUMER_PIP);
            } catch (RemoteException e) {
                Log.e(TAG, "Failed to destroy PIP input consumer", e);
            }
            mInputEventReceiver.dispose();
            mInputEventReceiver = null;
        }
    }

    /**
     * Sets the controller to update the system of changes from user interaction.
     */
    void setPinnedStackController(IPinnedStackController controller) {
        mPinnedStackController = controller;
    }

    /**
     * Sets the snap-to-edge state and notifies the controller.
     */
    private void setSnapToEdge(boolean snapToEdge) {
        onSnapToEdgeStateChanged(snapToEdge);

        if (mPinnedStackController != null) {
            try {
                mPinnedStackController.setSnapToEdge(snapToEdge);
            } catch (RemoteException e) {
                Log.e(TAG, "Could not set snap mode to edge", e);
            }
        }
    }

    /**
     * Sets the minimized state and notifies the controller.
     */
    private void setMinimizedState(boolean isMinimized) {
        onMinimizedStateChanged(isMinimized);

        if (mPinnedStackController != null) {
            try {
                mPinnedStackController.setIsMinimized(isMinimized);
            } catch (RemoteException e) {
                Log.e(TAG, "Could not set minimized state", e);
            }
        }
    }

    /**
     * @return whether the given {@param pinnedStackBounds} indicates the PIP should be minimized.
     */
    private boolean shouldMinimizedPinnedStack() {
        Point displaySize = new Point();
        mContext.getDisplay().getRealSize(displaySize);
        if (mPinnedStackBounds.left < 0) {
            float offscreenFraction = (float) -mPinnedStackBounds.left / mPinnedStackBounds.width();
            return offscreenFraction >= MINIMIZE_OFFSCREEN_FRACTION;
        } else if (mPinnedStackBounds.right > displaySize.x) {
            float offscreenFraction = (float) (mPinnedStackBounds.right - displaySize.x) /
                    mPinnedStackBounds.width();
            return offscreenFraction >= MINIMIZE_OFFSCREEN_FRACTION;
        } else {
            return false;
        }
    }

    /**
     * Flings the minimized PIP to the closest minimized snap target.
     */
    private void flingToMinimizedSnapTarget(float velocityY) {
        // We currently only allow flinging the minimized stack up and down, so just lock the
        // movement bounds to the current stack bounds horizontally
        Rect movementBounds = new Rect(mPinnedStackBounds.left, mBoundedPinnedStackBounds.top,
                mPinnedStackBounds.left, mBoundedPinnedStackBounds.bottom);
        Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(movementBounds, mPinnedStackBounds,
                0 /* velocityX */, velocityY);
        if (!mPinnedStackBounds.equals(toBounds)) {
            mPinnedStackBoundsAnimator = mMotionHelper.createAnimationToBounds(mPinnedStackBounds,
                    toBounds, 0, FAST_OUT_SLOW_IN, mUpdatePinnedStackBoundsListener);
            mFlingAnimationUtils.apply(mPinnedStackBoundsAnimator, 0,
                    distanceBetweenRectOffsets(mPinnedStackBounds, toBounds),
                    velocityY);
            mPinnedStackBoundsAnimator.start();
        }
    }

    /**
     * Animates the PIP to the minimized state, slightly offscreen.
     */
    private void animateToClosestMinimizedTarget() {
        Point displaySize = new Point();
        mContext.getDisplay().getRealSize(displaySize);
        Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(mBoundedPinnedStackBounds,
                mPinnedStackBounds);
        mSnapAlgorithm.applyMinimizedOffset(toBounds, mBoundedPinnedStackBounds, displaySize,
                mStableInsets);
        mPinnedStackBoundsAnimator = mMotionHelper.createAnimationToBounds(mPinnedStackBounds,
                toBounds, MINIMIZE_STACK_MAX_DURATION, LINEAR_OUT_SLOW_IN,
                mUpdatePinnedStackBoundsListener);
        mPinnedStackBoundsAnimator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                mMenuController.hideMenu();
            }
        });
        mPinnedStackBoundsAnimator.start();
    }

    /**
     * Flings the PIP to the closest snap target.
     */
    private void flingToSnapTarget(float velocity, float velocityX, float velocityY) {
        Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(mBoundedPinnedStackBounds,
                mPinnedStackBounds, velocityX, velocityY);
        if (!mPinnedStackBounds.equals(toBounds)) {
            mPinnedStackBoundsAnimator = mMotionHelper.createAnimationToBounds(mPinnedStackBounds,
                toBounds, 0, FAST_OUT_SLOW_IN, mUpdatePinnedStackBoundsListener);
            mFlingAnimationUtils.apply(mPinnedStackBoundsAnimator, 0,
                distanceBetweenRectOffsets(mPinnedStackBounds, toBounds),
                velocity);
            mPinnedStackBoundsAnimator.start();
        }
    }

    /**
     * Animates the PIP to the closest snap target.
     */
    private void animateToClosestSnapTarget() {
        Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(mBoundedPinnedStackBounds,
                mPinnedStackBounds);
        if (!mPinnedStackBounds.equals(toBounds)) {
            mPinnedStackBoundsAnimator = mMotionHelper.createAnimationToBounds(mPinnedStackBounds,
                toBounds, SNAP_STACK_DURATION, FAST_OUT_SLOW_IN, mUpdatePinnedStackBoundsListener);
            mPinnedStackBoundsAnimator.start();
        }
    }

    /**
     * Animates the dismissal of the PIP over the dismiss target bounds.
     */
    private void animateDismissPinnedStack(Rect dismissBounds) {
        Rect toBounds = new Rect(dismissBounds.centerX(),
            dismissBounds.centerY(),
            dismissBounds.centerX() + 1,
            dismissBounds.centerY() + 1);
        mPinnedStackBoundsAnimator = mMotionHelper.createAnimationToBounds(mPinnedStackBounds,
            toBounds, DISMISS_STACK_DURATION, FAST_OUT_LINEAR_IN, mUpdatePinnedStackBoundsListener);
        mPinnedStackBoundsAnimator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                BackgroundThread.getHandler().post(PipTouchHandler.this::dismissPinnedStack);
            }
        });
        mPinnedStackBoundsAnimator.start();
    }

    /**
     * Resizes the pinned stack back to fullscreen.
     */
    private void expandPinnedStackToFullscreen() {
        BackgroundThread.getHandler().post(() -> {
            try {
                mActivityManager.resizeStack(PINNED_STACK_ID, null /* bounds */,
                        true /* allowResizeInDockedMode */, true /* preserveWindows */,
                        true /* animate */, EXPAND_STACK_DURATION);
            } catch (RemoteException e) {
                Log.e(TAG, "Error showing PIP menu activity", e);
            }
        });
    }

    /**
     * Tries to the move the pinned stack to the given {@param bounds}.
     */
    private void movePinnedStack(Rect bounds) {
        if (!bounds.equals(mPinnedStackBounds)) {
            mPinnedStackBounds.set(bounds);
            mMotionHelper.resizeToBounds(mPinnedStackBounds);
        }
    }

    /**
     * Dismisses the pinned stack.
     */
    private void dismissPinnedStack() {
        try {
            mActivityManager.removeStack(PINNED_STACK_ID);
        } catch (RemoteException e) {
            Log.e(TAG, "Failed to remove PIP", e);
        }
    }

    /**
     * Updates the movement bounds of the pinned stack.
     */
    private void updateBoundedPinnedStackBounds(boolean updatePinnedStackBounds) {
        try {
            StackInfo info = mActivityManager.getStackInfo(PINNED_STACK_ID);
            if (info != null) {
                if (updatePinnedStackBounds) {
                    mPinnedStackBounds.set(info.bounds);
                }
                mWindowManager.getStableInsets(info.displayId, mStableInsets);
                mBoundedPinnedStackBounds.set(mWindowManager.getPictureInPictureMovementBounds(
                        info.displayId));
            }
        } catch (RemoteException e) {
            Log.e(TAG, "Could not fetch PIP movement bounds.", e);
        }
    }

    /**
     * @return the distance between points {@param p1} and {@param p2}.
     */
    private float distanceBetweenRectOffsets(Rect r1, Rect r2) {
        return PointF.length(r1.left - r2.left, r1.top - r2.top);
    }

    /**
     * Gesture controlling dragging over a target to dismiss the PIP.
     */
    private PipTouchGesture mDragToDismissGesture = new PipTouchGesture() {
        @Override
        public void onDown(PipTouchState touchState) {
            if (mEnableDragToDismiss) {
                // TODO: Consider setting a timer such at after X time, we show the dismiss
                //       target if the user hasn't already dragged some distance
                mDismissViewController.createDismissTarget();
            }
        }

        @Override
        boolean onMove(PipTouchState touchState) {
            if (mEnableDragToDismiss && touchState.startedDragging()) {
                mDismissViewController.showDismissTarget();
            }
            return false;
        }

        @Override
        public boolean onUp(PipTouchState touchState) {
            if (mEnableDragToDismiss) {
                try {
                    if (touchState.isDragging()) {
                        Rect dismissBounds = mDismissViewController.getDismissBounds();
                        PointF lastTouch = touchState.getLastTouchPosition();
                        if (dismissBounds.contains((int) lastTouch.x, (int) lastTouch.y)) {
                            animateDismissPinnedStack(dismissBounds);
                            return true;
                        }
                    }
                } finally {
                    mDismissViewController.destroyDismissTarget();
                }
            }
            return false;
        }
    };

    /**** Gestures ****/

    /**
     * Gesture controlling dragging the PIP slightly offscreen to minimize it.
     */
    private PipTouchGesture mMinimizeGesture = new PipTouchGesture() {
        @Override
        boolean onMove(PipTouchState touchState) {
            if (mEnableMinimizing) {
                boolean isDraggingOffscreen = isDraggingOffscreen(touchState);
                if (touchState.startedDragging() && isDraggingOffscreen) {
                    // Reset the minimized state once we drag horizontally
                    setMinimizedState(false);
                }

                if (touchState.allowDraggingOffscreen() && isDraggingOffscreen) {
                    // Move the pinned stack, but ignore the vertical movement
                    float left = mPinnedStackBounds.left + touchState.getLastTouchDelta().x;
                    mTmpBounds.set(mPinnedStackBounds);
                    mTmpBounds.offsetTo((int) left, mPinnedStackBounds.top);
                    if (!mTmpBounds.equals(mPinnedStackBounds)) {
                        mPinnedStackBounds.set(mTmpBounds);
                        mMotionHelper.resizeToBounds(mPinnedStackBounds);
                    }
                    return true;
                } else if (mIsMinimized && touchState.isDragging()) {
                    // Move the pinned stack, but ignore the horizontal movement
                    PointF lastDelta = touchState.getLastTouchDelta();
                    float top = mPinnedStackBounds.top + lastDelta.y;
                    top = Math.max(mBoundedPinnedStackBounds.top, Math.min(
                            mBoundedPinnedStackBounds.bottom, top));
                    mTmpBounds.set(mPinnedStackBounds);
                    mTmpBounds.offsetTo(mPinnedStackBounds.left, (int) top);
                    movePinnedStack(mTmpBounds);
                    return true;
                }
            }
            return false;
        }

        @Override
        public boolean onUp(PipTouchState touchState) {
            if (mEnableMinimizing) {
                if (touchState.isDragging()) {
                    if (isDraggingOffscreen(touchState)) {
                        if (shouldMinimizedPinnedStack()) {
                            setMinimizedState(true);
                            animateToClosestMinimizedTarget();
                            return true;
                        }
                    } else if (mIsMinimized) {
                        PointF vel = touchState.getVelocity();
                        if (vel.length() > mFlingAnimationUtils.getMinVelocityPxPerSecond()) {
                            flingToMinimizedSnapTarget(vel.y);
                        } else {
                            animateToClosestMinimizedTarget();
                        }
                        return true;
                    }
                } else if (mIsMinimized) {
                    setMinimizedState(false);
                    animateToClosestSnapTarget();
                    return true;
                }
            }
            return false;
        }
    };

    /**
     * Gesture controlling tapping on the PIP to show an overlay.
     */
    private PipTouchGesture mTapThroughGesture = new PipTouchGesture() {
        @Override
        boolean onMove(PipTouchState touchState) {
            return false;
        }

        @Override
        public boolean onUp(PipTouchState touchState) {
            if (!touchState.isDragging() && !mIsMinimized && !mIsTappingThrough) {
                mMenuController.showMenu();
                mIsTappingThrough = true;
                return true;
            }
            return false;
        }
    };

    /**
     * Gesture controlling normal movement of the PIP.
     */
    private PipTouchGesture mDefaultMovementGesture = new PipTouchGesture() {
        @Override
        boolean onMove(PipTouchState touchState) {
            if (touchState.startedDragging()) {
                // For now, once the user has started a drag that the other gestures have not
                // intercepted, disallow those gestures from intercepting again to drag offscreen
                touchState.setDisallowDraggingOffscreen();
            }

            if (touchState.isDragging()) {
                // Move the pinned stack freely
                PointF lastDelta = touchState.getLastTouchDelta();
                float left = mPinnedStackBounds.left + lastDelta.x;
                float top = mPinnedStackBounds.top + lastDelta.y;
                if (!DEBUG_ALLOW_OUT_OF_BOUNDS_STACK) {
                    left = Math.max(mBoundedPinnedStackBounds.left, Math.min(
                            mBoundedPinnedStackBounds.right, left));
                    top = Math.max(mBoundedPinnedStackBounds.top, Math.min(
                            mBoundedPinnedStackBounds.bottom, top));
                }
                mTmpBounds.set(mPinnedStackBounds);
                mTmpBounds.offsetTo((int) left, (int) top);
                movePinnedStack(mTmpBounds);
                return true;
            }
            return false;
        }

        @Override
        public boolean onUp(PipTouchState touchState) {
            if (touchState.isDragging()) {
                PointF vel = mTouchState.getVelocity();
                float velocity = PointF.length(vel.x, vel.y);
                if (velocity > mFlingAnimationUtils.getMinVelocityPxPerSecond()) {
                    flingToSnapTarget(velocity, vel.x, vel.y);
                } else {
                    animateToClosestSnapTarget();
                }
            } else {
                expandPinnedStackToFullscreen();
            }
            return true;
        }
    };
}