【android】侧滑关闭activity

最近在使用IOS系统的时候，发现侧滑关闭很实用，因为单手就可以操作，不需要点击左上角的回退按钮、或者返回键了。

所以打算在android上实现这个技术。

需求：

1：IOS只能在屏幕边缘开始，往中间进行侧滑才能关闭；我们希望触发点可以在任意位置。

2：对现有代码入侵尽可能下，简单配置下就可以实现这个功能。

实战参考：请参考本人的博客园项目

参考了GitHub上一个开源框架，优化后形成现有的框架

下面是其实现原理，总结的很到位，做了部分修改

Android activity滑动返回原理

像fragment一样，activity本身是不可以滑动的，但是我们可以制造一个正在滑动activity的假象，使得看起来这个activity正在被手指滑动。

其原理其实很简单，我们滑动的其实是activity里面的可见view元素，而我们将activity设置为透明的，这样当view滑过的时候，由于activity的底部是透明的，我们就可以在滑动过程中看到下面的activity，这样看起来就是在滑动activity。

所以activity滑动效果分两步，1，设置透明，2，滑动view

设置透明： 很简单，建立一个Style，在Style里面添加下面两行并将这个style应用在activity上就可以了

<item name="android:windowBackground">@*android:color/transparent</item>
<item name="android:windowIsTranslucent">true</item>

先看看activity的层次结构：

我们用的activity的xml的根view并不是activity的根view，在它上面还有一个父view，id是android.R.id.content，再向上一层，还有一个view，它是一个LinearLayout，

它除了放置我们创建的view之外，还放置我们的xml之外的一些东西比如放ActionBar什么的。而再往上一级，就到了activity的根view——DecorView。

如下图



要做到像iOS那样可以滑动整个activity，只滑动我们在xml里面创建的view显然是不对的

因为我们还有ActionBar什么的，所以我们要滑动的应该是DecorView或者倒数第二层的那个view。

而要滑动view的话，我们要重写其父窗口的onInterceptTouchEvent以及onTouchEvent【当然使用setOnTouchListener不是不可能，但是如果子view里面有一个消费了onTouch事件，那么也就接收不到了】，但是窗口的创建过程不是我们能控制的，DecorView的创建都不是我们能干预的。

解决办法就是，我们自己创建一个SwipeLayout，然后人为地插入顶层view中，放置在DecorView和其下面的LinearLayout中间，随着手指的滑动，不断改变SwipeLayout的子view——曾经是DecorView的子view——的位置，

这样我们就可以控制activity的滑动啦。我们在activity的onPostCreate方法中调用swipeLayout.replaceLayer替换我们的SwipeLayout，代码如下

/**
* 将本view注入到decorView的子view上
* 在{@link Activity#onPostCreate(Bundle)}里使用本方法注入
*/
public void injectWindow() {
if (mIsInjected)
return;

final ViewGroup root = (ViewGroup) mActivity.getWindow().getDecorView();
mContent = root.getChildAt(0);
root.removeView(mContent);
this.addView(mContent, new ViewGroup.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
root.addView(this);
mIsInjected = true;
}

然后我们把这些写成一个SwipeActivity，其它activity只要继承这个SwipeActivity就可以实现滑动返回功能（当然Style仍然要设置的） 这里只说滑动activity的原理，剩下的都是控制滑动的事了，详见代码

BTW，滑动Fragment原理其实一样，只不过更加简单，Fragment在view树中就是它inflate的元素，用fragment.getView可以取得，滑动fragment其实滑动的就是fragment.getView。只要把滑动方法写在它父view中就可以了

在实际使用中，我们发现，当你把Activity背景色设置为透明之后，原先设置的Activity进入、退出动画效果就消失了

原因是因为透明背景色、Translucent的Activity，它的动画体系和有背景色的Activity是不同的，看下面代码的parent部分

<!-- 日间模式，透明 -->
<style name="AppTheme.day.transparent" parent="AppTheme.day">
<item name="android:windowBackground">@android:color/transparent</item>
<item name="android:windowIsTranslucent">true</item>
<item name="android:windowAnimationStyle">@style/transparentAnimation</item>
</style>

<!--普通有底色的Activity动画-->
<style name="normalAnimation" parent="@android:style/Animation.Activity">
<item name="android:activityOpenEnterAnimation">@anim/slide_right_in</item>
<item name="android:activityOpenExitAnimation">@anim/slide_left_out</item>
<item name="android:activityCloseEnterAnimation">@anim/slide_left_in</item>
<item name="android:activityCloseExitAnimation">@anim/slide_right_out</item>
</style>
<!--透明的Activity动画-->
<style name="transparentAnimation" parent="@android:style/Animation.Translucent">
<item name="android:windowEnterAnimation">@anim/slide_right_in</item>
<item name="android:windowExitAnimation">@anim/slide_right_out</item>
</style>

其他也没啥好说的了，直接看代码吧

package zhexian.learn.cnblogs.ui;

import android.animation.Animator;
import android.animation.ObjectAnimator;
import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.DecelerateInterpolator;
import android.widget.FrameLayout;

import zhexian.learn.cnblogs.R;

/**
* 侧滑关闭的布局，使用方式
* 在目标容器的onCreate里面创建本布局 {@link #SwipeCloseLayout(Context)}
* 在目标容器的onPostCreate里面将本布局挂载到decorView下{@link #injectWindow()}
* Created by 陈俊杰 on 2016/2/16.
*/
public class SwipeCloseLayout extends FrameLayout {
private static final int ANIMATION_DURATION = 200;

/**
* 是否可以滑动关闭页面
*/
private boolean mSwipeEnabled = true;
private boolean mIsAnimationFinished = true;
private boolean mCanSwipe = false;
private boolean mIgnoreSwipe = false;
private boolean mHasIgnoreFirstMove;

private Activity mActivity;
private VelocityTracker tracker;
private ObjectAnimator mAnimator;
private Drawable mLeftShadow;
private View mContent;
private int mScreenWidth;
private int touchSlopLength;
private float mDownX;
private float mDownY;
private float mLastX;
private float mCurrentX;
private int mPullMaxLength;
private boolean mIsInjected;

public SwipeCloseLayout(Context context) {
this(context, null, 0);
}

public SwipeCloseLayout(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}

public SwipeCloseLayout(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
mActivity = (Activity) context;
mLeftShadow = context.getResources().getDrawable(R.drawable.left_shadow);
DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
touchSlopLength = (int) (20 * displayMetrics.density);
touchSlopLength *= touchSlopLength;
mScreenWidth = displayMetrics.widthPixels;
mPullMaxLength = (int) (mScreenWidth * 0.33f);
setClickable(true);
}

/**
* 将本view注入到decorView的子view上
* 在{@link Activity#onPostCreate(Bundle)}里使用本方法注入
*/
public void injectWindow() {
if (mIsInjected)
return;

final ViewGroup root = (ViewGroup) mActivity.getWindow().getDecorView();
mContent = root.getChildAt(0);
root.removeView(mContent);
this.addView(mContent, new ViewGroup.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
root.addView(this);
mIsInjected = true;
}

public boolean isSwipeEnabled() {
return mSwipeEnabled;
}

public void setSwipeEnabled(boolean swipeEnabled) {
this.mSwipeEnabled = swipeEnabled;
}

@Override
protected boolean drawChild(@NonNull Canvas canvas, @NonNull View child, long drawingTime) {
boolean result = super.drawChild(canvas, child, drawingTime);
final int shadowWidth = mLeftShadow.getIntrinsicWidth();
int left = (int) (getContentX()) - shadowWidth;
mLeftShadow.setBounds(left, child.getTop(), left + shadowWidth, child.getBottom());
mLeftShadow.draw(canvas);
return result;
}

@Override
public boolean dispatchTouchEvent(@NonNull MotionEvent ev) {
if (mSwipeEnabled && !mCanSwipe && !mIgnoreSwipe) {
switch (ev.getAction()) {
case MotionEvent.ACTION_DOWN:
mDownX = ev.getX();
mDownY = ev.getY();
mCurrentX = mDownX;
mLastX = mDownX;
break;
case MotionEvent.ACTION_MOVE:
float dx = ev.getX() - mDownX;
float dy = ev.getY() - mDownY;
if (dx * dx + dy * dy > touchSlopLength) {
if (dy == 0f || Math.abs(dx / dy) > 1) {
mDownX = ev.getX();
mDownY = ev.getY();
mCurrentX = mDownX;
mLastX = mDownX;
mCanSwipe = true;
tracker = VelocityTracker.obtain();
return true;
} else {
mIgnoreSwipe = true;
}
}
break;
}
}
if (ev.getAction() == MotionEvent.ACTION_UP || ev.getAction() == MotionEvent.ACTION_CANCEL) {
mIgnoreSwipe = false;
}
return super.dispatchTouchEvent(ev);
}

@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
return mCanSwipe || super.onInterceptTouchEvent(ev);
}

@Override
public boolean onTouchEvent(@NonNull MotionEvent event) {
if (mCanSwipe) {
tracker.addMovement(event);
int action = event.getAction();
switch (action) {
case MotionEvent.ACTION_DOWN:
mDownX = event.getX();
mCurrentX = mDownX;
mLastX = mDownX;
break;
case MotionEvent.ACTION_MOVE:
mCurrentX = event.getX();
float dx = mCurrentX - mLastX;
if (dx != 0f && !mHasIgnoreFirstMove) {
mHasIgnoreFirstMove = true;
dx = dx / dx;
}
if (getContentX() + dx < 0) {
setContentX(0);
} else {
setContentX(getContentX() + dx);
}
mLastX = mCurrentX;
break;
case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_CANCEL:
tracker.computeCurrentVelocity(10000);
tracker.computeCurrentVelocity(1000, 20000);
mCanSwipe = false;
mHasIgnoreFirstMove = false;
int mv = mScreenWidth * 3;
if (Math.abs(tracker.getXVelocity()) > mv) {
animateFromVelocity(tracker.getXVelocity());
} else {
if (getContentX() > mPullMaxLength) {
animateFinish(false);
} else {
animateBack(false);
}
}
tracker.recycle();
break;
default:
break;
}
}
return super.onTouchEvent(event);
}

public void cancelPotentialAnimation() {
if (mAnimator != null) {
mAnimator.removeAllListeners();
mAnimator.cancel();
}
}

public float getContentX() {
return mContent.getX();
}

private void setContentX(float x) {
mContent.setX(x);
invalidate();
}

public boolean isAnimationFinished() {
return mIsAnimationFinished;
}

/**
* 弹回，不关闭，因为left是0，所以setX和setTranslationX效果是一样的
*
* @param withVel 使用计算出来的时间
*/
private void animateBack(boolean withVel) {
cancelPotentialAnimation();
mAnimator = ObjectAnimator.ofFloat(this, "contentX", getContentX(), 0);
int tmpDuration = withVel ? ((int) (ANIMATION_DURATION * getContentX() / mScreenWidth)) : ANIMATION_DURATION;
if (tmpDuration < 100) {
tmpDuration = 100;
}
mAnimator.setDuration(tmpDuration);
mAnimator.setInterpolator(new DecelerateInterpolator());
mAnimator.start();
}

private void animateFinish(boolean withVel) {
cancelPotentialAnimation();
mAnimator = ObjectAnimator.ofFloat(this, "contentX", getContentX(), mScreenWidth);
int tmpDuration = withVel ? ((int) (ANIMATION_DURATION * (mScreenWidth - getContentX()) / mScreenWidth)) : ANIMATION_DURATION;
if (tmpDuration < 100) {
tmpDuration = 100;
}
mAnimator.setDuration(tmpDuration);
mAnimator.setInterpolator(new DecelerateInterpolator());
mAnimator.addListener(new Animator.AnimatorListener() {

@Override
public void onAnimationStart(Animator animation) {
mIsAnimationFinished = false;
}

@Override
public void onAnimationRepeat(Animator animation) {

}

@Override
public void onAnimationEnd(Animator animation) {
mIsAnimationFinished = true;
if (!mActivity.isFinishing()) {
mActivity.finish();
}
}

@Override
public void onAnimationCancel(Animator animation) {
mIsAnimationFinished = true;
}
});
mAnimator.start();
}

private void animateFromVelocity(float v) {
int currentX = (int) getContentX();
if (v > 0) {
if (currentX < mPullMaxLength && v * ANIMATION_DURATION / 1000 + currentX < mPullMaxLength) {
animateBack(false);
} else {
animateFinish(true);
}
} else {
if (currentX > mPullMaxLength / 3 && v * ANIMATION_DURATION / 1000 + currentX > mPullMaxLength) {
animateFinish(false);
} else {
animateBack(true);
}
}
}

public void finish() {
if (!isAnimationFinished()) {
cancelPotentialAnimation();
}
}
}