| /* |
| * Copyright (C) 2014 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.internal.widget; |
| |
| import android.app.Activity; |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.res.TypedArray; |
| import android.util.AttributeSet; |
| import android.util.Log; |
| import android.view.MotionEvent; |
| import android.view.VelocityTracker; |
| import android.view.View; |
| import android.view.ViewConfiguration; |
| import android.view.ViewGroup; |
| import android.view.ViewTreeObserver; |
| import android.widget.FrameLayout; |
| |
| /** |
| * Special layout that finishes its activity when swiped away. |
| */ |
| public class SwipeDismissLayout extends FrameLayout { |
| private static final String TAG = "SwipeDismissLayout"; |
| |
| private static final float DISMISS_MIN_DRAG_WIDTH_RATIO = .33f; |
| private boolean mUseDynamicTranslucency = true; |
| |
| public interface OnDismissedListener { |
| void onDismissed(SwipeDismissLayout layout); |
| } |
| |
| public interface OnSwipeProgressChangedListener { |
| /** |
| * Called when the layout has been swiped and the position of the window should change. |
| * |
| * @param progress A number in [0, 1] representing how far to the |
| * right the window has been swiped |
| * @param translate A number in [0, w], where w is the width of the |
| * layout. This is equivalent to progress * layout.getWidth(). |
| */ |
| void onSwipeProgressChanged(SwipeDismissLayout layout, float progress, float translate); |
| |
| void onSwipeCancelled(SwipeDismissLayout layout); |
| } |
| |
| // Cached ViewConfiguration and system-wide constant values |
| private int mSlop; |
| private int mMinFlingVelocity; |
| |
| // Transient properties |
| private int mActiveTouchId; |
| private float mDownX; |
| private float mDownY; |
| private boolean mSwiping; |
| private boolean mDismissed; |
| private boolean mDiscardIntercept; |
| private VelocityTracker mVelocityTracker; |
| private float mTranslationX; |
| |
| private OnDismissedListener mDismissedListener; |
| private OnSwipeProgressChangedListener mProgressListener; |
| private ViewTreeObserver.OnEnterAnimationCompleteListener mOnEnterAnimationCompleteListener = |
| new ViewTreeObserver.OnEnterAnimationCompleteListener() { |
| @Override |
| public void onEnterAnimationComplete() { |
| // SwipeDismissLayout assumes that the host Activity is translucent |
| // and temporarily disables translucency when it is fully visible. |
| // As soon as the user starts swiping, we will re-enable |
| // translucency. |
| if (mUseDynamicTranslucency && getContext() instanceof Activity) { |
| ((Activity) getContext()).convertFromTranslucent(); |
| } |
| } |
| }; |
| private BroadcastReceiver mScreenOffReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| if (mDismissed) { |
| dismiss(); |
| } else { |
| cancel(); |
| } |
| resetMembers(); |
| } |
| }; |
| private IntentFilter mScreenOffFilter = new IntentFilter(Intent.ACTION_SCREEN_OFF); |
| |
| private float mLastX; |
| |
| public SwipeDismissLayout(Context context) { |
| super(context); |
| init(context); |
| } |
| |
| public SwipeDismissLayout(Context context, AttributeSet attrs) { |
| super(context, attrs); |
| init(context); |
| } |
| |
| public SwipeDismissLayout(Context context, AttributeSet attrs, int defStyle) { |
| super(context, attrs, defStyle); |
| init(context); |
| } |
| |
| private void init(Context context) { |
| ViewConfiguration vc = ViewConfiguration.get(context); |
| mSlop = vc.getScaledTouchSlop(); |
| mMinFlingVelocity = vc.getScaledMinimumFlingVelocity(); |
| TypedArray a = context.getTheme().obtainStyledAttributes( |
| com.android.internal.R.styleable.Theme); |
| mUseDynamicTranslucency = !a.hasValue( |
| com.android.internal.R.styleable.Window_windowIsTranslucent); |
| a.recycle(); |
| } |
| |
| public void setOnDismissedListener(OnDismissedListener listener) { |
| mDismissedListener = listener; |
| } |
| |
| public void setOnSwipeProgressChangedListener(OnSwipeProgressChangedListener listener) { |
| mProgressListener = listener; |
| } |
| |
| @Override |
| protected void onAttachedToWindow() { |
| super.onAttachedToWindow(); |
| if (getContext() instanceof Activity) { |
| getViewTreeObserver().addOnEnterAnimationCompleteListener( |
| mOnEnterAnimationCompleteListener); |
| } |
| getContext().registerReceiver(mScreenOffReceiver, mScreenOffFilter); |
| } |
| |
| @Override |
| protected void onDetachedFromWindow() { |
| getContext().unregisterReceiver(mScreenOffReceiver); |
| if (getContext() instanceof Activity) { |
| getViewTreeObserver().removeOnEnterAnimationCompleteListener( |
| mOnEnterAnimationCompleteListener); |
| } |
| super.onDetachedFromWindow(); |
| } |
| |
| @Override |
| public boolean onInterceptTouchEvent(MotionEvent ev) { |
| // offset because the view is translated during swipe |
| ev.offsetLocation(mTranslationX, 0); |
| |
| switch (ev.getActionMasked()) { |
| case MotionEvent.ACTION_DOWN: |
| resetMembers(); |
| mDownX = ev.getRawX(); |
| mDownY = ev.getRawY(); |
| mActiveTouchId = ev.getPointerId(0); |
| mVelocityTracker = VelocityTracker.obtain(); |
| mVelocityTracker.addMovement(ev); |
| break; |
| |
| case MotionEvent.ACTION_POINTER_DOWN: |
| int actionIndex = ev.getActionIndex(); |
| mActiveTouchId = ev.getPointerId(actionIndex); |
| break; |
| case MotionEvent.ACTION_POINTER_UP: |
| actionIndex = ev.getActionIndex(); |
| int pointerId = ev.getPointerId(actionIndex); |
| if (pointerId == mActiveTouchId) { |
| // This was our active pointer going up. Choose a new active pointer. |
| int newActionIndex = actionIndex == 0 ? 1 : 0; |
| mActiveTouchId = ev.getPointerId(newActionIndex); |
| } |
| break; |
| |
| case MotionEvent.ACTION_CANCEL: |
| case MotionEvent.ACTION_UP: |
| resetMembers(); |
| break; |
| |
| case MotionEvent.ACTION_MOVE: |
| if (mVelocityTracker == null || mDiscardIntercept) { |
| break; |
| } |
| |
| int pointerIndex = ev.findPointerIndex(mActiveTouchId); |
| if (pointerIndex == -1) { |
| Log.e(TAG, "Invalid pointer index: ignoring."); |
| mDiscardIntercept = true; |
| break; |
| } |
| float dx = ev.getRawX() - mDownX; |
| float x = ev.getX(pointerIndex); |
| float y = ev.getY(pointerIndex); |
| if (dx != 0 && canScroll(this, false, dx, x, y)) { |
| mDiscardIntercept = true; |
| break; |
| } |
| updateSwiping(ev); |
| break; |
| } |
| |
| return !mDiscardIntercept && mSwiping; |
| } |
| |
| @Override |
| public boolean onTouchEvent(MotionEvent ev) { |
| if (mVelocityTracker == null) { |
| return super.onTouchEvent(ev); |
| } |
| // offset because the view is translated during swipe |
| ev.offsetLocation(mTranslationX, 0); |
| switch (ev.getActionMasked()) { |
| case MotionEvent.ACTION_UP: |
| updateDismiss(ev); |
| if (mDismissed) { |
| dismiss(); |
| } else if (mSwiping) { |
| cancel(); |
| } |
| resetMembers(); |
| break; |
| |
| case MotionEvent.ACTION_CANCEL: |
| cancel(); |
| resetMembers(); |
| break; |
| |
| case MotionEvent.ACTION_MOVE: |
| mVelocityTracker.addMovement(ev); |
| mLastX = ev.getRawX(); |
| updateSwiping(ev); |
| if (mSwiping) { |
| if (mUseDynamicTranslucency && getContext() instanceof Activity) { |
| ((Activity) getContext()).convertToTranslucent(null, null); |
| } |
| setProgress(ev.getRawX() - mDownX); |
| break; |
| } |
| } |
| return true; |
| } |
| |
| private void setProgress(float deltaX) { |
| mTranslationX = deltaX; |
| if (mProgressListener != null && deltaX >= 0) { |
| mProgressListener.onSwipeProgressChanged(this, deltaX / getWidth(), deltaX); |
| } |
| } |
| |
| private void dismiss() { |
| if (mDismissedListener != null) { |
| mDismissedListener.onDismissed(this); |
| } |
| } |
| |
| protected void cancel() { |
| if (mUseDynamicTranslucency && getContext() instanceof Activity) { |
| ((Activity) getContext()).convertFromTranslucent(); |
| } |
| if (mProgressListener != null) { |
| mProgressListener.onSwipeCancelled(this); |
| } |
| } |
| |
| /** |
| * Resets internal members when canceling. |
| */ |
| private void resetMembers() { |
| if (mVelocityTracker != null) { |
| mVelocityTracker.recycle(); |
| } |
| mVelocityTracker = null; |
| mTranslationX = 0; |
| mDownX = 0; |
| mDownY = 0; |
| mSwiping = false; |
| mDismissed = false; |
| mDiscardIntercept = false; |
| } |
| |
| private void updateSwiping(MotionEvent ev) { |
| if (!mSwiping) { |
| float deltaX = ev.getRawX() - mDownX; |
| float deltaY = ev.getRawY() - mDownY; |
| if ((deltaX * deltaX) + (deltaY * deltaY) > mSlop * mSlop) { |
| mSwiping = deltaX > mSlop * 2 && Math.abs(deltaY) < Math.abs(deltaX); |
| } else { |
| mSwiping = false; |
| } |
| } |
| } |
| |
| private void updateDismiss(MotionEvent ev) { |
| float deltaX = ev.getRawX() - mDownX; |
| mVelocityTracker.addMovement(ev); |
| mVelocityTracker.computeCurrentVelocity(1000); |
| if (!mDismissed) { |
| |
| if (deltaX > (getWidth() * DISMISS_MIN_DRAG_WIDTH_RATIO) && |
| ev.getRawX() >= mLastX) { |
| mDismissed = true; |
| } |
| } |
| // Check if the user tried to undo this. |
| if (mDismissed && mSwiping) { |
| // Check if the user's finger is actually back |
| if (deltaX < (getWidth() * DISMISS_MIN_DRAG_WIDTH_RATIO) || |
| // or user is flinging back left |
| mVelocityTracker.getXVelocity() < -mMinFlingVelocity) { |
| mDismissed = false; |
| } |
| } |
| } |
| |
| /** |
| * Tests scrollability within child views of v in the direction of dx. |
| * |
| * @param v View to test for horizontal scrollability |
| * @param checkV Whether the view v passed should itself be checked for scrollability (true), |
| * or just its children (false). |
| * @param dx Delta scrolled in pixels. Only the sign of this is used. |
| * @param x X coordinate of the active touch point |
| * @param y Y coordinate of the active touch point |
| * @return true if child views of v can be scrolled by delta of dx. |
| */ |
| protected boolean canScroll(View v, boolean checkV, float dx, float x, float y) { |
| if (v instanceof ViewGroup) { |
| final ViewGroup group = (ViewGroup) v; |
| final int scrollX = v.getScrollX(); |
| final int scrollY = v.getScrollY(); |
| final int count = group.getChildCount(); |
| for (int i = count - 1; i >= 0; i--) { |
| final View child = group.getChildAt(i); |
| if (x + scrollX >= child.getLeft() && x + scrollX < child.getRight() && |
| y + scrollY >= child.getTop() && y + scrollY < child.getBottom() && |
| canScroll(child, true, dx, x + scrollX - child.getLeft(), |
| y + scrollY - child.getTop())) { |
| return true; |
| } |
| } |
| } |
| |
| return checkV && v.canScrollHorizontally((int) -dx); |
| } |
| } |