From 2fda8d12d2929505711396276468e15fb58e3621 Mon Sep 17 00:00:00 2001
From: yangchong <yangchong211@163.com>
Date: Mon, 20 Dec 2021 22:30:32 +0800
Subject: [PATCH] =?UTF-8?q?=E5=AE=8C=E5=96=84=E4=BB=A3=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .gitignore                                    |    3 +-
 .idea/gradle.xml                              |    1 +
 .idea/modules.xml                             |    1 +
 Widget/BannerWidget/.gitignore                |    1 +
 Widget/SwipeBackLib/.gitignore                |   76 +
 Widget/SwipeBackLib/.idea/.gitignore          |    0
 Widget/SwipeBackLib/.idea/gradle.xml          |   13 +
 Widget/SwipeBackLib/.idea/misc.xml            |    9 +
 Widget/SwipeBackLib/.idea/modules.xml         |    8 +
 .../SwipeBackLib/.idea/runConfigurations.xml  |   10 +
 Widget/SwipeBackLib/.idea/workspace.xml       |   40 +
 Widget/SwipeBackLib/build.gradle              |   23 +
 Widget/SwipeBackLib/consumer-rules.pro        |    0
 Widget/SwipeBackLib/proguard-rules.pro        |   21 +
 .../SwipeBackLib/src/main/AndroidManifest.xml |    1 +
 .../java/com/yc/swipe/ISwipeDelegate.java     |   28 +
 .../java/com/yc/swipe/SwipeBackHelper.java    |  325 +++
 .../java/com/yc/swipe/SwipeBackLayout.java    | 1823 +++++++++++++++++
 .../java/com/yc/swipe/SwipeBackManager.java   |  115 ++
 .../com/yc/swipe/SwipeBackShadowView.java     |  287 +++
 .../java/com/yc/swipe/SwipeKeyboardUtil.java  |  117 ++
 .../main/java/com/yc/swipe/SwipeUiUtils.java  |  137 ++
 .../anim/swipe_activity_backward_enter.xml    |    7 +
 .../res/anim/swipe_activity_backward_exit.xml |    7 +
 .../res/anim/swipe_activity_forward_enter.xml |    7 +
 .../res/anim/swipe_activity_forward_exit.xml  |    7 +
 .../anim/swipe_activity_swipeback_enter.xml   |    7 +
 .../anim/swipe_activity_swipeback_exit.xml    |    7 +
 .../src/main/res/drawable/swipe_shadow.9.png  |  Bin 0 -> 300 bytes
 app/.gitignore                                |    1 +
 settings.gradle                               |    4 +-
 31 files changed, 3084 insertions(+), 2 deletions(-)
 create mode 100644 Widget/SwipeBackLib/.gitignore
 create mode 100644 Widget/SwipeBackLib/.idea/.gitignore
 create mode 100644 Widget/SwipeBackLib/.idea/gradle.xml
 create mode 100644 Widget/SwipeBackLib/.idea/misc.xml
 create mode 100644 Widget/SwipeBackLib/.idea/modules.xml
 create mode 100644 Widget/SwipeBackLib/.idea/runConfigurations.xml
 create mode 100644 Widget/SwipeBackLib/.idea/workspace.xml
 create mode 100644 Widget/SwipeBackLib/build.gradle
 create mode 100644 Widget/SwipeBackLib/consumer-rules.pro
 create mode 100644 Widget/SwipeBackLib/proguard-rules.pro
 create mode 100644 Widget/SwipeBackLib/src/main/AndroidManifest.xml
 create mode 100644 Widget/SwipeBackLib/src/main/java/com/yc/swipe/ISwipeDelegate.java
 create mode 100644 Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackHelper.java
 create mode 100644 Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackLayout.java
 create mode 100644 Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackManager.java
 create mode 100644 Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackShadowView.java
 create mode 100644 Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeKeyboardUtil.java
 create mode 100644 Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeUiUtils.java
 create mode 100644 Widget/SwipeBackLib/src/main/res/anim/swipe_activity_backward_enter.xml
 create mode 100644 Widget/SwipeBackLib/src/main/res/anim/swipe_activity_backward_exit.xml
 create mode 100644 Widget/SwipeBackLib/src/main/res/anim/swipe_activity_forward_enter.xml
 create mode 100644 Widget/SwipeBackLib/src/main/res/anim/swipe_activity_forward_exit.xml
 create mode 100644 Widget/SwipeBackLib/src/main/res/anim/swipe_activity_swipeback_enter.xml
 create mode 100644 Widget/SwipeBackLib/src/main/res/anim/swipe_activity_swipeback_exit.xml
 create mode 100644 Widget/SwipeBackLib/src/main/res/drawable/swipe_shadow.9.png

diff --git a/.gitignore b/.gitignore
index c7ee9658f..067b13c72 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,4 +6,5 @@
 .DS_Store
 /build
 /captures
-.externalNativeBuild
\ No newline at end of file
+.externalNativeBuild
+.idea/
\ No newline at end of file
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 5a5c2db86..d1fae5ecc 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -41,6 +41,7 @@
             <option value="$PROJECT_DIR$/Widget/FragmentLib" />
             <option value="$PROJECT_DIR$/Widget/LargeImageLib" />
             <option value="$PROJECT_DIR$/Widget/PhotoWidget" />
+            <option value="$PROJECT_DIR$/Widget/SwipeBackLib" />
             <option value="$PROJECT_DIR$/Widget/WidgetViewLib" />
             <option value="$PROJECT_DIR$/Widget/ZoomImageLib" />
             <option value="$PROJECT_DIR$/app" />
diff --git a/.idea/modules.xml b/.idea/modules.xml
index c2d4a9f65..f8099ad3e 100644
--- a/.idea/modules.xml
+++ b/.idea/modules.xml
@@ -22,6 +22,7 @@
       <module fileurl="file://$PROJECT_DIR$/.idea/modules/widget/PhotoWidget/LifeHelper.PhotoWidget.iml" filepath="$PROJECT_DIR$/.idea/modules/widget/PhotoWidget/LifeHelper.PhotoWidget.iml" />
       <module fileurl="file://$PROJECT_DIR$/.idea/modules/server/ServerInterface/LifeHelper.ServerInterface.iml" filepath="$PROJECT_DIR$/.idea/modules/server/ServerInterface/LifeHelper.ServerInterface.iml" />
       <module fileurl="file://$PROJECT_DIR$/.idea/modules/server/ShareServer/LifeHelper.ShareServer.iml" filepath="$PROJECT_DIR$/.idea/modules/server/ShareServer/LifeHelper.ShareServer.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/modules/library/LifeHelper.SwipeBackLib.iml" filepath="$PROJECT_DIR$/.idea/modules/library/LifeHelper.SwipeBackLib.iml" />
       <module fileurl="file://$PROJECT_DIR$/.idea/modules/common/ToolUtilsLib/LifeHelper.ToolUtilsLib.iml" filepath="$PROJECT_DIR$/.idea/modules/common/ToolUtilsLib/LifeHelper.ToolUtilsLib.iml" />
       <module fileurl="file://$PROJECT_DIR$/.idea/modules/business/VideoBusiness/LifeHelper.VideoBusiness.iml" filepath="$PROJECT_DIR$/.idea/modules/business/VideoBusiness/LifeHelper.VideoBusiness.iml" />
       <module fileurl="file://$PROJECT_DIR$/.idea/modules/server/XlogServer/LifeHelper.XlogServer.iml" filepath="$PROJECT_DIR$/.idea/modules/server/XlogServer/LifeHelper.XlogServer.iml" />
diff --git a/Widget/BannerWidget/.gitignore b/Widget/BannerWidget/.gitignore
index c105a4fe1..60d929df9 100644
--- a/Widget/BannerWidget/.gitignore
+++ b/Widget/BannerWidget/.gitignore
@@ -12,6 +12,7 @@
 /captures
 .externalNativeBuild
 .cxx
+.idea/
 
 
 
diff --git a/Widget/SwipeBackLib/.gitignore b/Widget/SwipeBackLib/.gitignore
new file mode 100644
index 000000000..60d929df9
--- /dev/null
+++ b/Widget/SwipeBackLib/.gitignore
@@ -0,0 +1,76 @@
+*.iml
+.gradle
+/local.properties
+/.idea/caches
+/.idea/libraries
+/.idea/modules.xml
+/.idea/workspace.xml
+/.idea/navEditor.xml
+/.idea/assetWizardSettings.xml
+.DS_Store
+/build
+/captures
+.externalNativeBuild
+.cxx
+.idea/
+
+
+
+# Built application files
+*.apk
+*.ap_
+
+# Files for the ART/Dalvik VM
+*.dex
+
+# Java class files
+*.class
+
+# Generated files
+bin/
+gen/
+out/
+
+# Gradle files
+.gradle/
+build/
+
+# Local configuration file (sdk path, etc)
+local.properties
+
+# Proguard folder generated by Eclipse
+proguard/
+
+# Log Files
+*.log
+
+# Android Studio Navigation editor temp files
+.navigation/
+
+# Android Studio captures folder
+captures/
+
+# Intellij
+*.iml
+.idea/workspace.xml
+.idea/tasks.xml
+.idea/gradle.xml
+.idea/dictionaries
+.idea/libraries
+
+# Keystore files
+*.jks
+
+# External native build folder generated in Android Studio 2.2 and later
+.externalNativeBuild
+
+# Google Services (e.g. APIs or Firebase)
+google-services.json
+
+# Freeline
+freeline.py
+freeline/
+freeline_project_description.json
+.idea/
+
+
diff --git a/Widget/SwipeBackLib/.idea/.gitignore b/Widget/SwipeBackLib/.idea/.gitignore
new file mode 100644
index 000000000..e69de29bb
diff --git a/Widget/SwipeBackLib/.idea/gradle.xml b/Widget/SwipeBackLib/.idea/gradle.xml
new file mode 100644
index 000000000..3a3b9099e
--- /dev/null
+++ b/Widget/SwipeBackLib/.idea/gradle.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GradleSettings">
+    <option name="linkedExternalProjectsSettings">
+      <GradleProjectSettings>
+        <option name="testRunner" value="PLATFORM" />
+        <option name="distributionType" value="DEFAULT_WRAPPED" />
+        <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="resolveModulePerSourceSet" value="false" />
+      </GradleProjectSettings>
+    </option>
+  </component>
+</project>
\ No newline at end of file
diff --git a/Widget/SwipeBackLib/.idea/misc.xml b/Widget/SwipeBackLib/.idea/misc.xml
new file mode 100644
index 000000000..f84585426
--- /dev/null
+++ b/Widget/SwipeBackLib/.idea/misc.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/build/classes" />
+  </component>
+  <component name="ProjectType">
+    <option name="id" value="Android" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/Widget/SwipeBackLib/.idea/modules.xml b/Widget/SwipeBackLib/.idea/modules.xml
new file mode 100644
index 000000000..1415788de
--- /dev/null
+++ b/Widget/SwipeBackLib/.idea/modules.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/modules/library.iml" filepath="$PROJECT_DIR$/.idea/modules/library.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file
diff --git a/Widget/SwipeBackLib/.idea/runConfigurations.xml b/Widget/SwipeBackLib/.idea/runConfigurations.xml
new file mode 100644
index 000000000..797acea53
--- /dev/null
+++ b/Widget/SwipeBackLib/.idea/runConfigurations.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RunConfigurationProducerService">
+    <option name="ignoredProducers">
+      <set>
+        <option value="com.android.tools.idea.compose.preview.runconfiguration.ComposePreviewRunConfigurationProducer" />
+      </set>
+    </option>
+  </component>
+</project>
\ No newline at end of file
diff --git a/Widget/SwipeBackLib/.idea/workspace.xml b/Widget/SwipeBackLib/.idea/workspace.xml
new file mode 100644
index 000000000..29138e9b1
--- /dev/null
+++ b/Widget/SwipeBackLib/.idea/workspace.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="NONE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="28edf22c-b9ef-4a57-90f8-b909c12cef44" name="Default Changelist" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="ProjectId" id="22YLMcINCRMOPBrUxzjmpBvoUup" />
+  <component name="ProjectViewState">
+    <option name="showExcludedFiles" value="false" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent">
+    <property name="RunOnceActivity.OpenProjectViewOnStart" value="true" />
+    <property name="android.sdk.path" value="$USER_HOME$/Library/Android/sdk" />
+    <property name="dart.analysis.tool.window.visible" value="false" />
+    <property name="last_opened_file_path" value="$PROJECT_DIR$" />
+    <property name="project.structure.last.edited" value="SDK Location" />
+    <property name="project.structure.proportion" value="0.17" />
+    <property name="project.structure.side.proportion" value="0.0" />
+    <property name="settings.editor.selected.configurable" value="AndroidSdkUpdater" />
+    <property name="show.migrate.to.gradle.popup" value="false" />
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="28edf22c-b9ef-4a57-90f8-b909c12cef44" name="Default Changelist" comment="" />
+      <created>1640009528552</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1640009528552</updated>
+    </task>
+    <servers />
+  </component>
+</project>
\ No newline at end of file
diff --git a/Widget/SwipeBackLib/build.gradle b/Widget/SwipeBackLib/build.gradle
new file mode 100644
index 000000000..e70c14587
--- /dev/null
+++ b/Widget/SwipeBackLib/build.gradle
@@ -0,0 +1,23 @@
+apply plugin: 'com.android.library'
+apply plugin: 'com.github.dcendents.android-maven'
+apply from: rootProject.projectDir.absolutePath + "/yc.gradle"
+
+android {
+    compileSdkVersion rootProject.ext.android["compileSdkVersion"]
+    buildToolsVersion rootProject.ext.android["buildToolsVersion"]
+
+    defaultConfig {
+        minSdkVersion rootProject.ext.android["minSdkVersion"]
+        targetSdkVersion rootProject.ext.android["targetSdkVersion"]
+    }
+
+    lintOptions {
+        abortOnError false
+    }
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation(rootProject.ext.dependencies["appcompat-v7"])
+    implementation(rootProject.ext.dependencies["annotations"])
+}
diff --git a/Widget/SwipeBackLib/consumer-rules.pro b/Widget/SwipeBackLib/consumer-rules.pro
new file mode 100644
index 000000000..e69de29bb
diff --git a/Widget/SwipeBackLib/proguard-rules.pro b/Widget/SwipeBackLib/proguard-rules.pro
new file mode 100644
index 000000000..481bb4348
--- /dev/null
+++ b/Widget/SwipeBackLib/proguard-rules.pro
@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
\ No newline at end of file
diff --git a/Widget/SwipeBackLib/src/main/AndroidManifest.xml b/Widget/SwipeBackLib/src/main/AndroidManifest.xml
new file mode 100644
index 000000000..6110f7123
--- /dev/null
+++ b/Widget/SwipeBackLib/src/main/AndroidManifest.xml
@@ -0,0 +1 @@
+<manifest package="com.yc.swipe"/>
diff --git a/Widget/SwipeBackLib/src/main/java/com/yc/swipe/ISwipeDelegate.java b/Widget/SwipeBackLib/src/main/java/com/yc/swipe/ISwipeDelegate.java
new file mode 100644
index 000000000..4fd8366e9
--- /dev/null
+++ b/Widget/SwipeBackLib/src/main/java/com/yc/swipe/ISwipeDelegate.java
@@ -0,0 +1,28 @@
+package com.yc.swipe;
+
+
+public interface ISwipeDelegate {
+    /**
+     * 是否支持滑动返回
+     *
+     * @return
+     */
+    boolean isSupportSwipeBack();
+
+    /**
+     * 正在滑动返回
+     *
+     * @param slideOffset 从 0 到 1
+     */
+    void onSwipeBackLayoutSlide(float slideOffset);
+
+    /**
+     * 没达到滑动返回的阈值，取消滑动返回动作，回到默认状态
+     */
+    void onSwipeBackLayoutCancel();
+
+    /**
+     * 滑动返回执行完毕，销毁当前 Activity
+     */
+    void onSwipeBackLayoutExecuted();
+}
diff --git a/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackHelper.java b/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackHelper.java
new file mode 100644
index 000000000..62a3fb0e0
--- /dev/null
+++ b/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackHelper.java
@@ -0,0 +1,325 @@
+package com.yc.swipe;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Intent;
+import android.support.annotation.DrawableRes;
+import android.support.annotation.FloatRange;
+import android.view.View;
+
+import java.util.List;
+
+import cn.bingoogolapple.swipebacklayout.R;
+
+
+public class SwipeBackHelper {
+
+    private final Activity mActivity;
+    private final ISwipeDelegate mDelegate;
+    private SwipeBackLayout mSwipeBackLayout;
+
+    /**
+     * 必须在 Application 的 onCreate 方法中调用
+     *
+     * @param application          应用程序上下文
+     * @param problemViewClassList 如果发现滑动返回后立即触摸界面时应用崩溃，
+     *                             请把该界面里比较特殊的 View 的 class 添加到该集合中，
+     *                             目前在库中已经添加了 WebView 和 SurfaceView
+     */
+    public static void init(Application application, List<Class<? extends View>> problemViewClassList) {
+        SwipeBackManager.getInstance().init(application, problemViewClassList);
+    }
+
+    /**
+     * @param activity
+     * @param delegate
+     */
+    public SwipeBackHelper(Activity activity, ISwipeDelegate delegate) {
+        mActivity = activity;
+        mDelegate = delegate;
+
+        initSwipeBackFinish();
+    }
+
+    /**
+     * 初始化滑动返回
+     */
+    private void initSwipeBackFinish() {
+        if (mDelegate.isSupportSwipeBack()) {
+            mSwipeBackLayout = new SwipeBackLayout(mActivity);
+            mSwipeBackLayout.attachToActivity(mActivity);
+            mSwipeBackLayout.setPanelSlideListener(new SwipeBackLayout.PanelSlideListener() {
+                @Override
+                public void onPanelSlide(View panel, float slideOffset) {
+                    // 开始滑动返回时关闭软键盘
+                    if (slideOffset < 0.03) {
+                        SwipeKeyboardUtil.closeKeyboard(mActivity);
+                    }
+
+                    mDelegate.onSwipeBackLayoutSlide(slideOffset);
+                }
+
+                @Override
+                public void onPanelOpened(View panel) {
+                    mDelegate.onSwipeBackLayoutExecuted();
+                }
+
+                @Override
+                public void onPanelClosed(View panel) {
+                    mDelegate.onSwipeBackLayoutCancel();
+                }
+            });
+        }
+    }
+
+    /**
+     * 设置滑动返回是否可用。默认值为 true
+     *
+     * @param swipeBackEnable
+     * @return
+     */
+    public SwipeBackHelper setSwipeBackEnable(boolean swipeBackEnable) {
+        if (mSwipeBackLayout != null) {
+            mSwipeBackLayout.setSwipeBackEnable(swipeBackEnable);
+        }
+        return this;
+    }
+
+    /**
+     * 设置是否仅仅跟踪左侧边缘的滑动返回。默认值为 true
+     *
+     * @param isOnlyTrackingLeftEdge
+     * @return
+     */
+    public SwipeBackHelper setIsOnlyTrackingLeftEdge(boolean isOnlyTrackingLeftEdge) {
+        if (mSwipeBackLayout != null) {
+            mSwipeBackLayout.setIsOnlyTrackingLeftEdge(isOnlyTrackingLeftEdge);
+        }
+        return this;
+    }
+
+    /**
+     * 设置是否是微信滑动返回样式。默认值为 true
+     *
+     * @param isWeChatStyle
+     * @return
+     */
+    public SwipeBackHelper setIsWeChatStyle(boolean isWeChatStyle) {
+        if (mSwipeBackLayout != null) {
+            mSwipeBackLayout.setIsWeChatStyle(isWeChatStyle);
+        }
+        return this;
+    }
+
+    /**
+     * 设置阴影资源 id。默认值为 R.drawable.bga_sbl_shadow
+     *
+     * @param shadowResId
+     * @return
+     */
+    public SwipeBackHelper setShadowResId(@DrawableRes int shadowResId) {
+        if (mSwipeBackLayout != null) {
+            mSwipeBackLayout.setShadowResId(shadowResId);
+        }
+        return this;
+    }
+
+    /**
+     * 设置是否显示滑动返回的阴影效果。默认值为 true
+     *
+     * @param isNeedShowShadow
+     * @return
+     */
+    public SwipeBackHelper setIsNeedShowShadow(boolean isNeedShowShadow) {
+        if (mSwipeBackLayout != null) {
+            mSwipeBackLayout.setIsNeedShowShadow(isNeedShowShadow);
+        }
+        return this;
+    }
+
+    /**
+     * 设置阴影区域的透明度是否根据滑动的距离渐变。默认值为 true
+     *
+     * @param isShadowAlphaGradient
+     * @return
+     */
+    public SwipeBackHelper setIsShadowAlphaGradient(boolean isShadowAlphaGradient) {
+        if (mSwipeBackLayout != null) {
+            mSwipeBackLayout.setIsShadowAlphaGradient(isShadowAlphaGradient);
+        }
+        return this;
+    }
+
+    /**
+     * 设置触发释放后自动滑动返回的阈值，默认值为 0.3f
+     *
+     * @param threshold
+     */
+    public SwipeBackHelper setSwipeBackThreshold(@FloatRange(from = 0.0f, to = 1.0f) float threshold) {
+        if (mSwipeBackLayout != null) {
+            mSwipeBackLayout.setSwipeBackThreshold(threshold);
+        }
+        return this;
+    }
+
+    /**
+     * 设置底部导航条是否悬浮在内容上
+     *
+     * @param overlap
+     */
+    public SwipeBackHelper setIsNavigationBarOverlap(boolean overlap) {
+        if (mSwipeBackLayout != null) {
+            mSwipeBackLayout.setIsNavigationBarOverlap(overlap);
+        }
+        return this;
+    }
+
+    /**
+     * 是否正在滑动
+     *
+     * @return
+     */
+    public boolean isSliding() {
+        if (mSwipeBackLayout != null) {
+            return mSwipeBackLayout.isSliding();
+        }
+        return false;
+    }
+
+    /**
+     * 执行跳转到下一个 Activity 的动画
+     */
+    public void executeForwardAnim() {
+        executeForwardAnim(mActivity);
+    }
+
+    /**
+     * 执行回到到上一个 Activity 的动画
+     */
+    public void executeBackwardAnim() {
+        executeBackwardAnim(mActivity);
+    }
+
+    /**
+     * 执行滑动返回到到上一个 Activity 的动画
+     */
+    public void executeSwipeBackAnim() {
+        executeSwipeBackAnim(mActivity);
+    }
+
+    /**
+     * 执行跳转到下一个 Activity 的动画。这里弄成静态方法，方便在 Fragment 中调用
+     */
+    public static void executeForwardAnim(Activity activity) {
+        activity.overridePendingTransition(R.anim.swipe_activity_forward_enter, R.anim.swipe_activity_forward_exit);
+    }
+
+    /**
+     * 执行回到到上一个 Activity 的动画。这里弄成静态方法，方便在 Fragment 中调用
+     */
+    public static void executeBackwardAnim(Activity activity) {
+        activity.overridePendingTransition(R.anim.swipe_activity_backward_enter, R.anim.swipe_activity_backward_exit);
+    }
+
+    /**
+     * 执行滑动返回到到上一个 Activity 的动画。这里弄成静态方法，方便在 Fragment 中调用
+     */
+    public static void executeSwipeBackAnim(Activity activity) {
+        activity.overridePendingTransition(R.anim.swipe_activity_swipeback_enter, R.anim.swipe_activity_swipeback_exit);
+    }
+
+    /**
+     * 跳转到下一个 Activity，并且销毁当前 Activity
+     *
+     * @param cls 下一个 Activity 的 Class
+     */
+    public void forwardAndFinish(Class<?> cls) {
+        forward(cls);
+        mActivity.finish();
+    }
+
+    /**
+     * 跳转到下一个 Activity，不销毁当前 Activity
+     *
+     * @param cls 下一个 Activity 的 Class
+     */
+    public void forward(Class<?> cls) {
+        SwipeKeyboardUtil.closeKeyboard(mActivity);
+        mActivity.startActivity(new Intent(mActivity, cls));
+        executeForwardAnim();
+    }
+
+    /**
+     * 跳转到下一个 Activity，不销毁当前 Activity
+     *
+     * @param cls         下一个 Activity 的 Class
+     * @param requestCode 请求码
+     */
+    public void forward(Class<?> cls, int requestCode) {
+        forward(new Intent(mActivity, cls), requestCode);
+    }
+
+    /**
+     * 跳转到下一个 Activity，销毁当前 Activity
+     *
+     * @param intent 下一个 Activity 的意图对象
+     */
+    public void forwardAndFinish(Intent intent) {
+        forward(intent);
+        mActivity.finish();
+    }
+
+    /**
+     * 跳转到下一个 Activity,不销毁当前 Activity
+     *
+     * @param intent 下一个 Activity 的意图对象
+     */
+    public void forward(Intent intent) {
+        SwipeKeyboardUtil.closeKeyboard(mActivity);
+        mActivity.startActivity(intent);
+        executeForwardAnim();
+    }
+
+    /**
+     * 跳转到下一个 Activity,不销毁当前 Activity
+     *
+     * @param intent      下一个 Activity 的意图对象
+     * @param requestCode 请求码
+     */
+    public void forward(Intent intent, int requestCode) {
+        SwipeKeyboardUtil.closeKeyboard(mActivity);
+        mActivity.startActivityForResult(intent, requestCode);
+        executeForwardAnim();
+    }
+
+    /**
+     * 回到上一个 Activity，并销毁当前 Activity
+     */
+    public void backward() {
+        SwipeKeyboardUtil.closeKeyboard(mActivity);
+        mActivity.finish();
+        executeBackwardAnim();
+    }
+
+    /**
+     * 滑动返回上一个 Activity，并销毁当前 Activity
+     */
+    public void swipeBackward() {
+        SwipeKeyboardUtil.closeKeyboard(mActivity);
+        mActivity.finish();
+        executeSwipeBackAnim();
+    }
+
+    /**
+     * 回到上一个 Activity，并销毁当前 Activity（应用场景：欢迎、登录、注册这三个界面）
+     *
+     * @param cls 上一个 Activity 的 Class
+     */
+    public void backwardAndFinish(Class<?> cls) {
+        SwipeKeyboardUtil.closeKeyboard(mActivity);
+        mActivity.startActivity(new Intent(mActivity, cls));
+        mActivity.finish();
+        executeBackwardAnim();
+    }
+
+}
diff --git a/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackLayout.java b/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackLayout.java
new file mode 100644
index 000000000..2388ca92c
--- /dev/null
+++ b/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackLayout.java
@@ -0,0 +1,1823 @@
+package com.yc.swipe;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.PixelFormat;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffColorFilter;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import android.support.annotation.ColorInt;
+import android.support.annotation.DrawableRes;
+import android.support.annotation.FloatRange;
+import android.support.v4.content.ContextCompat;
+import android.support.v4.os.ParcelableCompat;
+import android.support.v4.os.ParcelableCompatCreatorCallbacks;
+import android.support.v4.view.AbsSavedState;
+import android.support.v4.view.AccessibilityDelegateCompat;
+import android.support.v4.view.MotionEventCompat;
+import android.support.v4.view.ViewCompat;
+import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat;
+import android.support.v4.widget.ViewDragHelper;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import android.view.accessibility.AccessibilityEvent;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+
+public class SwipeBackLayout extends ViewGroup {
+
+    private static final String TAG = "SlidingPaneLayout";
+
+    /**
+     * Default size of the overhang for a pane in the open state.
+     * At least this much of a sliding pane will remain visible.
+     * This indicates that there is more content available and provides
+     * a "physical" edge to grab to pull it closed.
+     */
+    private static final int DEFAULT_OVERHANG_SIZE = 32; // dp;
+
+    /**
+     * If no fade color is given by default it will fade to 80% gray.
+     */
+    private static final int DEFAULT_FADE_COLOR = 0xcccccccc;
+
+    /**
+     * The fade color used for the sliding panel. 0 = no fading.
+     */
+    private int mSliderFadeColor = DEFAULT_FADE_COLOR;
+
+    /**
+     * Minimum velocity that will be detected as a fling
+     */
+    private static final int MIN_FLING_VELOCITY = 400; // dips per second
+
+    /**
+     * The fade color used for the panel covered by the slider. 0 = no fading.
+     */
+    private int mCoveredFadeColor;
+
+    /**
+     * Drawable used to draw the shadow between panes by default.
+     */
+    private Drawable mShadowDrawableLeft;
+
+    /**
+     * Drawable used to draw the shadow between panes to support RTL (right to left language).
+     */
+    private Drawable mShadowDrawableRight;
+
+    /**
+     * The size of the overhang in pixels.
+     * This is the minimum section of the sliding panel that will
+     * be visible in the open state to allow for a closing drag.
+     */
+    private final int mOverhangSize;
+
+    /**
+     * True if a panel can slide with the current measurements
+     */
+    private boolean mCanSlide;
+
+    /**
+     * The child view that can slide, if any.
+     */
+    View mSlideableView;
+
+    /**
+     * How far the panel is offset from its closed position.
+     * range [0, 1] where 0 = closed, 1 = open.
+     */
+    float mSlideOffset;
+
+    /**
+     * How far the non-sliding panel is parallaxed from its usual position when open.
+     * range [0, 1]
+     */
+    private float mParallaxOffset;
+
+    /**
+     * How far in pixels the slideable panel may move.
+     */
+    int mSlideRange;
+
+    /**
+     * A panel view is locked into internal scrolling or another condition that
+     * is preventing a drag.
+     */
+    boolean mIsUnableToDrag;
+
+    /**
+     * Distance in pixels to parallax the fixed pane by when fully closed
+     */
+    private int mParallaxBy;
+
+    private float mInitialMotionX;
+    private float mInitialMotionY;
+
+    private PanelSlideListener mPanelSlideListener;
+
+    final ViewDragHelper mDragHelper;
+
+    /**
+     * Stores whether or not the pane was open the last time it was slideable.
+     * If open/close operations are invoked this state is modified. Used by
+     * instance state save/restore.
+     */
+    boolean mPreservedOpenState;
+    private boolean mFirstLayout = true;
+
+    private final Rect mTmpRect = new Rect();
+
+    final ArrayList<DisableLayerRunnable> mPostedRunnables =
+            new ArrayList<DisableLayerRunnable>();
+
+    static final SlidingPanelLayoutImpl IMPL;
+
+    static {
+        final int deviceVersion = Build.VERSION.SDK_INT;
+        if (deviceVersion >= 17) {
+            IMPL = new SlidingPanelLayoutImplJBMR1();
+        } else if (deviceVersion >= 16) {
+            IMPL = new SlidingPanelLayoutImplJB();
+        } else {
+            IMPL = new SlidingPanelLayoutImplBase();
+        }
+    }
+
+    // ======================== 新加的 START ========================
+    /**
+     * 滑动返回是否可用
+     */
+    private boolean mSwipeBackEnable = true;
+    /**
+     * 是否仅仅跟踪左侧边缘的滑动返回
+     */
+    private boolean mIsOnlyTrackingLeftEdge = true;
+    /**
+     * 滑动返回时的阴影视图
+     */
+    private SwipeBackShadowView mShadowView;
+    /**
+     * 内容视图
+     */
+    private View mContentView;
+    /**
+     * 当前 Activity
+     */
+    private Activity mActivity;
+    /**
+     * 触发滑动返回的滑动范围
+     */
+    private float mSwipeBackThreshold = 0.3f;
+    /**
+     * 底部导航条是否悬浮在内容上
+     */
+    private boolean mIsNavigationBarOverlap = false;
+    /**
+     * 是否正在滑动
+     */
+    private boolean mIsSliding;
+
+    /**
+     * 将该滑动返回控件添加到 Activity 上
+     */
+    void attachToActivity(Activity activity) {
+        mActivity = activity;
+
+        setSliderFadeColor(Color.TRANSPARENT);
+
+        mShadowView = new SwipeBackShadowView(activity);
+
+        addView(mShadowView, 0, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+
+        ViewGroup decorView = (ViewGroup) activity.getWindow().getDecorView();
+        mContentView = decorView.getChildAt(0);
+        decorView.removeView(mContentView);
+        decorView.addView(this);
+        addView(mContentView, 1, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+    }
+
+    /**
+     * 设置滑动返回是否可用。默认值为 true
+     */
+    void setSwipeBackEnable(boolean swipeBackEnable) {
+        mSwipeBackEnable = swipeBackEnable;
+    }
+
+    /**
+     * 设置是否仅仅跟踪左侧边缘的滑动返回。默认值为 true
+     */
+    void setIsOnlyTrackingLeftEdge(boolean isOnlyTrackingLeftEdge) {
+        mIsOnlyTrackingLeftEdge = isOnlyTrackingLeftEdge;
+    }
+
+    /**
+     * 设置是否是微信滑动返回样式
+     */
+    void setIsWeChatStyle(boolean isWeChatStyle) {
+        mShadowView.setIsWeChatStyle(isWeChatStyle);
+    }
+
+    /**
+     * 设置触发释放后自动滑动返回的阈值
+     *
+     * @param threshold 触发释放后自动滑动返回的阈值
+     */
+    void setSwipeBackThreshold(@FloatRange(from = 0.0f, to = 1.0f) float threshold) {
+        mSwipeBackThreshold = threshold;
+    }
+
+    /**
+     * 设置底部导航条是否悬浮在内容上
+     */
+    void setIsNavigationBarOverlap(boolean overlap) {
+        mIsNavigationBarOverlap = overlap;
+    }
+
+    /**
+     * 是否正在滑动
+     */
+    boolean isSliding() {
+        return this.mIsSliding;
+    }
+
+    /**
+     * 滑动返回是否可用
+     */
+    private boolean isSwipeBackEnable() {
+        return mSwipeBackEnable && SwipeBackManager.getInstance().isSwipeBackEnable();
+    }
+
+    /**
+     * 设置阴影资源 id
+     */
+    void setShadowResId(@DrawableRes int shadowResId) {
+        mShadowView.setShadowResId(shadowResId);
+    }
+
+    /**
+     * 设置是否显示滑动返回的阴影效果
+     */
+    void setIsNeedShowShadow(boolean isNeedShowShadow) {
+        mShadowView.setIsNeedShowShadow(isNeedShowShadow);
+    }
+
+    /**
+     * 设置阴影区域的透明度是否根据滑动的距离渐变
+     */
+    void setIsShadowAlphaGradient(boolean isShadowAlphaGradient) {
+        mShadowView.setIsShadowAlphaGradient(isShadowAlphaGradient);
+    }
+    // ======================== 新加的 END ========================
+
+    /**
+     * Listener for monitoring events about sliding panes.
+     */
+    public interface PanelSlideListener {
+        /**
+         * Called when a sliding pane's position changes.
+         *
+         * @param panel       The child view that was moved
+         * @param slideOffset The new offset of this sliding pane within its range, from 0-1
+         */
+        void onPanelSlide(View panel, float slideOffset);
+
+        /**
+         * Called when a sliding pane becomes slid completely open. The pane may or may not
+         * be interactive at this point depending on how much of the pane is visible.
+         *
+         * @param panel The child view that was slid to an open position, revealing other panes
+         */
+        void onPanelOpened(View panel);
+
+        /**
+         * Called when a sliding pane becomes slid completely closed. The pane is now guaranteed
+         * to be interactive. It may now obscure other views in the layout.
+         *
+         * @param panel The child view that was slid to a closed position
+         */
+        void onPanelClosed(View panel);
+    }
+
+    /**
+     * No-op stubs for {@link PanelSlideListener}. If you only want to implement a subset
+     * of the listener methods you can extend this instead of implement the full interface.
+     */
+    public static class SimplePanelSlideListener implements PanelSlideListener {
+        @Override
+        public void onPanelSlide(View panel, float slideOffset) {
+        }
+
+        @Override
+        public void onPanelOpened(View panel) {
+        }
+
+        @Override
+        public void onPanelClosed(View panel) {
+        }
+    }
+
+    public SwipeBackLayout(Context context) {
+        this(context, null);
+    }
+
+    public SwipeBackLayout(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public SwipeBackLayout(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+
+        final float density = context.getResources().getDisplayMetrics().density;
+
+        // ======================== 新加的 START ========================
+//        mOverhangSize = (int) (DEFAULT_OVERHANG_SIZE * density + 0.5f);
+        mOverhangSize = 0;
+        // ======================== 新加的 END ========================
+
+        final ViewConfiguration viewConfig = ViewConfiguration.get(context);
+
+        setWillNotDraw(false);
+
+        ViewCompat.setAccessibilityDelegate(this, new AccessibilityDelegate());
+        ViewCompat.setImportantForAccessibility(this, ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_YES);
+
+        mDragHelper = ViewDragHelper.create(this, 0.5f, new DragHelperCallback());
+        mDragHelper.setMinVelocity(MIN_FLING_VELOCITY * density);
+    }
+
+    /**
+     * Set a distance to parallax the lower pane by when the upper pane is in its
+     * fully closed state. The lower pane will scroll between this position and
+     * its fully open state.
+     *
+     * @param parallaxBy Distance to parallax by in pixels
+     */
+    public void setParallaxDistance(int parallaxBy) {
+        mParallaxBy = parallaxBy;
+        requestLayout();
+    }
+
+    /**
+     * @return The distance the lower pane will parallax by when the upper pane is fully closed.
+     * @see #setParallaxDistance(int)
+     */
+    public int getParallaxDistance() {
+        return mParallaxBy;
+    }
+
+    /**
+     * Set the color used to fade the sliding pane out when it is slid most of the way offscreen.
+     *
+     * @param color An ARGB-packed color value
+     */
+    public void setSliderFadeColor(@ColorInt int color) {
+        mSliderFadeColor = color;
+    }
+
+    /**
+     * @return The ARGB-packed color value used to fade the sliding pane
+     */
+    @ColorInt
+    public int getSliderFadeColor() {
+        return mSliderFadeColor;
+    }
+
+    /**
+     * Set the color used to fade the pane covered by the sliding pane out when the pane
+     * will become fully covered in the closed state.
+     *
+     * @param color An ARGB-packed color value
+     */
+    public void setCoveredFadeColor(@ColorInt int color) {
+        mCoveredFadeColor = color;
+    }
+
+    /**
+     * @return The ARGB-packed color value used to fade the fixed pane
+     */
+    @ColorInt
+    public int getCoveredFadeColor() {
+        return mCoveredFadeColor;
+    }
+
+    public void setPanelSlideListener(PanelSlideListener listener) {
+        mPanelSlideListener = listener;
+    }
+
+    void dispatchOnPanelSlide(View panel) {
+        // ======================== 新加的 START ========================
+        mShadowView.setShadowAlpha(1.0f - mSlideOffset);
+        mShadowView.onPanelSlide(mSlideOffset);
+        // ======================== 新加的 END ========================
+
+        if (mPanelSlideListener != null) {
+            mPanelSlideListener.onPanelSlide(panel, mSlideOffset);
+        }
+    }
+
+    void dispatchOnPanelOpened(final View panel) {
+        if (mPanelSlideListener != null) {
+            mPanelSlideListener.onPanelOpened(panel);
+        }
+        sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
+
+        // ======================== 新加的 START ========================
+        mShadowView.unBindPreActivity(true);
+        // ======================== 新加的 END ========================
+    }
+
+    void dispatchOnPanelClosed(View panel) {
+        // ======================== 新加的 START ========================
+        mShadowView.onPanelClosed();
+        // ======================== 新加的 END ========================
+
+        if (mPanelSlideListener != null) {
+            mPanelSlideListener.onPanelClosed(panel);
+        }
+        sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
+    }
+
+    void updateObscuredViewsVisibility(View panel) {
+        final boolean isLayoutRtl = isLayoutRtlSupport();
+        final int startBound = isLayoutRtl ? (getWidth() - getPaddingRight()) : getPaddingLeft();
+        final int endBound = isLayoutRtl ? getPaddingLeft() : (getWidth() - getPaddingRight());
+        final int topBound = getPaddingTop();
+        final int bottomBound = getHeight() - getPaddingBottom();
+        final int left;
+        final int right;
+        final int top;
+        final int bottom;
+        if (panel != null && viewIsOpaque(panel)) {
+            left = panel.getLeft();
+            right = panel.getRight();
+            top = panel.getTop();
+            bottom = panel.getBottom();
+        } else {
+            left = right = top = bottom = 0;
+        }
+
+        for (int i = 0, childCount = getChildCount(); i < childCount; i++) {
+            final View child = getChildAt(i);
+
+            if (child == panel) {
+                // There are still more children above the panel but they won't be affected.
+                break;
+            } else if (child.getVisibility() == GONE) {
+                continue;
+            }
+
+            final int clampedChildLeft = Math.max(
+                    (isLayoutRtl ? endBound : startBound), child.getLeft());
+            final int clampedChildTop = Math.max(topBound, child.getTop());
+            final int clampedChildRight = Math.min(
+                    (isLayoutRtl ? startBound : endBound), child.getRight());
+            final int clampedChildBottom = Math.min(bottomBound, child.getBottom());
+            final int vis;
+            if (clampedChildLeft >= left && clampedChildTop >= top
+                    && clampedChildRight <= right && clampedChildBottom <= bottom) {
+                vis = INVISIBLE;
+            } else {
+                vis = VISIBLE;
+            }
+            child.setVisibility(vis);
+        }
+    }
+
+    void setAllChildrenVisible() {
+        for (int i = 0, childCount = getChildCount(); i < childCount; i++) {
+            final View child = getChildAt(i);
+            if (child.getVisibility() == INVISIBLE) {
+                child.setVisibility(VISIBLE);
+            }
+        }
+    }
+
+    private static boolean viewIsOpaque(View v) {
+        if (v.isOpaque()) {
+            return true;
+        }
+
+        // View#isOpaque didn't take all valid opaque scrollbar modes into account
+        // before API 18 (JB-MR2). On newer devices rely solely on isOpaque above and return false
+        // here. On older devices, check the view's background drawable directly as a fallback.
+        if (Build.VERSION.SDK_INT >= 18) {
+            return false;
+        }
+
+        final Drawable bg = v.getBackground();
+        if (bg != null) {
+            return bg.getOpacity() == PixelFormat.OPAQUE;
+        }
+        return false;
+    }
+
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        mFirstLayout = true;
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+        mFirstLayout = true;
+
+        for (int i = 0, count = mPostedRunnables.size(); i < count; i++) {
+            final DisableLayerRunnable dlr = mPostedRunnables.get(i);
+            dlr.run();
+        }
+        mPostedRunnables.clear();
+    }
+
+    @SuppressLint("Range")
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+        // ======================== 新加的 START ========================
+//        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
+        int widthSize = SwipeUiUtils.getRealScreenWidth(mActivity);
+//        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
+        int heightSize = SwipeUiUtils.getRealScreenHeight(mActivity);
+        // ======================== 新加的 END ========================
+
+        if (widthMode != MeasureSpec.EXACTLY) {
+            if (isInEditMode()) {
+                // Don't crash the layout editor. Consume all of the space if specified
+                // or pick a magic number from thin air otherwise.
+                // TODO Better communication with tools of this bogus state.
+                // It will crash on a real device.
+                if (widthMode == MeasureSpec.AT_MOST) {
+                    widthMode = MeasureSpec.EXACTLY;
+                } else if (widthMode == MeasureSpec.UNSPECIFIED) {
+                    widthMode = MeasureSpec.EXACTLY;
+                    widthSize = 300;
+                }
+            } else {
+                throw new IllegalStateException("Width must have an exact value or MATCH_PARENT");
+            }
+        } else if (heightMode == MeasureSpec.UNSPECIFIED) {
+            if (isInEditMode()) {
+                // Don't crash the layout editor. Pick a magic number from thin air instead.
+                // TODO Better communication with tools of this bogus state.
+                // It will crash on a real device.
+                if (heightMode == MeasureSpec.UNSPECIFIED) {
+                    heightMode = MeasureSpec.AT_MOST;
+                    heightSize = 300;
+                }
+            } else {
+                throw new IllegalStateException("Height must not be UNSPECIFIED");
+            }
+        }
+
+        int layoutHeight = 0;
+        int maxLayoutHeight = -1;
+        switch (heightMode) {
+            case MeasureSpec.EXACTLY:
+                layoutHeight = maxLayoutHeight = heightSize - getPaddingTop() - getPaddingBottom();
+                break;
+            case MeasureSpec.AT_MOST:
+                maxLayoutHeight = heightSize - getPaddingTop() - getPaddingBottom();
+                break;
+        }
+
+        // ======================== 新加的 START ========================
+        if (!mIsNavigationBarOverlap && SwipeUiUtils.isPortrait(mActivity)) {
+            maxLayoutHeight -= SwipeUiUtils.getNavigationBarHeight(mActivity);
+        }
+
+        if (mIsNavigationBarOverlap && !SwipeUiUtils.isPortrait(mActivity)) {
+            widthSize += SwipeUiUtils.getNavigationBarHeight(mActivity);
+        }
+        // ======================== 新加的 END ========================
+
+        float weightSum = 0;
+        boolean canSlide = false;
+        final int widthAvailable = widthSize - getPaddingLeft() - getPaddingRight();
+        int widthRemaining = widthAvailable;
+        final int childCount = getChildCount();
+
+        if (childCount > 2) {
+            Log.e(TAG, "onMeasure: More than two child views are not supported.");
+        }
+
+        // We'll find the current one below.
+        mSlideableView = null;
+
+        // First pass. Measure based on child LayoutParams width/height.
+        // Weight will incur a second pass.
+        for (int i = 0; i < childCount; i++) {
+            final View child = getChildAt(i);
+            final LayoutParams lp = (LayoutParams) child.getLayoutParams();
+
+            if (child.getVisibility() == GONE) {
+                lp.dimWhenOffset = false;
+                continue;
+            }
+
+            if (lp.weight > 0) {
+                weightSum += lp.weight;
+
+                // If we have no width, weight is the only contributor to the final size.
+                // Measure this view on the weight pass only.
+                if (lp.width == 0) continue;
+            }
+
+            int childWidthSpec;
+            final int horizontalMargin = lp.leftMargin + lp.rightMargin;
+            if (lp.width == LayoutParams.WRAP_CONTENT) {
+                childWidthSpec = MeasureSpec.makeMeasureSpec(widthAvailable - horizontalMargin,
+                        MeasureSpec.AT_MOST);
+            } else if (lp.width == LayoutParams.MATCH_PARENT) {
+                childWidthSpec = MeasureSpec.makeMeasureSpec(widthAvailable - horizontalMargin,
+                        MeasureSpec.EXACTLY);
+            } else {
+                childWidthSpec = MeasureSpec.makeMeasureSpec(lp.width, MeasureSpec.EXACTLY);
+            }
+
+            int childHeightSpec;
+            if (lp.height == LayoutParams.WRAP_CONTENT) {
+                childHeightSpec = MeasureSpec.makeMeasureSpec(maxLayoutHeight, MeasureSpec.AT_MOST);
+            } else if (lp.height == LayoutParams.MATCH_PARENT) {
+                childHeightSpec = MeasureSpec.makeMeasureSpec(maxLayoutHeight, MeasureSpec.EXACTLY);
+            } else {
+                childHeightSpec = MeasureSpec.makeMeasureSpec(lp.height, MeasureSpec.EXACTLY);
+            }
+
+            child.measure(childWidthSpec, childHeightSpec);
+            final int childWidth = child.getMeasuredWidth();
+            final int childHeight = child.getMeasuredHeight();
+
+            if (heightMode == MeasureSpec.AT_MOST && childHeight > layoutHeight) {
+                layoutHeight = Math.min(childHeight, maxLayoutHeight);
+            }
+
+            widthRemaining -= childWidth;
+            canSlide |= lp.slideable = widthRemaining < 0;
+            if (lp.slideable) {
+                mSlideableView = child;
+            }
+        }
+
+        // Resolve weight and make sure non-sliding panels are smaller than the full screen.
+        if (canSlide || weightSum > 0) {
+            final int fixedPanelWidthLimit = widthAvailable - mOverhangSize;
+
+            for (int i = 0; i < childCount; i++) {
+                final View child = getChildAt(i);
+
+                if (child.getVisibility() == GONE) {
+                    continue;
+                }
+
+                final LayoutParams lp = (LayoutParams) child.getLayoutParams();
+
+                if (child.getVisibility() == GONE) {
+                    continue;
+                }
+
+                final boolean skippedFirstPass = lp.width == 0 && lp.weight > 0;
+                final int measuredWidth = skippedFirstPass ? 0 : child.getMeasuredWidth();
+                if (canSlide && child != mSlideableView) {
+                    if (lp.width < 0 && (measuredWidth > fixedPanelWidthLimit || lp.weight > 0)) {
+                        // Fixed panels in a sliding configuration should
+                        // be clamped to the fixed panel limit.
+                        final int childHeightSpec;
+                        if (skippedFirstPass) {
+                            // Do initial height measurement if we skipped measuring this view
+                            // the first time around.
+                            if (lp.height == LayoutParams.WRAP_CONTENT) {
+                                childHeightSpec = MeasureSpec.makeMeasureSpec(maxLayoutHeight,
+                                        MeasureSpec.AT_MOST);
+                            } else if (lp.height == LayoutParams.MATCH_PARENT) {
+                                childHeightSpec = MeasureSpec.makeMeasureSpec(maxLayoutHeight,
+                                        MeasureSpec.EXACTLY);
+                            } else {
+                                childHeightSpec = MeasureSpec.makeMeasureSpec(lp.height,
+                                        MeasureSpec.EXACTLY);
+                            }
+                        } else {
+                            childHeightSpec = MeasureSpec.makeMeasureSpec(
+                                    child.getMeasuredHeight(), MeasureSpec.EXACTLY);
+                        }
+                        final int childWidthSpec = MeasureSpec.makeMeasureSpec(
+                                fixedPanelWidthLimit, MeasureSpec.EXACTLY);
+                        child.measure(childWidthSpec, childHeightSpec);
+                    }
+                } else if (lp.weight > 0) {
+                    int childHeightSpec;
+                    if (lp.width == 0) {
+                        // This was skipped the first time; figure out a real height spec.
+                        if (lp.height == LayoutParams.WRAP_CONTENT) {
+                            childHeightSpec = MeasureSpec.makeMeasureSpec(maxLayoutHeight,
+                                    MeasureSpec.AT_MOST);
+                        } else if (lp.height == LayoutParams.MATCH_PARENT) {
+                            childHeightSpec = MeasureSpec.makeMeasureSpec(maxLayoutHeight,
+                                    MeasureSpec.EXACTLY);
+                        } else {
+                            childHeightSpec = MeasureSpec.makeMeasureSpec(lp.height,
+                                    MeasureSpec.EXACTLY);
+                        }
+                    } else {
+                        childHeightSpec = MeasureSpec.makeMeasureSpec(
+                                child.getMeasuredHeight(), MeasureSpec.EXACTLY);
+                    }
+
+                    if (canSlide) {
+                        // Consume available space
+                        final int horizontalMargin = lp.leftMargin + lp.rightMargin;
+                        final int newWidth = widthAvailable - horizontalMargin;
+                        final int childWidthSpec = MeasureSpec.makeMeasureSpec(
+                                newWidth, MeasureSpec.EXACTLY);
+                        if (measuredWidth != newWidth) {
+                            child.measure(childWidthSpec, childHeightSpec);
+                        }
+                    } else {
+                        // Distribute the extra width proportionally similar to LinearLayout
+                        final int widthToDistribute = Math.max(0, widthRemaining);
+                        final int addedWidth = (int) (lp.weight * widthToDistribute / weightSum);
+                        final int childWidthSpec = MeasureSpec.makeMeasureSpec(
+                                measuredWidth + addedWidth, MeasureSpec.EXACTLY);
+                        child.measure(childWidthSpec, childHeightSpec);
+                    }
+                }
+            }
+        }
+
+        final int measuredWidth = widthSize;
+        final int measuredHeight = layoutHeight + getPaddingTop() + getPaddingBottom();
+
+        setMeasuredDimension(measuredWidth, measuredHeight);
+        mCanSlide = canSlide;
+
+        if (mDragHelper.getViewDragState() != ViewDragHelper.STATE_IDLE && !canSlide) {
+            // Cancel scrolling in progress, it's no longer relevant.
+            mDragHelper.abort();
+        }
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        final boolean isLayoutRtl = isLayoutRtlSupport();
+        if (isLayoutRtl) {
+            mDragHelper.setEdgeTrackingEnabled(ViewDragHelper.EDGE_RIGHT);
+        } else {
+            mDragHelper.setEdgeTrackingEnabled(ViewDragHelper.EDGE_LEFT);
+        }
+        final int width = r - l;
+        final int paddingStart = isLayoutRtl ? getPaddingRight() : getPaddingLeft();
+        final int paddingEnd = isLayoutRtl ? getPaddingLeft() : getPaddingRight();
+        final int paddingTop = getPaddingTop();
+
+        final int childCount = getChildCount();
+        int xStart = paddingStart;
+        int nextXStart = xStart;
+
+        if (mFirstLayout) {
+            mSlideOffset = mCanSlide && mPreservedOpenState ? 1.f : 0.f;
+        }
+
+        for (int i = 0; i < childCount; i++) {
+            final View child = getChildAt(i);
+
+            if (child.getVisibility() == GONE) {
+                continue;
+            }
+
+            final LayoutParams lp = (LayoutParams) child.getLayoutParams();
+
+            final int childWidth = child.getMeasuredWidth();
+            int offset = 0;
+
+            if (lp.slideable) {
+                final int margin = lp.leftMargin + lp.rightMargin;
+                final int range = Math.min(nextXStart,
+                        width - paddingEnd - mOverhangSize) - xStart - margin;
+                mSlideRange = range;
+                final int lpMargin = isLayoutRtl ? lp.rightMargin : lp.leftMargin;
+                lp.dimWhenOffset = xStart + lpMargin + range + childWidth / 2 > width - paddingEnd;
+                final int pos = (int) (range * mSlideOffset);
+                xStart += pos + lpMargin;
+                mSlideOffset = (float) pos / mSlideRange;
+            } else if (mCanSlide && mParallaxBy != 0) {
+                offset = (int) ((1 - mSlideOffset) * mParallaxBy);
+                xStart = nextXStart;
+            } else {
+                xStart = nextXStart;
+            }
+
+            final int childRight;
+            final int childLeft;
+            if (isLayoutRtl) {
+                childRight = width - xStart + offset;
+                childLeft = childRight - childWidth;
+            } else {
+                childLeft = xStart - offset;
+                childRight = childLeft + childWidth;
+            }
+
+            final int childTop = paddingTop;
+            final int childBottom = childTop + child.getMeasuredHeight();
+            child.layout(childLeft, paddingTop, childRight, childBottom);
+
+            nextXStart += child.getWidth();
+        }
+
+        if (mFirstLayout) {
+            if (mCanSlide) {
+                if (mParallaxBy != 0) {
+                    parallaxOtherViews(mSlideOffset);
+                }
+                if (((LayoutParams) mSlideableView.getLayoutParams()).dimWhenOffset) {
+                    dimChildView(mSlideableView, mSlideOffset, mSliderFadeColor);
+                }
+            } else {
+                // Reset the dim level of all children; it's irrelevant when nothing moves.
+                for (int i = 0; i < childCount; i++) {
+                    dimChildView(getChildAt(i), 0, mSliderFadeColor);
+                }
+            }
+            updateObscuredViewsVisibility(mSlideableView);
+        }
+
+        mFirstLayout = false;
+    }
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+        // Recalculate sliding panes and their details
+        if (w != oldw) {
+            mFirstLayout = true;
+        }
+    }
+
+    @Override
+    public void requestChildFocus(View child, View focused) {
+        super.requestChildFocus(child, focused);
+        if (!isInTouchMode() && !mCanSlide) {
+            mPreservedOpenState = child == mSlideableView;
+        }
+    }
+
+    @Override
+    public boolean onInterceptTouchEvent(MotionEvent ev) {
+        final int action = MotionEventCompat.getActionMasked(ev);
+
+        // Preserve the open state based on the last view that was touched.
+        if (!mCanSlide && action == MotionEvent.ACTION_DOWN && getChildCount() > 1) {
+            // After the first things will be slideable.
+            final View secondChild = getChildAt(1);
+            if (secondChild != null) {
+                mPreservedOpenState = !mDragHelper.isViewUnder(secondChild,
+                        (int) ev.getX(), (int) ev.getY());
+            }
+        }
+
+        // ======================== 新加的 START ========================
+        if (!isSwipeBackEnable()) {
+            mDragHelper.cancel();
+            return super.onInterceptTouchEvent(ev);
+        }
+        // ======================== 新加的 END ========================
+
+        if (!mCanSlide || (mIsUnableToDrag && action != MotionEvent.ACTION_DOWN)) {
+            mDragHelper.cancel();
+            return super.onInterceptTouchEvent(ev);
+        }
+
+        if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
+            mDragHelper.cancel();
+            return false;
+        }
+
+        boolean interceptTap = false;
+
+        switch (action) {
+            case MotionEvent.ACTION_DOWN: {
+                mIsUnableToDrag = false;
+                final float x = ev.getX();
+                final float y = ev.getY();
+                mInitialMotionX = x;
+                mInitialMotionY = y;
+
+                if (mDragHelper.isViewUnder(mSlideableView, (int) x, (int) y)
+                        && isDimmed(mSlideableView)) {
+                    interceptTap = true;
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_MOVE: {
+                final float x = ev.getX();
+                final float y = ev.getY();
+                final float adx = Math.abs(x - mInitialMotionX);
+                final float ady = Math.abs(y - mInitialMotionY);
+                final int slop = mDragHelper.getTouchSlop();
+                if (adx > slop && ady > adx) {
+                    mDragHelper.cancel();
+                    mIsUnableToDrag = true;
+                    return false;
+                }
+            }
+        }
+
+        final boolean interceptForDrag = mDragHelper.shouldInterceptTouchEvent(ev);
+
+        return interceptForDrag || interceptTap;
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        // ======================== 新加的 START ========================
+        if (!isSwipeBackEnable()) {
+            return super.onTouchEvent(ev);
+        }
+        // ======================== 新加的 END ========================
+
+        if (!mCanSlide) {
+            return super.onTouchEvent(ev);
+        }
+
+        mDragHelper.processTouchEvent(ev);
+
+        final int action = ev.getAction();
+        boolean wantTouchEvents = true;
+
+        switch (action & MotionEventCompat.ACTION_MASK) {
+            case MotionEvent.ACTION_DOWN: {
+                final float x = ev.getX();
+                final float y = ev.getY();
+                mInitialMotionX = x;
+                mInitialMotionY = y;
+                break;
+            }
+
+            case MotionEvent.ACTION_UP: {
+                if (isDimmed(mSlideableView)) {
+                    final float x = ev.getX();
+                    final float y = ev.getY();
+                    final float dx = x - mInitialMotionX;
+                    final float dy = y - mInitialMotionY;
+                    final int slop = mDragHelper.getTouchSlop();
+                    if (dx * dx + dy * dy < slop * slop
+                            && mDragHelper.isViewUnder(mSlideableView, (int) x, (int) y)) {
+                        // Taps close a dimmed open pane.
+                        closePane(mSlideableView, 0);
+                        break;
+                    }
+                }
+                break;
+            }
+        }
+
+        return wantTouchEvents;
+    }
+
+    private boolean closePane(View pane, int initialVelocity) {
+        if (mFirstLayout || smoothSlideTo(0.f, initialVelocity)) {
+            mPreservedOpenState = false;
+            return true;
+        }
+        return false;
+    }
+
+    private boolean openPane(View pane, int initialVelocity) {
+        if (mFirstLayout || smoothSlideTo(1.f, initialVelocity)) {
+            mPreservedOpenState = true;
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * @deprecated Renamed to {@link #openPane()} - this method is going away soon!
+     */
+    @Deprecated
+    public void smoothSlideOpen() {
+        openPane();
+    }
+
+    /**
+     * Open the sliding pane if it is currently slideable. If first layout
+     * has already completed this will animate.
+     *
+     * @return true if the pane was slideable and is now open/in the process of opening
+     */
+    public boolean openPane() {
+        return openPane(mSlideableView, 0);
+    }
+
+    /**
+     * @deprecated Renamed to {@link #closePane()} - this method is going away soon!
+     */
+    @Deprecated
+    public void smoothSlideClosed() {
+        closePane();
+    }
+
+    /**
+     * Close the sliding pane if it is currently slideable. If first layout
+     * has already completed this will animate.
+     *
+     * @return true if the pane was slideable and is now closed/in the process of closing
+     */
+    public boolean closePane() {
+        return closePane(mSlideableView, 0);
+    }
+
+    /**
+     * Check if the layout is completely open. It can be open either because the slider
+     * itself is open revealing the left pane, or if all content fits without sliding.
+     *
+     * @return true if sliding panels are completely open
+     */
+    public boolean isOpen() {
+        return !mCanSlide || mSlideOffset == 1;
+    }
+
+    /**
+     * @return true if content in this layout can be slid open and closed
+     * @deprecated Renamed to {@link #isSlideable()} - this method is going away soon!
+     */
+    @Deprecated
+    public boolean canSlide() {
+        return mCanSlide;
+    }
+
+    /**
+     * Check if the content in this layout cannot fully fit side by side and therefore
+     * the content pane can be slid back and forth.
+     *
+     * @return true if content in this layout can be slid open and closed
+     */
+    public boolean isSlideable() {
+        return mCanSlide;
+    }
+
+    void onPanelDragged(int newLeft) {
+        if (mSlideableView == null) {
+            // This can happen if we're aborting motion during layout because everything now fits.
+            mSlideOffset = 0;
+            return;
+        }
+        final boolean isLayoutRtl = isLayoutRtlSupport();
+        final LayoutParams lp = (LayoutParams) mSlideableView.getLayoutParams();
+
+        int childWidth = mSlideableView.getWidth();
+        final int newStart = isLayoutRtl ? getWidth() - newLeft - childWidth : newLeft;
+
+        final int paddingStart = isLayoutRtl ? getPaddingRight() : getPaddingLeft();
+        final int lpMargin = isLayoutRtl ? lp.rightMargin : lp.leftMargin;
+        final int startBound = paddingStart + lpMargin;
+
+        mSlideOffset = (float) (newStart - startBound) / mSlideRange;
+
+        if (mParallaxBy != 0) {
+            parallaxOtherViews(mSlideOffset);
+        }
+
+        if (lp.dimWhenOffset) {
+            dimChildView(mSlideableView, mSlideOffset, mSliderFadeColor);
+        }
+
+        // ======================== 新加的 START ========================
+        ViewCompat.setTranslationX(mShadowView, -mShadowView.getMeasuredWidth() + newLeft);
+        // ======================== 新加的 END ========================
+
+        dispatchOnPanelSlide(mSlideableView);
+    }
+
+    private void dimChildView(View v, float mag, int fadeColor) {
+        final LayoutParams lp = (LayoutParams) v.getLayoutParams();
+
+        if (mag > 0 && fadeColor != 0) {
+            final int baseAlpha = (fadeColor & 0xff000000) >>> 24;
+            int imag = (int) (baseAlpha * mag);
+            int color = imag << 24 | (fadeColor & 0xffffff);
+            if (lp.dimPaint == null) {
+                lp.dimPaint = new Paint();
+            }
+            lp.dimPaint.setColorFilter(new PorterDuffColorFilter(color, PorterDuff.Mode.SRC_OVER));
+            if (ViewCompat.getLayerType(v) != ViewCompat.LAYER_TYPE_HARDWARE) {
+                ViewCompat.setLayerType(v, ViewCompat.LAYER_TYPE_HARDWARE, lp.dimPaint);
+            }
+            invalidateChildRegion(v);
+        } else if (ViewCompat.getLayerType(v) != ViewCompat.LAYER_TYPE_NONE) {
+            if (lp.dimPaint != null) {
+                lp.dimPaint.setColorFilter(null);
+            }
+            final DisableLayerRunnable dlr = new DisableLayerRunnable(v);
+            mPostedRunnables.add(dlr);
+            ViewCompat.postOnAnimation(this, dlr);
+        }
+    }
+
+    @Override
+    protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
+        final LayoutParams lp = (LayoutParams) child.getLayoutParams();
+        boolean result;
+        final int save = canvas.save();
+
+        if (mCanSlide && !lp.slideable && mSlideableView != null) {
+            // Clip against the slider; no sense drawing what will immediately be covered.
+            canvas.getClipBounds(mTmpRect);
+            if (isLayoutRtlSupport()) {
+                mTmpRect.left = Math.max(mTmpRect.left, mSlideableView.getRight());
+            } else {
+                mTmpRect.right = Math.min(mTmpRect.right, mSlideableView.getLeft());
+            }
+            canvas.clipRect(mTmpRect);
+        }
+
+        if (Build.VERSION.SDK_INT >= 11) { // HC
+            result = super.drawChild(canvas, child, drawingTime);
+        } else {
+            if (lp.dimWhenOffset && mSlideOffset > 0) {
+                if (!child.isDrawingCacheEnabled()) {
+                    child.setDrawingCacheEnabled(true);
+                }
+                final Bitmap cache = child.getDrawingCache();
+                if (cache != null) {
+                    canvas.drawBitmap(cache, child.getLeft(), child.getTop(), lp.dimPaint);
+                    result = false;
+                } else {
+                    Log.e(TAG, "drawChild: child view " + child + " returned null drawing cache");
+                    result = super.drawChild(canvas, child, drawingTime);
+                }
+            } else {
+                if (child.isDrawingCacheEnabled()) {
+                    child.setDrawingCacheEnabled(false);
+                }
+                result = super.drawChild(canvas, child, drawingTime);
+            }
+        }
+
+        canvas.restoreToCount(save);
+
+        return result;
+    }
+
+    void invalidateChildRegion(View v) {
+        IMPL.invalidateChildRegion(this, v);
+    }
+
+    /**
+     * Smoothly animate mDraggingPane to the target X position within its range.
+     *
+     * @param slideOffset position to animate to
+     * @param velocity    initial velocity in case of fling, or 0.
+     */
+    boolean smoothSlideTo(float slideOffset, int velocity) {
+        if (!mCanSlide) {
+            // Nothing to do.
+            return false;
+        }
+
+        final boolean isLayoutRtl = isLayoutRtlSupport();
+        final LayoutParams lp = (LayoutParams) mSlideableView.getLayoutParams();
+
+        int x;
+        if (isLayoutRtl) {
+            int startBound = getPaddingRight() + lp.rightMargin;
+            int childWidth = mSlideableView.getWidth();
+            x = (int) (getWidth() - (startBound + slideOffset * mSlideRange + childWidth));
+        } else {
+            int startBound = getPaddingLeft() + lp.leftMargin;
+            x = (int) (startBound + slideOffset * mSlideRange);
+        }
+
+        if (mDragHelper.smoothSlideViewTo(mSlideableView, x, mSlideableView.getTop())) {
+            setAllChildrenVisible();
+            ViewCompat.postInvalidateOnAnimation(this);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void computeScroll() {
+        if (mDragHelper.continueSettling(true)) {
+            if (!mCanSlide) {
+                mDragHelper.abort();
+                return;
+            }
+
+            ViewCompat.postInvalidateOnAnimation(this);
+        }
+    }
+
+    /**
+     * @param d drawable to use as a shadow
+     * @deprecated Renamed to {@link #setShadowDrawableLeft(Drawable d)} to support LTR (left to
+     * right language) and {@link #setShadowDrawableRight(Drawable d)} to support RTL (right to left
+     * language) during opening/closing.
+     */
+    @Deprecated
+    public void setShadowDrawable(Drawable d) {
+        setShadowDrawableLeft(d);
+    }
+
+    /**
+     * Set a drawable to use as a shadow cast by the right pane onto the left pane
+     * during opening/closing.
+     *
+     * @param d drawable to use as a shadow
+     */
+    public void setShadowDrawableLeft(Drawable d) {
+        mShadowDrawableLeft = d;
+    }
+
+    /**
+     * Set a drawable to use as a shadow cast by the left pane onto the right pane
+     * during opening/closing to support right to left language.
+     *
+     * @param d drawable to use as a shadow
+     */
+    public void setShadowDrawableRight(Drawable d) {
+        mShadowDrawableRight = d;
+    }
+
+    /**
+     * Set a drawable to use as a shadow cast by the right pane onto the left pane
+     * during opening/closing.
+     *
+     * @param resId Resource ID of a drawable to use
+     * @deprecated Renamed to {@link #setShadowResourceLeft(int)} to support LTR (left to
+     * right language) and {@link #setShadowResourceRight(int)} to support RTL (right to left
+     * language) during opening/closing.
+     */
+    @Deprecated
+    public void setShadowResource(@DrawableRes int resId) {
+        setShadowDrawable(getResources().getDrawable(resId));
+    }
+
+    /**
+     * Set a drawable to use as a shadow cast by the right pane onto the left pane
+     * during opening/closing.
+     *
+     * @param resId Resource ID of a drawable to use
+     */
+    public void setShadowResourceLeft(int resId) {
+        setShadowDrawableLeft(ContextCompat.getDrawable(getContext(), resId));
+    }
+
+    /**
+     * Set a drawable to use as a shadow cast by the left pane onto the right pane
+     * during opening/closing to support right to left language.
+     *
+     * @param resId Resource ID of a drawable to use
+     */
+    public void setShadowResourceRight(int resId) {
+        setShadowDrawableRight(ContextCompat.getDrawable(getContext(), resId));
+    }
+
+    @Override
+    public void draw(Canvas c) {
+        super.draw(c);
+        final boolean isLayoutRtl = isLayoutRtlSupport();
+        Drawable shadowDrawable;
+        if (isLayoutRtl) {
+            shadowDrawable = mShadowDrawableRight;
+        } else {
+            shadowDrawable = mShadowDrawableLeft;
+        }
+
+        final View shadowView = getChildCount() > 1 ? getChildAt(1) : null;
+        if (shadowView == null || shadowDrawable == null) {
+            // No need to draw a shadow if we don't have one.
+            return;
+        }
+
+        final int top = shadowView.getTop();
+        final int bottom = shadowView.getBottom();
+
+        final int shadowWidth = shadowDrawable.getIntrinsicWidth();
+        final int left;
+        final int right;
+        if (isLayoutRtlSupport()) {
+            left = shadowView.getRight();
+            right = left + shadowWidth;
+        } else {
+            right = shadowView.getLeft();
+            left = right - shadowWidth;
+        }
+
+        shadowDrawable.setBounds(left, top, right, bottom);
+        shadowDrawable.draw(c);
+    }
+
+    private void parallaxOtherViews(float slideOffset) {
+        final boolean isLayoutRtl = isLayoutRtlSupport();
+        final LayoutParams slideLp = (LayoutParams) mSlideableView.getLayoutParams();
+        final boolean dimViews = slideLp.dimWhenOffset
+                && (isLayoutRtl ? slideLp.rightMargin : slideLp.leftMargin) <= 0;
+        final int childCount = getChildCount();
+        for (int i = 0; i < childCount; i++) {
+            final View v = getChildAt(i);
+            if (v == mSlideableView) continue;
+
+            final int oldOffset = (int) ((1 - mParallaxOffset) * mParallaxBy);
+            mParallaxOffset = slideOffset;
+            final int newOffset = (int) ((1 - slideOffset) * mParallaxBy);
+            final int dx = oldOffset - newOffset;
+
+            v.offsetLeftAndRight(isLayoutRtl ? -dx : dx);
+
+            if (dimViews) {
+                dimChildView(v, isLayoutRtl ? mParallaxOffset - 1
+                        : 1 - mParallaxOffset, mCoveredFadeColor);
+            }
+        }
+    }
+
+    /**
+     * Tests scrollability within child views of v given a delta 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
+     * @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, int dx, int x, int 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();
+            // Count backwards - let topmost views consume scroll distance first.
+            for (int i = count - 1; i >= 0; i--) {
+                // TODO: Add versioned support here for transformed views.
+                // This will not work for transformed views in Honeycomb+
+                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 && ViewCompat.canScrollHorizontally(v, (isLayoutRtlSupport() ? dx : -dx));
+    }
+
+    boolean isDimmed(View child) {
+        if (child == null) {
+            return false;
+        }
+        final LayoutParams lp = (LayoutParams) child.getLayoutParams();
+        return mCanSlide && lp.dimWhenOffset && mSlideOffset > 0;
+    }
+
+    @Override
+    protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
+        return new LayoutParams();
+    }
+
+    @Override
+    protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
+        return p instanceof MarginLayoutParams
+                ? new LayoutParams((MarginLayoutParams) p)
+                : new LayoutParams(p);
+    }
+
+    @Override
+    protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
+        return p instanceof LayoutParams && super.checkLayoutParams(p);
+    }
+
+    @Override
+    public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
+        return new LayoutParams(getContext(), attrs);
+    }
+
+    @Override
+    protected Parcelable onSaveInstanceState() {
+        Parcelable superState = super.onSaveInstanceState();
+
+        SavedState ss = new SavedState(superState);
+        ss.isOpen = isSlideable() ? isOpen() : mPreservedOpenState;
+
+        return ss;
+    }
+
+    @Override
+    protected void onRestoreInstanceState(Parcelable state) {
+        if (!(state instanceof SavedState)) {
+            super.onRestoreInstanceState(state);
+            return;
+        }
+
+        SavedState ss = (SavedState) state;
+        super.onRestoreInstanceState(ss.getSuperState());
+
+        if (ss.isOpen) {
+            openPane();
+        } else {
+            closePane();
+        }
+        mPreservedOpenState = ss.isOpen;
+    }
+
+    private class DragHelperCallback extends ViewDragHelper.Callback {
+
+        DragHelperCallback() {
+        }
+
+        @Override
+        public boolean tryCaptureView(View child, int pointerId) {
+            if (mIsUnableToDrag) {
+                return false;
+            }
+
+            // ======================== 新加的 START ========================
+//            return ((LayoutParams) child.getLayoutParams()).slideable;
+
+            if (mIsOnlyTrackingLeftEdge) {
+                return false;
+            }
+            return isSwipeBackEnable() && ((LayoutParams) child.getLayoutParams()).slideable;
+            // ======================== 新加的 END ========================
+        }
+
+        @Override
+        public void onViewDragStateChanged(int state) {
+            if (mDragHelper.getViewDragState() == ViewDragHelper.STATE_IDLE) {
+                if (mSlideOffset == 0) {
+                    updateObscuredViewsVisibility(mSlideableView);
+                    dispatchOnPanelClosed(mSlideableView);
+                    mPreservedOpenState = false;
+                } else {
+                    dispatchOnPanelOpened(mSlideableView);
+                    mPreservedOpenState = true;
+                }
+                // ======================== 新加的 START ========================
+//            }
+                mIsSliding = false;
+            } else {
+                mIsSliding = true;
+            }
+            // ======================== 新加的 END ========================
+        }
+
+        @Override
+        public void onViewCaptured(View capturedChild, int activePointerId) {
+            // ======================== 新加的 START ========================
+            if (isSwipeBackEnable()) {
+                mShadowView.bindPreActivity();
+            }
+            // ======================== 新加的 END ========================
+            // Make all child views visible in preparation for sliding things around
+            setAllChildrenVisible();
+        }
+
+        @Override
+        public void onViewPositionChanged(View changedView, int left, int top, int dx, int dy) {
+            onPanelDragged(left);
+            invalidate();
+        }
+
+        @Override
+        public void onViewReleased(View releasedChild, float xvel, float yvel) {
+            final LayoutParams lp = (LayoutParams) releasedChild.getLayoutParams();
+
+            int left;
+            if (isLayoutRtlSupport()) {
+                int startToRight = getPaddingRight() + lp.rightMargin;
+                if (xvel < 0 || (xvel == 0 && mSlideOffset > mSwipeBackThreshold)) {
+                    startToRight += mSlideRange;
+                }
+                int childWidth = mSlideableView.getWidth();
+                left = getWidth() - startToRight - childWidth;
+            } else {
+                left = getPaddingLeft() + lp.leftMargin;
+                if (xvel > 0 || (xvel == 0 && mSlideOffset > mSwipeBackThreshold)) {
+                    left += mSlideRange;
+                }
+            }
+            mDragHelper.settleCapturedViewAt(left, releasedChild.getTop());
+            invalidate();
+        }
+
+        @Override
+        public int getViewHorizontalDragRange(View child) {
+            return mSlideRange;
+        }
+
+        @Override
+        public int clampViewPositionHorizontal(View child, int left, int dx) {
+            final LayoutParams lp = (LayoutParams) mSlideableView.getLayoutParams();
+
+            final int newLeft;
+            if (isLayoutRtlSupport()) {
+                int startBound = getWidth()
+                        - (getPaddingRight() + lp.rightMargin + mSlideableView.getWidth());
+                int endBound = startBound - mSlideRange;
+                newLeft = Math.max(Math.min(left, startBound), endBound);
+            } else {
+                int startBound = getPaddingLeft() + lp.leftMargin;
+                int endBound = startBound + mSlideRange;
+                newLeft = Math.min(Math.max(left, startBound), endBound);
+            }
+            return newLeft;
+        }
+
+        @Override
+        public int clampViewPositionVertical(View child, int top, int dy) {
+            // Make sure we never move views vertically.
+            // This could happen if the child has less height than its parent.
+            return child.getTop();
+        }
+
+        @Override
+        public void onEdgeDragStarted(int edgeFlags, int pointerId) {
+            // ======================== 新加的 START ========================
+//            mDragHelper.captureChildView(mSlideableView, pointerId);
+
+            if (isSwipeBackEnable()) {
+                mDragHelper.captureChildView(mSlideableView, pointerId);
+            }
+            // ======================== 新加的 END ========================
+        }
+    }
+
+    public static class LayoutParams extends ViewGroup.MarginLayoutParams {
+        private static final int[] ATTRS = new int[]{
+                android.R.attr.layout_weight
+        };
+
+        /**
+         * The weighted proportion of how much of the leftover space
+         * this child should consume after measurement.
+         */
+        public float weight = 0;
+
+        /**
+         * True if this pane is the slideable pane in the layout.
+         */
+        boolean slideable;
+
+        /**
+         * True if this view should be drawn dimmed
+         * when it's been offset from its default position.
+         */
+        boolean dimWhenOffset;
+
+        Paint dimPaint;
+
+        public LayoutParams() {
+            super(MATCH_PARENT, MATCH_PARENT);
+        }
+
+        public LayoutParams(int width, int height) {
+            super(width, height);
+        }
+
+        public LayoutParams(android.view.ViewGroup.LayoutParams source) {
+            super(source);
+        }
+
+        public LayoutParams(MarginLayoutParams source) {
+            super(source);
+        }
+
+        public LayoutParams(LayoutParams source) {
+            super(source);
+            this.weight = source.weight;
+        }
+
+        public LayoutParams(Context c, AttributeSet attrs) {
+            super(c, attrs);
+
+            final TypedArray a = c.obtainStyledAttributes(attrs, ATTRS);
+            this.weight = a.getFloat(0, 0);
+            a.recycle();
+        }
+
+    }
+
+    static class SavedState extends AbsSavedState {
+        boolean isOpen;
+
+        SavedState(Parcelable superState) {
+            super(superState);
+        }
+
+        SavedState(Parcel in, ClassLoader loader) {
+            super(in, loader);
+            isOpen = in.readInt() != 0;
+        }
+
+        @Override
+        public void writeToParcel(Parcel out, int flags) {
+            super.writeToParcel(out, flags);
+            out.writeInt(isOpen ? 1 : 0);
+        }
+
+        public static final Creator<SavedState> CREATOR = ParcelableCompat.newCreator(
+                new ParcelableCompatCreatorCallbacks<SavedState>() {
+                    @Override
+                    public SavedState createFromParcel(Parcel in, ClassLoader loader) {
+                        return new SavedState(in, loader);
+                    }
+
+                    @Override
+                    public SavedState[] newArray(int size) {
+                        return new SavedState[size];
+                    }
+                });
+    }
+
+    interface SlidingPanelLayoutImpl {
+        void invalidateChildRegion(SwipeBackLayout parent, View child);
+    }
+
+    static class SlidingPanelLayoutImplBase implements SlidingPanelLayoutImpl {
+        @Override
+        public void invalidateChildRegion(SwipeBackLayout parent, View child) {
+            ViewCompat.postInvalidateOnAnimation(parent, child.getLeft(), child.getTop(),
+                    child.getRight(), child.getBottom());
+        }
+    }
+
+    static class SlidingPanelLayoutImplJB extends SlidingPanelLayoutImplBase {
+        /*
+         * Private API hacks! Nasty! Bad!
+         *
+         * In Jellybean, some optimizations in the hardware UI renderer
+         * prevent a changed Paint on a View using a hardware layer from having
+         * the intended effect. This twiddles some internal bits on the view to force
+         * it to recreate the display list.
+         */
+        private Method mGetDisplayList;
+        private Field mRecreateDisplayList;
+
+        SlidingPanelLayoutImplJB() {
+            try {
+                mGetDisplayList = View.class.getDeclaredMethod("getDisplayList", (Class[]) null);
+            } catch (NoSuchMethodException e) {
+                Log.e(TAG, "Couldn't fetch getDisplayList method; dimming won't work right.", e);
+            }
+            try {
+                mRecreateDisplayList = View.class.getDeclaredField("mRecreateDisplayList");
+                mRecreateDisplayList.setAccessible(true);
+            } catch (NoSuchFieldException e) {
+                Log.e(TAG, "Couldn't fetch mRecreateDisplayList field; dimming will be slow.", e);
+            }
+        }
+
+        @Override
+        public void invalidateChildRegion(SwipeBackLayout parent, View child) {
+            if (mGetDisplayList != null && mRecreateDisplayList != null) {
+                try {
+                    mRecreateDisplayList.setBoolean(child, true);
+                    mGetDisplayList.invoke(child, (Object[]) null);
+                } catch (Exception e) {
+                    Log.e(TAG, "Error refreshing display list state", e);
+                }
+            } else {
+                // Slow path. REALLY slow path. Let's hope we don't get here.
+                child.invalidate();
+                return;
+            }
+            super.invalidateChildRegion(parent, child);
+        }
+    }
+
+    static class SlidingPanelLayoutImplJBMR1 extends SlidingPanelLayoutImplBase {
+        @Override
+        public void invalidateChildRegion(SwipeBackLayout parent, View child) {
+            ViewCompat.setLayerPaint(child, ((LayoutParams) child.getLayoutParams()).dimPaint);
+        }
+    }
+
+    class AccessibilityDelegate extends AccessibilityDelegateCompat {
+        private final Rect mTmpRect = new Rect();
+
+        @Override
+        public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfoCompat info) {
+            final AccessibilityNodeInfoCompat superNode = AccessibilityNodeInfoCompat.obtain(info);
+            super.onInitializeAccessibilityNodeInfo(host, superNode);
+            copyNodeInfoNoChildren(info, superNode);
+            superNode.recycle();
+
+            info.setClassName(SwipeBackLayout.class.getName());
+            info.setSource(host);
+
+            final ViewParent parent = ViewCompat.getParentForAccessibility(host);
+            if (parent instanceof View) {
+                info.setParent((View) parent);
+            }
+
+            // This is a best-approximation of addChildrenForAccessibility()
+            // that accounts for filtering.
+            final int childCount = getChildCount();
+            for (int i = 0; i < childCount; i++) {
+                final View child = getChildAt(i);
+                if (!filter(child) && (child.getVisibility() == View.VISIBLE)) {
+                    // Force importance to "yes" since we can't read the value.
+                    ViewCompat.setImportantForAccessibility(
+                            child, ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_YES);
+                    info.addChild(child);
+                }
+            }
+        }
+
+        @Override
+        public void onInitializeAccessibilityEvent(View host, AccessibilityEvent event) {
+            super.onInitializeAccessibilityEvent(host, event);
+
+            event.setClassName(SwipeBackLayout.class.getName());
+        }
+
+        @Override
+        public boolean onRequestSendAccessibilityEvent(ViewGroup host, View child,
+                AccessibilityEvent event) {
+            if (!filter(child)) {
+                return super.onRequestSendAccessibilityEvent(host, child, event);
+            }
+            return false;
+        }
+
+        public boolean filter(View child) {
+            return isDimmed(child);
+        }
+
+        /**
+         * This should really be in AccessibilityNodeInfoCompat, but there unfortunately
+         * seem to be a few elements that are not easily cloneable using the underlying API.
+         * Leave it private here as it's not general-purpose useful.
+         */
+        private void copyNodeInfoNoChildren(AccessibilityNodeInfoCompat dest,
+                AccessibilityNodeInfoCompat src) {
+            final Rect rect = mTmpRect;
+
+            src.getBoundsInParent(rect);
+            dest.setBoundsInParent(rect);
+
+            src.getBoundsInScreen(rect);
+            dest.setBoundsInScreen(rect);
+
+            dest.setVisibleToUser(src.isVisibleToUser());
+            dest.setPackageName(src.getPackageName());
+            dest.setClassName(src.getClassName());
+            dest.setContentDescription(src.getContentDescription());
+
+            dest.setEnabled(src.isEnabled());
+            dest.setClickable(src.isClickable());
+            dest.setFocusable(src.isFocusable());
+            dest.setFocused(src.isFocused());
+            dest.setAccessibilityFocused(src.isAccessibilityFocused());
+            dest.setSelected(src.isSelected());
+            dest.setLongClickable(src.isLongClickable());
+
+            dest.addAction(src.getActions());
+
+            dest.setMovementGranularities(src.getMovementGranularities());
+        }
+    }
+
+    private class DisableLayerRunnable implements Runnable {
+        final View mChildView;
+
+        DisableLayerRunnable(View childView) {
+            mChildView = childView;
+        }
+
+        @Override
+        public void run() {
+            if (mChildView.getParent() == this) {
+                ViewCompat.setLayerType(mChildView, ViewCompat.LAYER_TYPE_NONE, null);
+                invalidateChildRegion(mChildView);
+            }
+            mPostedRunnables.remove(this);
+        }
+    }
+
+    boolean isLayoutRtlSupport() {
+        return ViewCompat.getLayoutDirection(this) == ViewCompat.LAYOUT_DIRECTION_RTL;
+    }
+}
diff --git a/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackManager.java b/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackManager.java
new file mode 100644
index 000000000..86d8a599b
--- /dev/null
+++ b/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackManager.java
@@ -0,0 +1,115 @@
+package com.yc.swipe;
+
+import android.app.Activity;
+import android.app.Application;
+import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.view.SurfaceView;
+import android.view.View;
+import android.webkit.WebView;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.Stack;
+
+
+public class SwipeBackManager implements Application.ActivityLifecycleCallbacks {
+    private static final SwipeBackManager sInstance = new SwipeBackManager();
+    private Stack<Activity> mActivityStack = new Stack<>();
+    private Set<Class<? extends View>> mProblemViewClassSet = new HashSet<>();
+
+    public static SwipeBackManager getInstance() {
+        return sInstance;
+    }
+
+    private SwipeBackManager() {
+    }
+
+    public void init(Application application, List<Class<? extends View>> problemViewClassList) {
+        application.registerActivityLifecycleCallbacks(this);
+
+        mProblemViewClassSet.add(WebView.class);
+        mProblemViewClassSet.add(SurfaceView.class);
+        if (problemViewClassList != null) {
+            mProblemViewClassSet.addAll(problemViewClassList);
+        }
+    }
+
+    @Override
+    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
+        mActivityStack.add(activity);
+    }
+
+    @Override
+    public void onActivityStarted(Activity activity) {
+    }
+
+    @Override
+    public void onActivityResumed(Activity activity) {
+    }
+
+    @Override
+    public void onActivityPaused(Activity activity) {
+    }
+
+    @Override
+    public void onActivityStopped(Activity activity) {
+    }
+
+    @Override
+    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
+    }
+
+    @Override
+    public void onActivityDestroyed(Activity activity) {
+        mActivityStack.remove(activity);
+    }
+
+    /**
+     * 获取倒数第二个 Activity
+     *
+     * @return
+     */
+    @Nullable
+    public Activity getPenultimateActivity(Activity currentActivity) {
+        Activity activity = null;
+        try {
+            if (mActivityStack.size() > 1) {
+                activity = mActivityStack.get(mActivityStack.size() - 2);
+
+                if (currentActivity.equals(activity)) {
+                    int index = mActivityStack.indexOf(currentActivity);
+                    if (index > 0) {
+                        // 处理内存泄漏或最后一个 Activity 正在 finishing 的情况
+                        activity = mActivityStack.get(index - 1);
+                    } else if (mActivityStack.size() == 2) {
+                        // 处理屏幕旋转后 mActivityStack 中顺序错乱
+                        activity = mActivityStack.lastElement();
+                    }
+                }
+            }
+        } catch (Exception e) {
+        }
+        return activity;
+    }
+
+    /**
+     * 滑动返回是否可用
+     *
+     * @return
+     */
+    public boolean isSwipeBackEnable() {
+        return mActivityStack.size() > 1;
+    }
+
+    /**
+     * 某个 view 是否会导致滑动返回后立即触摸界面时应用崩溃
+     *
+     * @param view
+     * @return
+     */
+    public boolean isProblemView(View view) {
+        return mProblemViewClassSet.contains(view.getClass());
+    }
+}
\ No newline at end of file
diff --git a/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackShadowView.java b/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackShadowView.java
new file mode 100644
index 000000000..a7a7a32a7
--- /dev/null
+++ b/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeBackShadowView.java
@@ -0,0 +1,287 @@
+package com.yc.swipe;
+
+import android.app.Activity;
+import android.content.res.TypedArray;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.support.annotation.DrawableRes;
+import android.support.v4.view.ViewCompat;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.RelativeLayout;
+import java.lang.ref.WeakReference;
+import cn.bingoogolapple.swipebacklayout.R;
+
+
+public class SwipeBackShadowView extends FrameLayout {
+
+    private static final String TAG = SwipeBackShadowView.class.getSimpleName();
+    private static final float WE_CHAT_STYLE_MAX_OFFSET = 0.75f;
+    private Activity mActivity;
+    private WeakReference<Activity> mPreActivity;
+    private ViewGroup mPreDecorView;
+    private View mPreContentView;
+    private ImageView mPreImageView;
+    private View mShadowView;
+
+    /**
+     * 是否显示滑动返回的阴影效果
+     */
+    private boolean mIsNeedShowShadow = true;
+    /**
+     * 阴影资源 id
+     */
+    private int mShadowResId = R.drawable.swipe_shadow;
+    /**
+     * 阴影区域的透明度是否根据滑动的距离渐变
+     */
+    private boolean mIsShadowAlphaGradient = true;
+    /**
+     * 是否是微信滑动返回样式
+     */
+    private boolean mIsWeChatStyle = true;
+
+    private boolean mIsCurrentActivityTranslucent;
+
+    SwipeBackShadowView(Activity activity) {
+        super(activity);
+        mActivity = activity;
+
+        TypedArray typedArray = mActivity.getTheme().obtainStyledAttributes(new int[]{
+                android.R.attr.windowIsTranslucent
+        });
+        mIsCurrentActivityTranslucent = typedArray.getBoolean(0, false);
+        typedArray.recycle();
+    }
+
+    /**
+     * 设置是否显示滑动返回的阴影效果。默认值为 true
+     */
+    void setIsNeedShowShadow(boolean isNeedShowShadow) {
+        mIsNeedShowShadow = isNeedShowShadow;
+        updateShadow();
+    }
+
+    /**
+     * 设置阴影资源 id。默认值为 R.drawable.bga_sbl_shadow
+     */
+    void setShadowResId(@DrawableRes int shadowResId) {
+        mShadowResId = shadowResId;
+        updateShadow();
+    }
+
+    /**
+     * 设置阴影区域的透明度是否根据滑动的距离渐变。默认值为 true
+     */
+    void setIsShadowAlphaGradient(boolean isShadowAlphaGradient) {
+        mIsShadowAlphaGradient = isShadowAlphaGradient;
+    }
+
+    /**
+     * 设置是否是微信滑动返回样式。默认值为 true
+     */
+    void setIsWeChatStyle(boolean isWeChatStyle) {
+        mIsWeChatStyle = isWeChatStyle;
+    }
+
+    private void updateShadow() {
+        if (mIsCurrentActivityTranslucent) {
+            if (mIsNeedShowShadow) {
+                setBackgroundResource(mShadowResId);
+            } else {
+                setBackgroundResource(android.R.color.transparent);
+            }
+        } else {
+            if (mIsNeedShowShadow) {
+                if (mShadowView == null) {
+                    mShadowView = new View(getContext());
+                    addView(mShadowView, getChildCount(), new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+                }
+                mShadowView.setBackgroundResource(mShadowResId);
+            } else {
+                if (mShadowView != null) {
+                    removeView(mShadowView);
+                }
+            }
+        }
+    }
+
+    void bindPreActivity() {
+        if (mIsCurrentActivityTranslucent) {
+            return;
+        }
+
+        if (mPreActivity == null) {
+            Activity preActivity = SwipeBackManager.getInstance().getPenultimateActivity(mActivity);
+            if (preActivity != null) {
+                mPreActivity = new WeakReference<>(preActivity);
+                mPreDecorView = (ViewGroup) preActivity.getWindow().getDecorView();
+                mPreContentView = mPreDecorView.getChildAt(0);
+                mPreDecorView.removeView(mPreContentView);
+                addView(mPreContentView, 0, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+            }
+        }
+    }
+
+    void unBindPreActivity(boolean isNeedAddImageView) {
+        if (mIsCurrentActivityTranslucent) {
+            return;
+        }
+
+        if (mPreActivity == null) {
+            return;
+        }
+
+        Activity activity = mPreActivity.get();
+        if (activity == null || activity.isFinishing()) {
+            return;
+        }
+
+        if (mPreDecorView != null && mPreContentView != null) {
+            if (isNeedAddImageView && mPreImageView == null && containsProblemView((ViewGroup) mPreContentView)) {
+                mPreImageView = new ImageView(mActivity);
+                mPreImageView.setScaleType(ImageView.ScaleType.FIT_XY);
+                mPreImageView.setImageBitmap(getBitmap(mPreContentView));
+                addView(mPreImageView, 0, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+            }
+
+            removeView(mPreContentView);
+
+            ViewGroup.LayoutParams lp = null;
+            if (!(mPreContentView instanceof SwipeBackLayout)) {
+                int width = mPreDecorView.getWidth();
+                int height = mPreDecorView.getHeight() - SwipeUiUtils.getNavigationBarHeight(activity);
+                if (!SwipeUiUtils.isPortrait(activity)) {
+                    width = mPreDecorView.getWidth() - SwipeUiUtils.getNavigationBarHeight(activity);
+                    height = mPreDecorView.getHeight();
+                }
+                if (mPreDecorView instanceof FrameLayout) {
+                    lp = new FrameLayout.LayoutParams(width, height);
+                } else if (mPreDecorView instanceof LinearLayout) {
+                    lp = new LinearLayout.LayoutParams(width, height);
+                } else if (mPreDecorView instanceof RelativeLayout) {
+                    lp = new RelativeLayout.LayoutParams(width, height);
+                }
+            }
+            if (lp == null) {
+                mPreDecorView.addView(mPreContentView, 0);
+            } else {
+                mPreDecorView.addView(mPreContentView, 0, lp);
+            }
+
+            mPreContentView = null;
+            mPreActivity.clear();
+            mPreActivity = null;
+        }
+    }
+
+    @Override
+    protected void dispatchDraw(final Canvas canvas) {
+        super.dispatchDraw(canvas);
+        if (mIsCurrentActivityTranslucent) {
+            return;
+        }
+
+        if (mPreImageView != null) {
+            return;
+        }
+
+        // add 和 remove 方式时，滑动返回结束后的最后一帧通过 draw 来实现，避免抖动
+        if (mPreContentView == null && mPreDecorView != null) {
+            mPreDecorView.draw(canvas);
+        }
+    }
+
+    private Bitmap getBitmap(View view) {
+        view.setDrawingCacheEnabled(true);
+        view.buildDrawingCache();
+        Bitmap bitmap = Bitmap.createBitmap(view.getDrawingCache(), 0, 0,
+                SwipeUiUtils.getRealScreenWidth(mActivity),
+                SwipeUiUtils.getRealScreenHeight(mActivity) - SwipeUiUtils.getNavigationBarHeight(mActivity));
+        view.destroyDrawingCache();
+        return bitmap;
+    }
+
+    /**
+     * 该 ViewGroup 中是否包含导致多次 draw 后应用崩溃的 View
+     */
+    private boolean containsProblemView(ViewGroup viewGroup) {
+        int childCount = viewGroup.getChildCount();
+        View childView;
+        for (int i = 0; i < childCount; i++) {
+            childView = viewGroup.getChildAt(i);
+            if (SwipeBackManager.getInstance().isProblemView(childView)) {
+                return true;
+            } else if (childView instanceof ViewGroup) {
+                if (containsProblemView((ViewGroup) childView)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    void setShadowAlpha(float alpha) {
+        if (mIsNeedShowShadow && mIsShadowAlphaGradient) {
+            if (mIsCurrentActivityTranslucent) {
+                ViewCompat.setAlpha(this, alpha);
+            } else if (mShadowView != null) {
+                ViewCompat.setAlpha(mShadowView, alpha);
+            }
+        }
+    }
+
+    void onPanelSlide(float slideOffset) {
+        if (mIsWeChatStyle) { // 微信滑动返回样式的情况
+            if (mIsCurrentActivityTranslucent) { // 透明主题
+                onPanelSlide(mActivity, slideOffset);
+            } else if (mPreContentView != null) { // 非透明主题
+                ViewCompat.setTranslationX(mPreContentView, (mPreContentView.getMeasuredWidth() * WE_CHAT_STYLE_MAX_OFFSET) * (1 - slideOffset));
+            }
+        } else { // 非微信滑动返回样式的情况
+            if (!mIsCurrentActivityTranslucent && mPreContentView != null) { // 只有非透明主题时才移动
+                ViewCompat.setTranslationX(mPreContentView, mPreContentView.getMeasuredWidth() * (1 - slideOffset));
+            }
+        }
+    }
+
+    private void onPanelSlide(Activity currentActivity, float slideOffset) {
+        try {
+            Activity preActivity = SwipeBackManager.getInstance().getPenultimateActivity(currentActivity);
+            if (preActivity != null) {
+                View decorView = preActivity.getWindow().getDecorView();
+                ViewCompat.setTranslationX(decorView, -decorView.getMeasuredWidth() * (1 - WE_CHAT_STYLE_MAX_OFFSET) * (1 - slideOffset));
+            }
+        } catch (Exception e) {
+        }
+    }
+
+    void onPanelClosed() {
+        if (mIsWeChatStyle) { // 微信滑动返回样式的情况
+            if (mIsCurrentActivityTranslucent) { // 透明主题
+                onPanelClosed(mActivity);
+            } else if (mPreContentView != null) { // 非透明主题
+                ViewCompat.setTranslationX(mPreContentView, 0);
+            }
+        } else { // 非微信滑动返回样式的情况
+            if (!mIsCurrentActivityTranslucent && mPreContentView != null) { // 只有非透明主题时才移动
+                ViewCompat.setTranslationX(mPreContentView, 0);
+            }
+        }
+        unBindPreActivity(false);
+    }
+
+    private void onPanelClosed(Activity currentActivity) {
+        try {
+            Activity preActivity = SwipeBackManager.getInstance().getPenultimateActivity(currentActivity);
+            if (preActivity != null) {
+                View decorView = preActivity.getWindow().getDecorView();
+                ViewCompat.setTranslationX(decorView, 0);
+            }
+        } catch (Exception e) {
+        }
+    }
+}
diff --git a/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeKeyboardUtil.java b/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeKeyboardUtil.java
new file mode 100644
index 000000000..e6dce8878
--- /dev/null
+++ b/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeKeyboardUtil.java
@@ -0,0 +1,117 @@
+
+package com.yc.swipe;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.ClipData;
+import android.content.ClipboardManager;
+import android.content.Context;
+import android.os.Build;
+import android.os.Handler;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.EditText;
+
+
+public final class SwipeKeyboardUtil {
+    private SwipeKeyboardUtil() {
+    }
+
+    /**
+     * 关闭activity中打开的键盘
+     *
+     * @param activity
+     */
+    public static void closeKeyboard(Activity activity) {
+        View view = activity.getWindow().peekDecorView();
+        if (view != null) {
+            InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
+            inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
+        }
+    }
+
+    /**
+     * 关闭dialog中打开的键盘
+     *
+     * @param dialog
+     */
+    public static void closeKeyboard(Dialog dialog) {
+        View view = dialog.getWindow().peekDecorView();
+        if (view != null) {
+            InputMethodManager inputMethodManager = (InputMethodManager) dialog.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
+            inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
+        }
+    }
+
+    /**
+     * 打开键盘
+     *
+     * @param context
+     * @param editText
+     */
+    public static void openKeyboard(final Context context, final EditText editText) {
+        new Handler().postDelayed(new Runnable() {
+            @Override
+            public void run() {
+                editText.requestFocus();
+                editText.setSelection(editText.getText().toString().length());
+                InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
+                imm.showSoftInput(editText, InputMethodManager.SHOW_FORCED);
+            }
+        }, 300);
+    }
+
+    /**
+     * 拷贝文档到黏贴板
+     *
+     * @param text
+     */
+    public static void clip(Context context, String text) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
+            android.text.ClipboardManager clipboardManager = (android.text.ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);
+            clipboardManager.setText(text);
+        } else {
+            ClipboardManager clipboardManager = (ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);
+            clipboardManager.setPrimaryClip(ClipData.newPlainText("content", text));
+        }
+    }
+
+    /**
+     * 切换键盘的显示与隐藏
+     *
+     * @param activity
+     */
+    public static void toggleKeyboard(Activity activity) {
+        InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
+        if (inputMethodManager.isActive()) {
+            inputMethodManager.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS);
+        }
+    }
+
+    /**
+     * 处理点击非 EditText 区域时，自动关闭键盘
+     *
+     * @param isAutoCloseKeyboard 是否自动关闭键盘
+     * @param currentFocusView    当前获取焦点的控件
+     * @param motionEvent         触摸事件
+     * @param dialogOrActivity    Dialog 或 Activity
+     */
+    public static void handleAutoCloseKeyboard(boolean isAutoCloseKeyboard, View currentFocusView, MotionEvent motionEvent, Object dialogOrActivity) {
+        if (isAutoCloseKeyboard && motionEvent.getAction() == MotionEvent.ACTION_DOWN && currentFocusView != null && (currentFocusView instanceof EditText) && dialogOrActivity != null) {
+            int[] leftTop = {0, 0};
+            currentFocusView.getLocationInWindow(leftTop);
+            int left = leftTop[0];
+            int top = leftTop[1];
+            int bottom = top + currentFocusView.getHeight();
+            int right = left + currentFocusView.getWidth();
+            if (!(motionEvent.getX() > left && motionEvent.getX() < right && motionEvent.getY() > top && motionEvent.getY() < bottom)) {
+                if (dialogOrActivity instanceof Dialog) {
+                    closeKeyboard((Dialog) dialogOrActivity);
+                } else if (dialogOrActivity instanceof Activity) {
+                    closeKeyboard((Activity) dialogOrActivity);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeUiUtils.java b/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeUiUtils.java
new file mode 100644
index 000000000..726d9f5e9
--- /dev/null
+++ b/Widget/SwipeBackLib/src/main/java/com/yc/swipe/SwipeUiUtils.java
@@ -0,0 +1,137 @@
+package com.yc.swipe;
+
+import android.app.Activity;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.os.Build;
+import android.util.DisplayMetrics;
+import android.view.Display;
+import android.view.View;
+import android.view.WindowManager;
+
+import java.lang.reflect.Method;
+
+
+class SwipeUiUtils {
+
+    private SwipeUiUtils() {
+    }
+
+    /**
+     * 获取底部导航栏高度
+     */
+    public static int getNavigationBarHeight(Activity activity) {
+        int navigationBarHeight = 0;
+        Resources resources = activity.getResources();
+        int resourceId = resources.getIdentifier(isPortrait(activity) ? "navigation_bar_height" : "navigation_bar_height_landscape", "dimen", "android");
+        if (resourceId > 0 && checkDeviceHasNavigationBar(activity) && isNavigationBarVisible(activity)) {
+            navigationBarHeight = resources.getDimensionPixelSize(resourceId);
+        }
+        return navigationBarHeight;
+    }
+
+    /**
+     * 是否为竖屏
+     */
+    public static boolean isPortrait(Activity activity) {
+        return activity.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT;
+    }
+
+    /**
+     * 手机具有底部导航栏时，底部导航栏是否可见
+     */
+    private static boolean isNavigationBarVisible(Activity activity) {
+//        View decorView = activity.getWindow().getDecorView();
+//        return (decorView.getSystemUiVisibility() & View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) != 2;
+
+        boolean show = false;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+            Display display = activity.getWindow().getWindowManager().getDefaultDisplay();
+            Point point = new Point();
+            display.getRealSize(point);
+            View decorView = activity.getWindow().getDecorView();
+            Configuration conf = activity.getResources().getConfiguration();
+            if (Configuration.ORIENTATION_LANDSCAPE == conf.orientation) {
+                View contentView = decorView.findViewById(android.R.id.content);
+                if (contentView != null) {
+                    show = (point.x != contentView.getWidth());
+                }
+            } else {
+                Rect rect = new Rect();
+                decorView.getWindowVisibleDisplayFrame(rect);
+                show = (rect.bottom != point.y);
+            }
+        }
+        return show;
+    }
+
+    /**
+     * 检测是否具有底部导航栏
+     */
+    private static boolean checkDeviceHasNavigationBar(Activity activity) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+            WindowManager windowManager = activity.getWindowManager();
+            Display display = windowManager.getDefaultDisplay();
+            DisplayMetrics realDisplayMetrics = new DisplayMetrics();
+            display.getRealMetrics(realDisplayMetrics);
+            int realHeight = realDisplayMetrics.heightPixels;
+            int realWidth = realDisplayMetrics.widthPixels;
+            DisplayMetrics displayMetrics = new DisplayMetrics();
+            display.getMetrics(displayMetrics);
+            int displayHeight = displayMetrics.heightPixels;
+            int displayWidth = displayMetrics.widthPixels;
+            return (realWidth - displayWidth) > 0 || (realHeight - displayHeight) > 0;
+        } else {
+            boolean hasNavigationBar = false;
+            Resources resources = Resources.getSystem();
+            int id = resources.getIdentifier("config_showNavigationBar", "bool", "android");
+            if (id > 0) {
+                hasNavigationBar = resources.getBoolean(id);
+            }
+            try {
+                Class systemPropertiesClass = Class.forName("android.os.SystemProperties");
+                Method m = systemPropertiesClass.getMethod("get", String.class);
+                String navBarOverride = (String) m.invoke(systemPropertiesClass, "qemu.hw.mainkeys");
+                if ("1".equals(navBarOverride)) {
+                    hasNavigationBar = false;
+                } else if ("0".equals(navBarOverride)) {
+                    hasNavigationBar = true;
+                }
+            } catch (Exception e) {
+            }
+            return hasNavigationBar;
+        }
+    }
+
+    /**
+     * 获取屏幕高度，包括底部导航栏
+     */
+    public static int getRealScreenHeight(Activity activity) {
+        WindowManager windowManager = activity.getWindowManager();
+        Display display = windowManager.getDefaultDisplay();
+        DisplayMetrics displayMetrics = new DisplayMetrics();
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+            display.getRealMetrics(displayMetrics);
+        } else {
+            display.getMetrics(displayMetrics);
+        }
+        return displayMetrics.heightPixels;
+    }
+
+    /**
+     * 获取屏幕宽度，不包括右侧导航栏
+     */
+    public static int getRealScreenWidth(Activity activity) {
+        WindowManager windowManager = activity.getWindowManager();
+        Display display = windowManager.getDefaultDisplay();
+        DisplayMetrics displayMetrics = new DisplayMetrics();
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+            display.getRealMetrics(displayMetrics);
+        } else {
+            display.getMetrics(displayMetrics);
+        }
+        return displayMetrics.widthPixels;
+    }
+}
diff --git a/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_backward_enter.xml b/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_backward_enter.xml
new file mode 100644
index 000000000..6db928152
--- /dev/null
+++ b/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_backward_enter.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<translate xmlns:android="http://schemas.android.com/apk/res/android"
+           android:duration="200"
+           android:fromXDelta="-100%p"
+           android:fromYDelta="0"
+           android:toXDelta="0"
+           android:toYDelta="0"/>
\ No newline at end of file
diff --git a/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_backward_exit.xml b/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_backward_exit.xml
new file mode 100644
index 000000000..62fdb7e6d
--- /dev/null
+++ b/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_backward_exit.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<translate xmlns:android="http://schemas.android.com/apk/res/android"
+           android:duration="200"
+           android:fromXDelta="0"
+           android:fromYDelta="0"
+           android:toXDelta="100%p"
+           android:toYDelta="0"/>
\ No newline at end of file
diff --git a/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_forward_enter.xml b/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_forward_enter.xml
new file mode 100644
index 000000000..10a10d57d
--- /dev/null
+++ b/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_forward_enter.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<translate xmlns:android="http://schemas.android.com/apk/res/android"
+           android:duration="200"
+           android:fromXDelta="100%p"
+           android:fromYDelta="0"
+           android:toXDelta="0"
+           android:toYDelta="0"/>
\ No newline at end of file
diff --git a/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_forward_exit.xml b/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_forward_exit.xml
new file mode 100644
index 000000000..96c6d36c9
--- /dev/null
+++ b/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_forward_exit.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<translate xmlns:android="http://schemas.android.com/apk/res/android"
+           android:duration="200"
+           android:fromXDelta="0"
+           android:fromYDelta="0"
+           android:toXDelta="-100%p"
+           android:toYDelta="0"/>
\ No newline at end of file
diff --git a/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_swipeback_enter.xml b/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_swipeback_enter.xml
new file mode 100644
index 000000000..46591ab0e
--- /dev/null
+++ b/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_swipeback_enter.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<translate xmlns:android="http://schemas.android.com/apk/res/android"
+           android:duration="0"
+           android:fromXDelta="0"
+           android:fromYDelta="0"
+           android:toXDelta="0"
+           android:toYDelta="0"/>
\ No newline at end of file
diff --git a/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_swipeback_exit.xml b/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_swipeback_exit.xml
new file mode 100644
index 000000000..8fccf50d2
--- /dev/null
+++ b/Widget/SwipeBackLib/src/main/res/anim/swipe_activity_swipeback_exit.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<translate xmlns:android="http://schemas.android.com/apk/res/android"
+    android:duration="10"
+    android:fromXDelta="0"
+    android:fromYDelta="0"
+    android:toXDelta="100%p"
+    android:toYDelta="0" />
\ No newline at end of file
diff --git a/Widget/SwipeBackLib/src/main/res/drawable/swipe_shadow.9.png b/Widget/SwipeBackLib/src/main/res/drawable/swipe_shadow.9.png
new file mode 100644
index 0000000000000000000000000000000000000000..211768c9728d9f2faeadc554935286ec30fbcb13
GIT binary patch
literal 300
zcmV+{0n`48P)<h;3K|Lk000e1NJLTq000&M002Y?1^@s6h4RJ60002<Nkl<Zc-rlj
z(F%e<5Jk<RjL@WvG|C7qwEqA5>_!I5vW~7=4{;aH>t(nz9(0`dtDG-C7tFvMEWru{
zAOu^m1ACBwBRGQ#$iNMh;9&}$fT<SjgEiQIs182V!KoHpNWq_pJz-)!IJXH_Ck~Z~
zW1)(|riwrb)+aUv-}_A5w7k|T+?I}`hKX~VtMD4CP&>9>-oj9YH1VKwQ|~w#5-ct6
zHStO7_}aESy<=ZEx76@ScRn{$6;g2TDq`W>td{2st{5d)y5p?N^5|pwm_DYD>El21
yaYY}~$Mi9MOds?Am_DYD>0|nsKK`wbM|)2sq-YKyV}!;40000<MNUMnLSTZ0Oox8}

literal 0
HcmV?d00001

diff --git a/app/.gitignore b/app/.gitignore
index c105a4fe1..60d929df9 100644
--- a/app/.gitignore
+++ b/app/.gitignore
@@ -12,6 +12,7 @@
 /captures
 .externalNativeBuild
 .cxx
+.idea/
 
 
 
diff --git a/settings.gradle b/settings.gradle
index 2060dcb33..b04dd411a 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -31,7 +31,8 @@ project(':ToolUtilsLib').projectDir = new File('Common/ToolUtilsLib')
 
 /* +++++++++ 框架view基础组件层 +++++++++ */
 include ':BannerWidget', ':PhotoWidget', ':CustomWidget', ':BlurView',
-        ':FragmentLib',':WidgetViewLib',':ZoomImageLib', ':LargeImageLib'
+        ':FragmentLib',':WidgetViewLib',':ZoomImageLib', ':LargeImageLib',
+        ':SwipeBackLib'
 project(':BannerWidget').projectDir = new File('Widget/BannerWidget')
 project(':PhotoWidget').projectDir = new File('Widget/PhotoWidget')
 project(':CustomWidget').projectDir = new File('Widget/CustomWidget')
@@ -40,6 +41,7 @@ project(':FragmentLib').projectDir = new File('Widget/FragmentLib')
 project(':WidgetViewLib').projectDir = new File('Widget/WidgetViewLib')
 project(':ZoomImageLib').projectDir = new File('Widget/ZoomImageLib')
 project(':LargeImageLib').projectDir = new File('Widget/LargeImageLib')
+project(':SwipeBackLib').projectDir = new File('Widget/SwipeBackLib')
 
 /* +++++++++ 框架基础工具库 +++++++++ */
 include ':ZxingServerLib', ':WebSocketLib',  ':SocketIoLib', ':SerialTaskLib' ,