Android 一键打造仿IOS右滑退出Activity,非常简单的集成方式(SwipeFinishLayout)

相信很多玩过苹果的伙伴，都觉得苹果应用的可以右滑退出界面非常方便，但是Android的应用大多都是需要点击返回按钮才能退出，不过现在已经有几个App有了，比如：网易、今日头条和淘宝都有实现。现在网上已经有了这个控件，已经实现了，但是使用起来不是很方便，今天我们就把这个控件的使用方式简单化，只需要你继承一个BaseActivity就可以完成右滑控件的添加。

首先看效果：

跟IOS的效果没有很大的区别吧？
下面看代码。
BaseSwipeFinishActivity：

public abstract class BaseSwipeFinishActivity extends Activity implements SwipeFinishLayout.SwipeToCloseLayoutAction {

    private SwipeFinishLayout mSwipeToCloseLayout;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    /**
     * 此方法要在setContentView之后执行，用户添加右滑退出的布局。
     */
    protected void addSwipeFinishLayout() {
        mSwipeToCloseLayout = new SwipeFinishLayout(this);
        mSwipeToCloseLayout.attachToActivity(this);
        mSwipeToCloseLayout.setSwipeToCloseLayoutAction(this);
    }

    /**
     * 是否可滑动退出
     *
     * @param enableGesture
     */
    public void setEnableGesture(boolean enableGesture) {
        if (mSwipeToCloseLayout != null) {
            mSwipeToCloseLayout.setEnableGesture(enableGesture);
        }
    }

    /**
     * 全屏时滑动的处理
     *
     * @param fullScreen
     */
    public void setActivityFullScreen(boolean fullScreen) {
        if (mSwipeToCloseLayout != null) {
            mSwipeToCloseLayout.setActivityFullScreen(fullScreen);
        }
    }

    /**
     * 向右滑动是否可关闭activity
     */
    @Override
    public boolean onScrollToClose() {
        return true;
    }

    /**
     * 是否点击在可左右滑动的views里面
     */
    @Override
    public boolean inChild(Rect rect, Point point) {
        return false;
    }

    @Override
    public void onCloseAction() {
        finish();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mSwipeToCloseLayout != null) {
            mSwipeToCloseLayout.removeAllViews();
            mSwipeToCloseLayout.setSwipeToCloseLayoutAction(null);
            mSwipeToCloseLayout = null;
        }
    }

    /**
     * 关闭执行的动画
     */
    @Override
    public final void finish() {
        super.finish();
        overridePendingTransition(R.anim.push_none, R.anim.push_up_out);
    }

    /**
     * 打开activity执行的方法
     */
    @Override
    public void startActivity(Intent intent) {
        super.startActivity(intent);
        overridePendingTransition(R.anim.push_up_in, R.anim.push_none);
    }

}

两个Activity代码：

public class MainActivity extends BaseSwipeFinishActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        addSwipeFinishLayout();
        //首页activtiy可设置为不能滑动关闭
        setEnableGesture(false);
    }

    public void onClick(View view) {
        startActivity(new Intent(this, SecondActivity.class));
    }
}


public class SecondActivity extends BaseSwipeFinishActivity{

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        //添加布局之后需要执行添加右滑退出的布局
        addSwipeFinishLayout();
    }
}

右滑控件代码：
SwipeFinishLayout

public class SwipeFinishLayout extends FrameLayout implements SwipeFinishAction {

    private boolean             mEnableGesture = true;
    private Scroller            mScroller;
    private SwipeFinishUtils mSwipeToClose;
    private boolean             mToCloseActivity;
    private Activity            mActivity;

    public SwipeFinishLayout(Context context) {
        super(context);
        init(context);
    }

    public SwipeFinishLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }

    private void init(Context context){
        mScroller = new Scroller(context);
        mSwipeToClose = new SwipeFinishUtils(context, mScroller);

        mSwipeToClose.setContentView(this);
        mSwipeToClose.setSwipeToTouchAction(this);
        setWillNotDraw(false);
    }


    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        if (mEnableGesture && mSwipeToClose != null && mSwipeToClose.onInterceptTouchEvent(ev)) {
            return true;
        }
        return super.onInterceptTouchEvent(ev);
    }

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        return (mEnableGesture && mSwipeToClose != null && mSwipeToClose.onTouchEvent(ev));
    }

    public void setAllAreaCanScroll(boolean allAreaCanScroll) {
    }

    public void setEnableGesture(boolean enableGesture) {
        this.mEnableGesture = enableGesture;
    }

    public void setActivityFullScreen(boolean fullScreen){
        this.mSwipeToClose.setActivityFullScreen(fullScreen);
    }

    @Override
    public void computeScroll() {
        super.computeScroll();
        if (mScroller.computeScrollOffset()) {
            scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
            postInvalidate();
        } else {
            if (mToCloseActivity) {
                if (mSwipeToCloseLayoutAction != null) {
                    mSwipeToCloseLayoutAction.onCloseAction();
                }
            }
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        if(Math.abs(getScrollX()) >= getWidth()){
            return;
        }
        canvas.save();
        int alpha = 160 * (getWidth() - Math.abs(getScrollX())) / getWidth();
        int color = (alpha << 24 | 0x00000000);
        canvas.drawColor(color);
        canvas.restore();
    }

    @Override
    public void startScroll(int startX, int dx, boolean finish) {
        mToCloseActivity = dx < 0;
        mScroller.startScroll(startX, 0, dx, 0, 500 * Math.abs(dx) / getWidth());
        postInvalidate();
    }

    private SwipeToCloseLayoutAction mSwipeToCloseLayoutAction;

    public void setSwipeToCloseLayoutAction(SwipeToCloseLayoutAction action) {
        this.mSwipeToCloseLayoutAction = action;
    }

    public interface SwipeToCloseLayoutAction extends SwipeFinishTouchCheckAction {
        /**
         * 关闭界面
         */
        void onCloseAction();
    }

    public void attachToActivity(Activity activity){
        mActivity = activity;
        ViewGroup viewGroup = (ViewGroup) activity.findViewById(android.R.id.content);
        View contentView = viewGroup.getChildAt(0);
        viewGroup.removeView(contentView);
        if(contentView != null){
            if(contentView.getBackground() == null){
                contentView.setBackgroundColor(Color.WHITE);
            }
            attachView(contentView);
        }
        viewGroup.addView(this);
        convertActivityFromTranslucent(activity);
    }

    public void attachView(View view) {
        addView(view);
    }
    public  void convertActivityFromTranslucent(Activity activity) {
        try {
            Method method = Activity.class
                    .getDeclaredMethod("convertFromTranslucent");
            method.setAccessible(true);
            method.invoke(activity);
        } catch (Throwable t) {
        }
    }
    public  void convertActivityToTranslucent(Activity activity) {
        if (activity == null)
            return;
        try {
            Class<?>[] t = Activity.class.getDeclaredClasses();
            Class<?> translucentConversionListenerClazz = null;
            Class<?>[] method = t;
            int len$ = t.length;
            for (int i$ = 0; i$ < len$; ++i$) {
                Class<?> clazz = method[i$];
                if (clazz.getSimpleName().contains(
                        "TranslucentConversionListener")) {
                    translucentConversionListenerClazz = clazz;
                    break;
                }
            }
            if (Build.VERSION.SDK_INT >= 21) {
                Class<?> ActivityOptions = Class
                        .forName("android.app.ActivityOptions");
                Method var8 = Activity.class.getDeclaredMethod(
                        "convertToTranslucent",
                        translucentConversionListenerClazz, ActivityOptions);
                var8.setAccessible(true);
                var8.invoke(activity, new Object[] { null, null });
            } else {
                Method var8 = Activity.class.getDeclaredMethod(
                        "convertToTranslucent",
                        translucentConversionListenerClazz);
                var8.setAccessible(true);
                var8.invoke(activity, new Object[] { null });
            }
        } catch (Throwable e) {
        }
    }
    @Override
    public void onScroll() {
        convertActivityToTranslucent(mActivity);
    }

    @Override
    public void onTouchDown() {
        convertActivityToTranslucent(mActivity);
    }

    @Override
    public boolean inChild(Rect rect, Point point) {
        return mSwipeToCloseLayoutAction != null && mSwipeToCloseLayoutAction.inChild(rect, point);
    }

    @Override
    public boolean onScrollToClose() {
        return mSwipeToCloseLayoutAction != null && mSwipeToCloseLayoutAction.onScrollToClose();
    }

    public void onActivityDestory() {
        mSwipeToClose = null;
        mScroller = null;
        mActivity = null;
        mToCloseActivity = false;
    }

}

SwipeFinishUtils，主要的滑动处理基本都在这个里面，根据手指滑动的距离进行判断是否要关闭activity，这里是根据是否滑动到了屏幕的一半来判断的。滑动的时候移动当前activity的布局：

package com.xw.widget;

import android.app.Activity;
import android.content.Context;
import android.graphics.Point;
import android.graphics.Rect;
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.ViewParent;
import android.widget.Scroller;

import java.lang.reflect.Field;

public class SwipeFinishUtils {

    private static final int INVALID_POINTER = -1;

    private boolean mIsBeingDragged;

    private int mTouchSlop;
    private int mActivePointerId;
    private int mLastMotionX;
    private int mLastMotionY;
    private int mMoveMotionX;
    private int mMoveMotionY;
    private int mMaximumVelocity;
    private int mMinimumVelocity;

    private View mView;
    private VelocityTracker mVelocityTracker;
    private Scroller mScroller;
    private SwipeFinishAction mAction;
    private int mStatusBarHeight;

    private boolean mFullScreen;
    private boolean mDownOver = false;//距离左侧1/2才生效
    private int mScreenWidth;
    private boolean mInChild;

    public SwipeFinishUtils(Context context, Scroller scroller) {
        mScroller = scroller;
        mScreenWidth = context.getResources().getDisplayMetrics().widthPixels;
        final ViewConfiguration configuration = ViewConfiguration.get(context);
        mTouchSlop = configuration.getScaledTouchSlop();
        mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
        mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
        mStatusBarHeight =getStatusBarHeight(context);
    }

    public void setContentView(View view) {
        this.mView = view;
    }

    public void setSwipeToTouchAction(SwipeFinishAction action) {
        this.mAction = action;
    }
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        final int action = ev.getAction();
        Log.i("TAG", "SwipeToClose----------------------onInterceptTouchEvent:" + ev.getAction() + ",mIsBeingDragged:" + mIsBeingDragged);
        if ((action == MotionEvent.ACTION_MOVE) && (mIsBeingDragged)) {
            return true;
        }
        switch (action & MotionEvent.ACTION_MASK) {
            case MotionEvent.ACTION_MOVE: {
                if (!mDownOver) {
                    break;
                }
                final int activePointerId = mActivePointerId;
                if (activePointerId == INVALID_POINTER) {
                    break;
                }

                final int pointerIndex = ev.findPointerIndex(activePointerId);
                if (pointerIndex == -1) {
                    break;
                }

                final int x = (int) ev.getX(pointerIndex);
                final int y = (int) ev.getY(pointerIndex);
                final int xDiff = Math.abs(x - mLastMotionX);
                final int yDiff = Math.abs(y - mLastMotionY);
                boolean hasScrollToRight = x > mLastMotionX;
                boolean hasCanScroll = !mInChild || (hasScrollToRight && mAction != null && mAction.onScrollToClose());
                if (xDiff > yDiff && xDiff > mTouchSlop && hasCanScroll) {
                    mIsBeingDragged = true;
                    mLastMotionX = x;
                    mMoveMotionX = x;
                    mLastMotionY = y;
                    mMoveMotionY = y;
                    initVelocityTrackerIfNotExists();
                    mVelocityTracker.addMovement(ev);
                    final ViewParent parent = mView.getParent();
                    if (parent != null) {
                        parent.requestDisallowInterceptTouchEvent(true);
                    }
                }
                break;
            }

            case MotionEvent.ACTION_DOWN: {
                final int x = (int) ev.getX();
                final int y = (int) ev.getY();
                mLastMotionX = x;
                mMoveMotionX = x;
                mLastMotionY = y;
                mMoveMotionY = y;
                mActivePointerId = ev.getPointerId(0);

                initOrResetVelocityTracker();
                mVelocityTracker.addMovement(ev);

                mIsBeingDragged = !mScroller.isFinished();
                Point point = new Point(mMoveMotionX, addYForSDK19(mLastMotionY));
                Rect rect = new Rect();
                mInChild = mAction != null && mAction.inChild(rect, point);

                if (mAction != null && !mIsBeingDragged) {
                    mAction.onTouchDown();
                }
                mDownOver = mLastMotionX <= mScreenWidth / 2;
                break;
            }

            case MotionEvent.ACTION_CANCEL:
            case MotionEvent.ACTION_UP:
                mIsBeingDragged = false;
                mActivePointerId = INVALID_POINTER;
                recycleVelocityTracker();
                mDownOver = false;
                mInChild = false;
                break;
            case MotionEvent.ACTION_POINTER_UP:
                onSecondaryPointerUp(ev);
                break;
        }
        return mIsBeingDragged;
    }

    private void onSecondaryPointerUp(MotionEvent ev) {
        final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK) >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
        final int pointerId = ev.getPointerId(pointerIndex);
        if (pointerId == mActivePointerId) {
            final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
            mLastMotionX = (int) ev.getX(newPointerIndex);
            mActivePointerId = ev.getPointerId(newPointerIndex);
            if (mVelocityTracker != null) {
                mVelocityTracker.clear();
            }
        }
    }

    public boolean onTouchEvent(MotionEvent ev) {
        initVelocityTrackerIfNotExists();
        MotionEvent vtev = MotionEvent.obtain(ev);
        final int actionMasked = ev.getActionMasked();

        switch (actionMasked) {
            case MotionEvent.ACTION_DOWN: {
                if (mView instanceof ViewGroup) {
                    if (((ViewGroup) mView).getChildCount() == 0)
                        return false;
                }
                if ((mIsBeingDragged = !mScroller.isFinished())) {
                    final ViewParent parent = mView.getParent();
                    if (parent != null) {
                        parent.requestDisallowInterceptTouchEvent(true);
                    }
                }

                if (!mScroller.isFinished()) {
                    mScroller.abortAnimation();
                }

                mLastMotionX = (int) ev.getX();
                mMoveMotionX = mLastMotionX;

                mLastMotionY = (int) ev.getY();
                mMoveMotionY = mLastMotionY;
                mActivePointerId = ev.getPointerId(0);
                break;
            }
            case MotionEvent.ACTION_MOVE:
                final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
                if (activePointerIndex == -1) {
                    break;
                }

                final int x = (int) ev.getX(activePointerIndex);
                int deltaX = mMoveMotionX - x;
                final int y = (int) ev.getY(activePointerIndex);
                int deltaY = mMoveMotionY - y;
                if (!mIsBeingDragged && Math.abs(deltaX) >= Math.abs(deltaY) && Math.abs(deltaX) > mTouchSlop) {
                    final ViewParent parent = mView.getParent();
                    if (parent != null) {
                        parent.requestDisallowInterceptTouchEvent(true);
                    }
                    mIsBeingDragged = true;
                    if (deltaX > 0) {
                        deltaX -= mTouchSlop;
                    } else {
                        deltaX += mTouchSlop;
                    }
                }
                if (mIsBeingDragged) {
                    if (mView.getScrollX() + deltaX >= 0) {
                        deltaX = -mView.getScrollX();
                    }
                    mView.scrollBy(deltaX, 0);
                }
                mMoveMotionX = x;
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
                if (mIsBeingDragged) {
                    final VelocityTracker velocityTracker = mVelocityTracker;
                    velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
                    int initialVelocity = (int) velocityTracker.getXVelocity(mActivePointerId);
                    int scrollX = mView.getScrollX();
                    int dx = Math.abs(scrollX);
                    boolean finish = false;
                    if ((Math.abs(initialVelocity) > mMinimumVelocity)) {
                        if (initialVelocity > 0) {
                            finish = true;
                            dx = -(mView.getWidth() - dx);
                        }
                    } else if (Math.abs(mLastMotionX - ev.getX()) > mView.getWidth() / 2) {
                        finish = true;
                        dx = -(mView.getWidth() - dx);
                    }
                    scrollTo(scrollX, dx, finish);
                    mActivePointerId = INVALID_POINTER;
                }
                mDownOver = false;
                mInChild = false;
                break;
            case MotionEvent.ACTION_POINTER_DOWN: {
                final int index = ev.getActionIndex();
                mLastMotionX = (int) ev.getX(index);
                mMoveMotionX = mLastMotionX;
                mActivePointerId = ev.getPointerId(index);
                break;
            }
            case MotionEvent.ACTION_POINTER_UP:
                onSecondaryPointerUp(ev);
                mLastMotionX = (int) ev.getX(ev.findPointerIndex(mActivePointerId));
                mMoveMotionX = mLastMotionX;
                break;
        }

        if (mVelocityTracker != null) {
            mVelocityTracker.addMovement(vtev);
        }
        vtev.recycle();
        if (mAction != null) {
            mAction.onScroll();
        }
        return true;
    }

    private void scrollTo(int startX, int dx, boolean finish) {
        if (mAction != null) {
            mAction.startScroll(startX, dx, finish);
        }
    }


    public void setActivityFullScreen(boolean fullScreen) {
        mFullScreen = fullScreen;
    }

    private int addYForSDK19(int y) {
        if (mFullScreen) {
            return y;
        } else {
            return y + mStatusBarHeight;
        }
    }

    private void initOrResetVelocityTracker() {
        if (mVelocityTracker == null) {
            mVelocityTracker = VelocityTracker.obtain();
        } else {
            mVelocityTracker.clear();
        }
    }

    private void initVelocityTrackerIfNotExists() {
        if (mVelocityTracker == null) {
            mVelocityTracker = VelocityTracker.obtain();
        }
    }

    private void recycleVelocityTracker() {
        if (mVelocityTracker != null) {
            mVelocityTracker.recycle();
            mVelocityTracker = null;
        }
    }


    /**
     * 获取状态栏的高度
     *
     * @param context
     * @return
     */
    public int getStatusBarHeight(Context context) {
        int statusBarHeight = 0;
        try {
            Class<?> c = Class.forName("com.android.internal.R$dimen");
            Object o = c.newInstance();
            Field field = c.getField("status_bar_height");
            int x = (Integer) field.get(o);
            statusBarHeight = context.getResources().getDimensionPixelSize(x);
        } catch (Exception e) {
            e.printStackTrace();
            if (context instanceof Activity) {
                Rect frame = new Rect();
                ((Activity) context).getWindow().getDecorView().getWindowVisibleDisplayFrame(frame);
                statusBarHeight = frame.top;
            }
        }
        return statusBarHeight;
    }


}

两个接口类：

public interface SwipeFinishAction extends SwipeFinishTouchCheckAction {

    void startScroll(int startX, int dx, boolean finish);

    void onTouchDown();

    void onScroll();

}

public interface SwipeFinishTouchCheckAction {

    /**
     * 向右滑动是否可关闭activity
     * @return
     */
    boolean onScrollToClose();

    /**
     * 是否点击横向滑动的view
     * @param rect
     * @param point
     * @return
     */
    boolean inChild(Rect rect, Point point);
}

如何使用，已经写在了两个Activity里面了，就是在setContentView之后，执行BaseSwipeFinishActivity里面的addSwipeFinishLayout()方法就行了，还需要把App的主题换一下，然后就可以了。非常之简单。

    <style name="AppTheme" parent="android:Theme.Light">
        //这里是颜色值为#00000000
        <item name="android:windowBackground">@color/transparent</item>
        <item name="android:windowIsTranslucent">true</item>
        <item name="android:windowNoTitle">true</item>
        <item name="android:splitMotionEvents">false</item>
        <item name="android:overScrollMode">never</item>
        <item name="android:scrollbars">none</item>
    </style>

附上demo下载地址

如果有大神，有更加好的集成方式，请在下边留言哈…