/*
|
* Copyright (C) 2012 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.bubbles;
|
|
import android.content.Context;
|
import android.graphics.PointF;
|
import android.os.Handler;
|
import android.view.MotionEvent;
|
import android.view.VelocityTracker;
|
import android.view.View;
|
import android.view.ViewConfiguration;
|
|
import com.android.systemui.Dependency;
|
|
/**
|
* Handles interpreting touches on a {@link BubbleStackView}. This includes expanding, collapsing,
|
* dismissing, and flings.
|
*/
|
class BubbleTouchHandler implements View.OnTouchListener {
|
/** Velocity required to dismiss the stack without dragging it into the dismiss target. */
|
private static final float STACK_DISMISS_MIN_VELOCITY = 4000f;
|
|
/**
|
* Velocity required to dismiss an individual bubble without dragging it into the dismiss
|
* target.
|
*
|
* This is higher than the stack dismiss velocity since unlike the stack, a downward fling could
|
* also be an attempted gesture to return the bubble to the row of expanded bubbles, which would
|
* usually be below the dragged bubble. By increasing the required velocity, it's less likely
|
* that the user is trying to drop it back into the row vs. fling it away.
|
*/
|
private static final float INDIVIDUAL_BUBBLE_DISMISS_MIN_VELOCITY = 6000f;
|
|
private static final String TAG = "BubbleTouchHandler";
|
/**
|
* When the stack is flung towards the bottom of the screen, it'll be dismissed if it's flung
|
* towards the center of the screen (where the dismiss target is). This value is the width of
|
* the target area to be considered 'towards the target'. For example 50% means that the stack
|
* needs to be flung towards the middle 50%, and the 25% on the left and right sides won't
|
* count.
|
*/
|
private static final float DISMISS_FLING_TARGET_WIDTH_PERCENT = 0.5f;
|
|
private final PointF mTouchDown = new PointF();
|
private final PointF mViewPositionOnTouchDown = new PointF();
|
private final BubbleStackView mStack;
|
private final BubbleData mBubbleData;
|
|
private BubbleController mController = Dependency.get(BubbleController.class);
|
|
private boolean mMovedEnough;
|
private int mTouchSlopSquared;
|
private VelocityTracker mVelocityTracker;
|
|
private boolean mInDismissTarget;
|
private Handler mHandler = new Handler();
|
|
/** View that was initially touched, when we received the first ACTION_DOWN event. */
|
private View mTouchedView;
|
|
BubbleTouchHandler(BubbleStackView stackView,
|
BubbleData bubbleData, Context context) {
|
final int touchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
|
mTouchSlopSquared = touchSlop * touchSlop;
|
mBubbleData = bubbleData;
|
mStack = stackView;
|
}
|
|
@Override
|
public boolean onTouch(View v, MotionEvent event) {
|
final int action = event.getActionMasked();
|
|
// If we aren't currently in the process of touching a view, figure out what we're touching.
|
// It'll be the stack, an individual bubble, or nothing.
|
if (mTouchedView == null) {
|
mTouchedView = mStack.getTargetView(event);
|
}
|
|
// If this is an ACTION_OUTSIDE event, or the stack reported that we aren't touching
|
// anything, collapse the stack.
|
if (action == MotionEvent.ACTION_OUTSIDE || mTouchedView == null) {
|
mBubbleData.setExpanded(false);
|
resetForNextGesture();
|
return false;
|
}
|
|
final boolean isStack = mStack.equals(mTouchedView);
|
final boolean isFlyout = mStack.getFlyoutView().equals(mTouchedView);
|
final float rawX = event.getRawX();
|
final float rawY = event.getRawY();
|
|
// The coordinates of the touch event, in terms of the touched view's position.
|
final float viewX = mViewPositionOnTouchDown.x + rawX - mTouchDown.x;
|
final float viewY = mViewPositionOnTouchDown.y + rawY - mTouchDown.y;
|
switch (action) {
|
case MotionEvent.ACTION_DOWN:
|
trackMovement(event);
|
|
mTouchDown.set(rawX, rawY);
|
mStack.onGestureStart();
|
|
if (isStack) {
|
mViewPositionOnTouchDown.set(mStack.getStackPosition());
|
mStack.onDragStart();
|
} else if (isFlyout) {
|
mStack.onFlyoutDragStart();
|
} else {
|
mViewPositionOnTouchDown.set(
|
mTouchedView.getTranslationX(), mTouchedView.getTranslationY());
|
mStack.onBubbleDragStart(mTouchedView);
|
}
|
|
break;
|
case MotionEvent.ACTION_MOVE:
|
trackMovement(event);
|
final float deltaX = rawX - mTouchDown.x;
|
final float deltaY = rawY - mTouchDown.y;
|
|
if ((deltaX * deltaX) + (deltaY * deltaY) > mTouchSlopSquared && !mMovedEnough) {
|
mMovedEnough = true;
|
}
|
|
if (mMovedEnough) {
|
if (isStack) {
|
mStack.onDragged(viewX, viewY);
|
} else if (isFlyout) {
|
mStack.onFlyoutDragged(deltaX);
|
} else {
|
mStack.onBubbleDragged(mTouchedView, viewX, viewY);
|
}
|
}
|
|
final boolean currentlyInDismissTarget = mStack.isInDismissTarget(event);
|
if (currentlyInDismissTarget != mInDismissTarget) {
|
mInDismissTarget = currentlyInDismissTarget;
|
|
mVelocityTracker.computeCurrentVelocity(/* maxVelocity */ 1000);
|
final float velX = mVelocityTracker.getXVelocity();
|
final float velY = mVelocityTracker.getYVelocity();
|
|
// If the touch event is within the dismiss target, magnet the stack to it.
|
if (!isFlyout) {
|
mStack.animateMagnetToDismissTarget(
|
mTouchedView, mInDismissTarget, viewX, viewY, velX, velY);
|
}
|
}
|
break;
|
|
case MotionEvent.ACTION_CANCEL:
|
resetForNextGesture();
|
break;
|
|
case MotionEvent.ACTION_UP:
|
trackMovement(event);
|
mVelocityTracker.computeCurrentVelocity(/* maxVelocity */ 1000);
|
final float velX = mVelocityTracker.getXVelocity();
|
final float velY = mVelocityTracker.getYVelocity();
|
|
final boolean shouldDismiss =
|
isStack
|
? mInDismissTarget
|
|| isFastFlingTowardsDismissTarget(rawX, rawY, velX, velY)
|
: mInDismissTarget
|
|| velY > INDIVIDUAL_BUBBLE_DISMISS_MIN_VELOCITY;
|
|
if (isFlyout && mMovedEnough) {
|
mStack.onFlyoutDragFinished(rawX - mTouchDown.x /* deltaX */, velX);
|
} else if (shouldDismiss) {
|
final String individualBubbleKey =
|
isStack ? null : ((BubbleView) mTouchedView).getKey();
|
mStack.magnetToStackIfNeededThenAnimateDismissal(mTouchedView, velX, velY,
|
() -> {
|
if (isStack) {
|
mController.dismissStack(BubbleController.DISMISS_USER_GESTURE);
|
} else {
|
mController.removeBubble(
|
individualBubbleKey,
|
BubbleController.DISMISS_USER_GESTURE);
|
}
|
});
|
} else if (isFlyout) {
|
// TODO(b/129768381): Expand if tapped, dismiss if swiped away.
|
if (!mBubbleData.isExpanded() && !mMovedEnough) {
|
mBubbleData.setExpanded(true);
|
}
|
} else if (mMovedEnough) {
|
if (isStack) {
|
mStack.onDragFinish(viewX, viewY, velX, velY);
|
} else {
|
mStack.onBubbleDragFinish(mTouchedView, viewX, viewY, velX, velY);
|
}
|
} else if (mTouchedView == mStack.getExpandedBubbleView()) {
|
mBubbleData.setExpanded(false);
|
} else if (isStack || isFlyout) {
|
// Toggle expansion
|
mBubbleData.setExpanded(!mBubbleData.isExpanded());
|
} else {
|
final String key = ((BubbleView) mTouchedView).getKey();
|
mBubbleData.setSelectedBubble(mBubbleData.getBubbleWithKey(key));
|
}
|
|
resetForNextGesture();
|
break;
|
}
|
|
return true;
|
}
|
|
/**
|
* Whether the given touch data represents a powerful fling towards the bottom-center of the
|
* screen (the dismiss target).
|
*/
|
private boolean isFastFlingTowardsDismissTarget(
|
float rawX, float rawY, float velX, float velY) {
|
// Not a fling downward towards the target if velocity is zero or negative.
|
if (velY <= 0) {
|
return false;
|
}
|
|
float bottomOfScreenInterceptX = rawX;
|
|
// Only do math if the X velocity is non-zero, otherwise X won't change.
|
if (velX != 0) {
|
// Rise over run...
|
final float slope = velY / velX;
|
// ...y = mx + b, b = y / mx...
|
final float yIntercept = rawY - slope * rawX;
|
// ...calculate the x value when y = bottom of the screen.
|
bottomOfScreenInterceptX = (mStack.getHeight() - yIntercept) / slope;
|
}
|
|
final float dismissTargetWidth =
|
mStack.getWidth() * DISMISS_FLING_TARGET_WIDTH_PERCENT;
|
return velY > STACK_DISMISS_MIN_VELOCITY
|
&& bottomOfScreenInterceptX > dismissTargetWidth / 2f
|
&& bottomOfScreenInterceptX < mStack.getWidth() - dismissTargetWidth / 2f;
|
}
|
|
/** Clears all touch-related state. */
|
private void resetForNextGesture() {
|
if (mVelocityTracker != null) {
|
mVelocityTracker.recycle();
|
mVelocityTracker = null;
|
}
|
|
mTouchedView = null;
|
mMovedEnough = false;
|
mInDismissTarget = false;
|
|
mStack.onGestureFinished();
|
}
|
|
private void trackMovement(MotionEvent event) {
|
if (mVelocityTracker == null) {
|
mVelocityTracker = VelocityTracker.obtain();
|
}
|
mVelocityTracker.addMovement(event);
|
}
|
}
|
