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

**遇到問(wèn)題：**如果在某個(gè)activity的主題style中設(shè)置了android:windowIsTranslucent屬性為true，那么該activity切換動(dòng)畫(huà)與沒(méi)設(shè)置之前是不同的，有些手機(jī)切換動(dòng)畫(huà)會(huì)變得非常跳。所以需要自定義activity的切換動(dòng)畫(huà)。
接下來(lái)我們會(huì)想到通過(guò)主題style里的windowAnimationStyle來(lái)設(shè)置切換動(dòng)畫(huà)

<item name="android:windowEnterAnimation">@anim/***</item>
<item name="android:windowExitAnimation">@anim/***</item>``

public class TranslucentHelper {
 private static final String TRANSLUCENT_STATE = "translucentState";
 private static final int INIT = 0;//表示初始
 private static final int CHANGE_STATE_FAIL = INIT + 1;//表示確認(rèn)不可以切換透明狀態(tài)
 private static final int CHANGE_STATE_SUCCEED = CHANGE_STATE_FAIL + 1;//表示確認(rèn)可以切換透明狀態(tài)
 private static int mTranslucentState = INIT;

 interface TranslucentListener {
  void onTranslucent();
 }

 private static class MyInvocationHandler implements InvocationHandler {
  private TranslucentListener listener;

  MyInvocationHandler(TranslucentListener listener) {
   this.listener = listener;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   try {
    boolean success = (boolean) args[0];
    if (success && listener != null) {
     listener.onTranslucent();
    }
   } catch (Exception ignored) {
   }
   return null;
  }
 }

 static boolean convertActivityFromTranslucent(Activity activity) {
  if (mTranslucentState == INIT) {
   mTranslucentState = PreferencesUtils.getInt(TRANSLUCENT_STATE, INIT);
  }
  if (mTranslucentState == INIT) {
   convertActivityToTranslucent(activity, null);
  } else if (mTranslucentState == CHANGE_STATE_FAIL) {
   return false;
  }

  try {
   Method method = Activity.class.getDeclaredMethod("convertFromTranslucent");
   method.setAccessible(true);
   method.invoke(activity);
   mTranslucentState = CHANGE_STATE_SUCCEED;
   return true;
  } catch (Throwable t) {
   mTranslucentState = CHANGE_STATE_FAIL;
   PreferencesUtils.saveInt(TRANSLUCENT_STATE, CHANGE_STATE_FAIL);
   return false;
  }
 }

 static void convertActivityToTranslucent(Activity activity, final TranslucentListener listener) {
  if (mTranslucentState == CHANGE_STATE_FAIL) {
   if (listener != null) {
    listener.onTranslucent();
   }
   return;
  }

  try {
   Class<?>[] classes = Activity.class.getDeclaredClasses();
   Class<?> translucentConversionListenerClazz = null;
   for (Class clazz : classes) {
    if (clazz.getSimpleName().contains("TranslucentConversionListener")) {
     translucentConversionListenerClazz = clazz;
    }
   }

   MyInvocationHandler myInvocationHandler = new MyInvocationHandler(listener);
   Object obj = Proxy.newProxyInstance(Activity.class.getClassLoader(),
     new Class[] { translucentConversionListenerClazz }, myInvocationHandler);

   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    Method getActivityOptions = Activity.class.getDeclaredMethod("getActivityOptions");
    getActivityOptions.setAccessible(true);
    Object options = getActivityOptions.invoke(activity);

    Method method = Activity.class.getDeclaredMethod("convertToTranslucent",
      translucentConversionListenerClazz, ActivityOptions.class);
    method.setAccessible(true);
    method.invoke(activity, obj, options);
   } else {
    Method method =
      Activity.class.getDeclaredMethod("convertToTranslucent", translucentConversionListenerClazz);
    method.setAccessible(true);
    method.invoke(activity, obj);
   }
   mTranslucentState = CHANGE_STATE_SUCCEED;
  } catch (Throwable t) {
   mTranslucentState = CHANGE_STATE_FAIL;
   PreferencesUtils.saveInt(TRANSLUCENT_STATE, CHANGE_STATE_FAIL);
   new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
     if (listener != null) {
      listener.onTranslucent();
     }
    }
   }, 100);
  }
 }
}

public abstract class SwipeBackActivity extends CoreBaseActivity {
 /**
  * 滑動(dòng)返回View
  */
 private SwipeBackLayout mSwipeBackLayout;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  if (!isSwipeBackDisableForever()) {
   TranslucentHelper.convertActivityFromTranslucent(this);
   mSwipeBackLayout = new SwipeBackLayout(this);
  }
 }

 @Override
 protected void onPostCreate(Bundle savedInstanceState) {
  super.onPostCreate(savedInstanceState);
  if (!isSwipeBackDisableForever()) {
   mSwipeBackLayout.attachToActivity(this);
   mSwipeBackLayout.setOnSwipeBackListener(new SwipeBackLayout.onSwipeBackListener() {
    @Override
    public void onStart() {
     onSwipeBackStart();
    }

    @Override
    public void onEnd() {
     onSwipeBackEnd();
    }
   });
  }
 }

 @Override
 public void onWindowFocusChanged(boolean hasFocus) {
  super.onWindowFocusChanged(hasFocus);
  if (!isSwipeBackDisableForever() && hasFocus) {
   getSwipeBackLayout().recovery();
  }
 }

 /**
  * 滑動(dòng)返回開(kāi)始時(shí)的回調(diào)
  */
 protected void onSwipeBackStart() {}

 /**
  * 滑動(dòng)返回結(jié)束時(shí)的回調(diào)
  */
 protected void onSwipeBackEnd() {}

 /**
  * 設(shè)置是否可以邊緣滑動(dòng)返回，需要在onCreate方法調(diào)用
  */
 public void setSwipeBackEnable(boolean enable) {
  if (mSwipeBackLayout != null) {
   mSwipeBackLayout.setSwipeBackEnable(enable);
  }
 }

 public boolean isSwipeBackDisableForever() {
  return false;
 }

 public SwipeBackLayout getSwipeBackLayout() {
  return mSwipeBackLayout;
 }
}

/**
 * 滑動(dòng)返回容器類(lèi)
 */
public class SwipeBackLayout extends FrameLayout {
 /**
  * 滑動(dòng)銷(xiāo)毀距離比例界限，滑動(dòng)部分的比例超過(guò)這個(gè)就銷(xiāo)毀
  */
 private static final float DEFAULT_SCROLL_THRESHOLD = 0.5f;
 /**
  * 滑動(dòng)銷(xiāo)毀速度界限，超過(guò)這個(gè)速度就銷(xiāo)毀
  */
 private static final float DEFAULT_VELOCITY_THRESHOLD = ScreenUtils.dpToPx(250);
 /**
  * 最小滑動(dòng)速度
  */
 private static final int MIN_FLING_VELOCITY = ScreenUtils.dpToPx(200);
 /**
  * 左邊移動(dòng)的像素值
  */
 private int mContentLeft;
 /**
  * 左邊移動(dòng)的像素值 / （ContentView的寬+陰影）
  */
 private float mScrollPercent;
 /**
  * （ContentView可見(jiàn)部分+陰影）的比例 （即1 - mScrollPercent）
  */
 private float mContentPercent;
 /**
  * 陰影圖
  */
 private Drawable mShadowDrawable;
 /**
  * 陰影圖的寬
  */
 private int mShadowWidth;
 /**
  * 內(nèi)容view，DecorView的原第一個(gè)子view
  */
 private View mContentView;
 /**
  * 用于記錄ContentView所在的矩形
  */
 private Rect mContentViewRect = new Rect();
 /**
  * 設(shè)置是否可滑動(dòng)
  */
 private boolean mIsSwipeBackEnable = true;
 /**
  * 是否正在放置
  */
 private boolean mIsLayout = true;
 /**
  * 判斷背景Activity是否啟動(dòng)進(jìn)入動(dòng)畫(huà)
  */
 private boolean mIsEnterAnimRunning = false;
 /**
  * 是否是透明的
  */
 private boolean mIsActivityTranslucent = false;
 /**
  * 進(jìn)入動(dòng)畫(huà)(只在釋放手指時(shí)使用)
  */
 private ObjectAnimator mEnterAnim;
 /**
  * 退拽助手類(lèi)
  */
 private SwipeBackLayoutDragHelper mViewDragHelper;
 /**
  * 執(zhí)行滑動(dòng)時(shí)的最頂層Activity
  */
 private Activity mTopActivity;
 /**
  * 后面的Activity的弱引用
  */
 private WeakReference<Activity> mBackActivityWeakRf;
 /**
  * 監(jiān)聽(tīng)滑動(dòng)開(kāi)始和結(jié)束
  */
 private onSwipeBackListener mListener;

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

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

 public SwipeBackLayout(Context context, AttributeSet attrs, int defStyleAttr) {
  super(context, attrs, defStyleAttr);
  init(context);
 }

 private void init(Context context) {
  mViewDragHelper = SwipeBackLayoutDragHelper.create(SwipeBackLayout.this, new ViewDragCallback());
  mViewDragHelper.setEdgeTrackingEnabled(SwipeBackLayoutDragHelper.EDGE_LEFT);
  mViewDragHelper.setMinVelocity(MIN_FLING_VELOCITY);
  mViewDragHelper.setMaxVelocity(MIN_FLING_VELOCITY * 2);
  try {
   mShadowDrawable = context.getResources().getDrawable(R.drawable.swipeback_shadow_left);
  } catch (Exception ignored) {
  }
 }

 @Override
 protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
  try {
   if (!mIsSwipeBackEnable) {
    super.onLayout(changed, left, top, right, bottom);
    return;
   }
   mIsLayout = true;
   if (mContentView != null) {
    mContentView.layout(mContentLeft, top, mContentLeft + mContentView.getMeasuredWidth(),
      mContentView.getMeasuredHeight());
   }
   mIsLayout = false;
  } catch (Exception e) {
   super.onLayout(changed, left, top, right, bottom);
  }
 }

 @Override
 public void requestLayout() {
  if (!mIsLayout || !mIsSwipeBackEnable) {
   super.requestLayout();
  }
 }

 @Override
 protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
  try {
   //繪制陰影
   if (mContentPercent > 0
     && mShadowDrawable != null
     && child == mContentView
     && mViewDragHelper.getViewDragState() != SwipeBackLayoutDragHelper.STATE_IDLE) {
    child.getHitRect(mContentViewRect);
    mShadowWidth = mShadowDrawable.getIntrinsicWidth();
    mShadowDrawable.setBounds(mContentViewRect.left - mShadowWidth, mContentViewRect.top,
      mContentViewRect.left, mContentViewRect.bottom);
    mShadowDrawable.draw(canvas);
   }
   return super.drawChild(canvas, child, drawingTime);
  } catch (Exception e) {
   return super.drawChild(canvas, child, drawingTime);
  }
 }

 @Override
 public void computeScroll() {
  mContentPercent = 1 - mScrollPercent;
  if (mViewDragHelper.continueSettling(true)) {
   ViewCompat.postInvalidateOnAnimation(this);
  }
 }

 @Override
 public boolean onInterceptTouchEvent(MotionEvent event) {
  if (!mIsSwipeBackEnable) {
   return false;
  }
  try {
   return mViewDragHelper.shouldInterceptTouchEvent(event);
  } catch (ArrayIndexOutOfBoundsException e) {
   return super.onInterceptTouchEvent(event);
  }
 }

 @Override
 public boolean onTouchEvent(MotionEvent event) {
  if (!mIsSwipeBackEnable) {
   return false;
  }
  try {
   mViewDragHelper.processTouchEvent(event);
   return true;
  } catch (Exception e) {
   return super.onTouchEvent(event);
  }
 }

 /**
  * 將View添加到Activity
  */
 public void attachToActivity(Activity activity) {
  //插入SwipeBackLayout
  ViewGroup decor = (ViewGroup) activity.getWindow().getDecorView();
  ViewGroup decorChild = (ViewGroup) decor.getChildAt(0);
  decor.removeView(decorChild);
  if (getParent() != null) {
   decor.removeView(this);
  }
  decor.addView(this);
  this.removeAllViews();
  this.addView(decorChild);

  //mContentView為SwipeBackLayout的直接子view,獲取window背景色進(jìn)行賦值
  activity.getWindow().setBackgroundDrawableResource(R.color.transparent_white);
  TypedArray a = activity.getTheme().obtainStyledAttributes(new int[] {
    android.R.attr.windowBackground
  });
  mContentView = decorChild;
  mContentView.setBackgroundResource(a.getResourceId(0, 0));
  a.recycle();

  //拿到頂層activity和下層activity，做聯(lián)動(dòng)操作
  mTopActivity = activity;
  Activity backActivity = ActivityUtils.getSecondTopActivity();
  if (backActivity != null && backActivity instanceof SwipeBackActivity) {
   if (!((SwipeBackActivity) backActivity).isSwipeBackDisableForever()) {
    mBackActivityWeakRf = new WeakReference<>(backActivity);
   }
  }
 }

 /**
  * 設(shè)置是否可以滑動(dòng)返回
  */
 public void setSwipeBackEnable(boolean enable) {
  mIsSwipeBackEnable = enable;
 }

 public boolean isActivityTranslucent() {
  return mIsActivityTranslucent;
 }

 /**
  * 啟動(dòng)進(jìn)入動(dòng)畫(huà)
  */
 private void startEnterAnim() {
  if (mContentView != null) {
   ObjectAnimator anim =
     ObjectAnimator.ofFloat(mContentView, "TranslationX", mContentView.getTranslationX(), 0f);
   anim.setDuration((long) (125 * mContentPercent));
   mEnterAnim = anim;
   mEnterAnim.start();
  }
 }

 protected View getContentView() {
  return mContentView;
 }

 private class ViewDragCallback extends SwipeBackLayoutDragHelper.Callback {
  @Override
  public boolean tryCaptureView(View child, int pointerId) {
   if (mIsSwipeBackEnable && mViewDragHelper.isEdgeTouched(SwipeBackLayoutDragHelper.EDGE_LEFT, pointerId)) {
    TranslucentHelper.convertActivityToTranslucent(mTopActivity,
      new TranslucentHelper.TranslucentListener() {
       @Override
       public void onTranslucent() {
        if (mListener != null) {
         mListener.onStart();
        }
        mIsActivityTranslucent = true;
       }
      });
    return true;
   }
   return false;
  }

  @Override
  public int getViewHorizontalDragRange(View child) {
   return mIsSwipeBackEnable ? SwipeBackLayoutDragHelper.EDGE_LEFT : 0;
  }

  @Override
  public void onViewPositionChanged(View changedView, int left, int top, int dx, int dy) {
   super.onViewPositionChanged(changedView, left, top, dx, dy);
   if (changedView == mContentView) {
    mScrollPercent = Math.abs((float) left / mContentView.getWidth());
    mContentLeft = left;
    //未執(zhí)行動(dòng)畫(huà)就平移
    if (!mIsEnterAnimRunning) {
     moveBackActivity();
    }
    invalidate();
    if (mScrollPercent >= 1 && !mTopActivity.isFinishing()) {
     if (mBackActivityWeakRf != null && ActivityUtils.activityIsAlive(mBackActivityWeakRf.get())) {
      ((SwipeBackActivity) mBackActivityWeakRf.get()).getSwipeBackLayout().invalidate();
     }
     mTopActivity.finish();
     mTopActivity.overridePendingTransition(0, 0);
    }
   }
  }

  @Override
  public void onViewReleased(View releasedChild, float xvel, float yvel) {
   if (xvel > DEFAULT_VELOCITY_THRESHOLD || mScrollPercent > DEFAULT_SCROLL_THRESHOLD) {
    if (mIsActivityTranslucent) {
     mViewDragHelper.settleCapturedViewAt(releasedChild.getWidth() + mShadowWidth, 0);
     if (mContentPercent < 0.85f) {
      startAnimOfBackActivity();
     }
    }
   } else {
    mViewDragHelper.settleCapturedViewAt(0, 0);
   }
   if (mListener != null) {
    mListener.onEnd();
   }
   invalidate();
  }

  @Override
  public int clampViewPositionHorizontal(View child, int left, int dx) {
   return Math.min(child.getWidth(), Math.max(left, 0));
  }

  @Override
  public void onViewDragStateChanged(int state) {
   super.onViewDragStateChanged(state);

   if (state == SwipeBackLayoutDragHelper.STATE_IDLE && mScrollPercent < 1f) {
    TranslucentHelper.convertActivityFromTranslucent(mTopActivity);
    mIsActivityTranslucent = false;
   }
  }

  @Override
  public boolean isTranslucent() {
   return SwipeBackLayout.this.isActivityTranslucent();
  }
 }

 /**
  * 背景Activity開(kāi)始進(jìn)入動(dòng)畫(huà)
  */
 private void startAnimOfBackActivity() {
  if (mBackActivityWeakRf != null && ActivityUtils.activityIsAlive(mBackActivityWeakRf.get())) {
   mIsEnterAnimRunning = true;
   SwipeBackLayout swipeBackLayout = ((SwipeBackActivity) mBackActivityWeakRf.get()).getSwipeBackLayout();
   swipeBackLayout.startEnterAnim();
  }
 }

 /**
  * 移動(dòng)背景Activity
  */
 private void moveBackActivity() {
  if (mBackActivityWeakRf != null && ActivityUtils.activityIsAlive(mBackActivityWeakRf.get())) {
   View view = ((SwipeBackActivity) mBackActivityWeakRf.get()).getSwipeBackLayout().getContentView();
   if (view != null) {
    int width = view.getWidth();
    view.setTranslationX(-width * 0.3f * Math.max(0f, mContentPercent - 0.15f));
   }
  }
 }

 /**
  * 回復(fù)界面的平移到初始位置
  */
 public void recovery() {
  if (mEnterAnim != null && mEnterAnim.isRunning()) {
   mEnterAnim.end();
  } else {
   mContentView.setTranslationX(0);
  }
 }

 interface onSwipeBackListener {
  void onStart();

  void onEnd();
 }

 public void setOnSwipeBackListener(onSwipeBackListener listener) {
  mListener = listener;
 }
}

private void dragTo(int left, int top, int dx, int dy) {
    int clampedX = left;
    int clampedY = top;
    final int oldLeft = mCapturedView.getLeft();
    final int oldTop = mCapturedView.getTop();
    if (dx != 0) {
      clampedX = mCallback.clampViewPositionHorizontal(mCapturedView, left, dx);
      if (mCallback.isTranslucent()) {
        ViewCompat.offsetLeftAndRight(mCapturedView, clampedX - oldLeft);
      }
    }
    if (dy != 0) {
      clampedY = mCallback.clampViewPositionVertical(mCapturedView, top, dy);
      ViewCompat.offsetTopAndBottom(mCapturedView, clampedY - oldTop);
    }

    if (dx != 0 || dy != 0) {
      final int clampedDx = clampedX - oldLeft;
      final int clampedDy = clampedY - oldTop;
      if (mCallback.isTranslucent()) {
        mCallback.onViewPositionChanged(mCapturedView, clampedX, clampedY,
            clampedDx, clampedDy);
      }
    }
  }