前言

在 Android开发中，会经常存在 “一键退出App” 的需求
但市面上流传着 太多不可用的“一键退出App”功能实现
本文将全面总结“一键退出App”的实现方式，并为你一一实践，希望你们会喜欢。

1. 需求本质

一键退出 App 其实是两个需求：

一键结束当前App所有的Activity
一键结束当前App进程

即需要2个步骤才可完成一键退出 App 需求。下面，我将根据这两个步骤进行功能实现讲解。

2. 功能实现

2.1 （步骤1）一键结束当前 App 所有 Activity

2.1.1 实现方法类型

主要分为2类：通过 Android组件 & 自身实现
具体如下图：

注：上述方法仅仅只是结束当前App所有的Activity （在用户的角度确实是退出了 App），但实际上该App的进程还未结束。

2.1.2 具体介绍

a. 通过 Android 组件：Activity

方法1：采用Activity启动模式：SingleTask

原理
1. 将 App的入口 Activity 采用 SingleTask 启动模式
a. 入口 Activity 此时处于栈底 b. 关于 SingleTask的原理如下：
1. 当需要退出 App时启动入口 Activity
此时入口 Activity 上层的Activity实例都将自动关闭移除 & 自身被放置在栈顶（这是SingleTask启动模式的特点）
1. 通过在入口 Activity 回调的onNewIntent()中关闭自身即可
若在后面的Activity启动任务栈底的Activity时，就会调用任务栈底Activity的onNewIntent()
具体实现

步骤1：将 App的入口 Activity 设置成 SingleTask 启动模式

// AndroidMainifest.xml中的Activity配置进行设置

<activity

android:launchMode="singleTask"
//属性
//standard：标准模式
//singleTop：栈顶复用模式
//singleTask：栈内复用模式
//singleInstance：单例模式
//如不设置，Activity的启动模式默认为 标准模式（standard）
</activity>

步骤2：在入口 Activity重写 onNewIntent()

// 在该方法传入一标志位标识是否要退出App & 关闭自身
  @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        if (intent != null) {
            // 是否退出App的标识
            boolean isExitApp = intent.getBooleanExtra("exit", false);
            if (isExitApp) {
                // 关闭自身
                this.finish();
            }
        }
    }

步骤3：在需要退出时调用 exitApp()

private void exitApp() {
        Intent intent = new Intent(context, MainActivity.class);
        intent.putExtra("exit", true);
        context.startActivity(intent);

         // 结束进程
        // System.exit(0);
    }

优点使用简单 & 方便
缺点
1. 规定 App的入口Activity采用SingleTask启动模式
2. 使用范围局限：只能结束当前任务栈的Activity，若出现多任务栈（即采用SingleInstance启动模式）则无法处理
应用场景 Activity单任务栈

方法2：采用Activity启动标记位

原理：对入口Activity采用 2 标记位：
1. Intent.FLAG_ACTIVITY_CLEAR_TOP：销毁目标Activity和它之上的所有Activity，重新创建目标Activity
2. Intent.FLAG_ACTIVITY_SINGLE_TOP：若启动的Activity位于任务栈栈顶，那么此Activity的实例就不会重建，而是重用栈顶的实例( 调用onNewIntent()）
具体使用（从MainActivity（入口Activity）跳转到 Activity2 & 一键退出）

步骤1：在MainActivity 中设置重写 onNewIntent() MainActivity.java

        // 设置 按钮 跳转到Activity2
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                startActivity(new Intent(MainActivity.this, Activity2.class));

            }

        });
    }

    // 在onNewIntent（）传入一标识符
    // 作用：标识是否要退出App
    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        if (intent != null) {
            // 是否退出App的标识
            boolean isExitApp = intent.getBooleanExtra("exit", false);
            if (isExitApp) {
                // 关闭自身
                this.finish();
            }
        }
        // 结束进程
        // System.exit(0);
    }
}

步骤2：在需要退出的地方（Activity2）启动MainActivity & 设置标记位

// 当需要退出时，启动入口Activity
                Intent intent = new Intent();
                intent.setClass(Activity2.this, MainActivity.class);

                // 设置标记位
                intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                // 步骤1：该标记位作用：销毁目标Activity和它之上的所有Activity，重新创建目标Activity

                intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
                // 步骤2：若启动的Activity位于任务栈栈顶，那么此Activity的实例就不会重建，而是重用栈顶的实例( 调用实例的 onNewIntent() )

                // 在步骤1中：MainActivity的上层的Activity2会被销毁，此时MainActivity位于栈顶；由于步骤2的设置，所以不会新建MainActivity而是重用栈顶的实例&调用实onNewIntent()

                // 传入自己设置的退出App标识
                intent.putExtra("exit", true);

                startActivity(intent);

优点使用简单 & 方便
缺点使用范围局限：只能结束当前任务栈的Activity，若出现多任务栈（即采用SingleInstance启动模式）则无法处理
应用场景 Activity单任务栈

方法3：通过系统任务栈

原理：通过 ActivityManager 获取当前系统的任务栈 & 把栈内所有Activity逐个退出
具体使用

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
        
        // 1. 通过Context获取ActivityManager
        ActivityManager activityManager = (ActivityManager) context.getApplicationContext().getSystemService(Context.ACTIVITY_SERVICE);

        // 2. 通过ActivityManager获取任务栈
        List<ActivityManager.AppTask> appTaskList = activityManager.getAppTasks();
        
        // 3. 逐个关闭Activity
        for (ActivityManager.AppTask appTask : appTaskList) {
            appTask.finishAndRemoveTask();
        }
        // 4. 结束进程
        // System.exit(0);

优点使用简单、方便
缺点
1. 使用范围局限：只能结束当前任务栈的Activity，若出现多任务栈（即采用SingleInstance启动模式）则无法处理
2. 对 Android 版本要求较高：Android 5.0以上
应用场景 Android 5.0以上的 Activity单任务栈

b. 通过 Android 组件： BroadcastReceiver

即使用 BroadcastReceiver 广播监听

原理：在每个 Activity 里注册广播接收器（响应动作 = 关闭自身）；当需要退出 App 时发送广播请求即可
具体实现

步骤1：自定义广播接收器

public class ExitAppReceiver extends BroadcastReceiver {
    private Activity activity;

    public ExitAppReceiver(Activity activity){
        this.activity = activity;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        activity.finish();
    }
}

步骤2：在每个 Activity 里注册广播接收器（响应动作 = 关闭自身）

public class Activity extends AppCompatActivity {

private  ExitAppReceiver mExitAppReceiver；

// 1. 在onCreate（）中注册广播接收器
 protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mExitAppReceiver = new ExitAppReceiver(this);
        registerReceiver(mExitAppReceiver,new IntentFilter(BaseApplication.EXIT));
    }

// 1. 在onDestroy（）中注销广播接收器
    protected void onDestroy() {
        super.onDestroy();
        unregisterReceiver(mExitAppReceive);
    }

步骤3：当需要退出App时发送广播请求

context.sendBroadcast(new Intent(BaseApplication.EXIT));
// 注：此处不能使用：System.exit(0);结束进程
// 原因：发送广播这个方法之后，不会等到广播接收器收到广播，程序就开始执行下一句System.exit(0)，然后就直接变成执行System.exit(0)的效果了。

优点应用场景广泛：兼顾单 / 多任务栈 & 多启动模式的情况
缺点实现复杂：需要在每个 Activity 里注册广播接收器
应用场景任意情况下的一键退出 App，但无法终止 App 进程

所以该方法仅仅是在用户的角度来说 “一键退出App”

c. 自身实现

方法1：创建链表

原理：通过在Application子类中建立一个 Activity链表：保存正在运行的Activity实例；当需要一键退出App时把链表内所有Activity实例逐个退出即可
具体使用

步骤1：在BaseApplication类的子类里建立Activity链表

Carson_BaseApplicaiton.java

public class Carson_BaseApplicaiton extends Application {

    // 此处采用 LinkedList作为容器，增删速度快
    public static LinkedList<Activity> activityLinkedList;


    @Override
    public void onCreate() {
        super.onCreate();

        activityLinkedList = new LinkedList<>();

        registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                Log.d(TAG, "onActivityCreated: " + activity.getLocalClassName());
                activityLinkedList.add(activity);
                // 在Activity启动时（onCreate()） 写入Activity实例到容器内
            }

            @Override
            public void onActivityDestroyed(Activity activity) {
                Log.d(TAG, "onActivityDestroyed: " + activity.getLocalClassName());
                activityLinkedList.remove(activity);
                // 在Activity结束时（Destroyed（）） 写出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) {

            }


        });
    }
    
    public  void exitApp() {

        Log.d(TAG, "容器内的Activity列表如下 ");
        // 先打印当前容器内的Activity列表
        for (Activity activity : activityLinkedList) {
            Log.d(TAG, activity.getLocalClassName());
        }

        Log.d(TAG, "正逐步退出容器内所有Activity");

        // 逐个退出Activity
        for (Activity activity : activityLinkedList) {
            activity.finish();
        }
      
        //  结束进程
        // System.exit(0);
    }
}

// 记得在Manifest.xml中添加
<application
        android:name=".Carson_BaseApplicaiton"
        ....
</application>

步骤2：需要一键退出 App 时，获取该 Applicaiton类对象 & 调用exitApp()

                private Carson_BaseApplicaiton app;

                app = (Carson_BaseApplicaiton)getApplication();
                app.exitApp();

效果图

优点应用场景广泛：兼顾单 / 多任务栈 & 多启动模式的情况
缺点需要 Activity 经历正常的生命周期，即创建时调用onCreate（），结束时调用onDestroy（）

因为只有这样经历正常的生命周期才能将 Activity正确写入 & 写出容器内

应用场景任意情况下的一键退出 App 实现

方法2：RxBus

原理：使用 RxBus当作事件总线，在每个 Activity里注册RxBus订阅（响应动作 = 关闭自身）；当需要退出App时发送退出事件请求即可。
具体使用

步骤1：在每个 Activity里注册RxBus订阅（响应动作 = 关闭自身）

public class Activity extends AppCompatActivity {
  private Disposable disposable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity2);
        
        // 注册RxBus订阅
        disposable = RxBus.getInstance().toObservable(String.class)
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        // 响应动作 = 关闭自身
                        if (s.equals("exit")){
                            finish();
                        }
                    }
                });
    }

// 注意一定要取消订阅
 @Override
    protected void onDestroy() {
        if (!disposable.isDisposed()){
              disposable.dispose();;
        }
}

步骤2：当需要退出App时发送退出事件

        RxBus.getInstance().post("exit");
        System.exit(0);

优点可与 RxJava & RxBus 相结合
缺点实现复杂：RxBus 本身的实现难度 & 需要在每个Activity注册和取消订阅 RxBus 使用
应用场景需要与RxJava 结合使用时

若项目中没有用到RxJava & RxBus 不建议使用

至此，一键结束当前 App的所有 Activity的方法讲解完毕。
注：上述方法仅仅只是结束当前App所有的Activity （在用户的角度确实是退出了 App），但实际上该App的进程还未结束

2.2 （步骤2）一键结束当前 App 进程

主要采用 Dalvik VM本地方法

作用结束当前 Activity & 结束进程

即在（步骤1）结束当前 App 所有的 Activity 后，调用该方法即可一键退出 App（更多体现在结束进程上）

具体使用

// 方式1：android.os.Process.killProcess（）
  android.os.Process.killProcess(android.os.Process.myPid()) ；

// 方式2：System.exit()
// System.exit() = Java中结束进程的方法：关闭当前JVM虚拟机
  System.exit(0);  

// System.exit(0)和System.exit(1)的区别
  // 1. System.exit(0)：正常退出；
  // 2. System.exit(1)：非正常退出，通常这种退出方式应该放在catch块中。

特别注意假设场景：当前 Activity ≠ 当前任务栈最后1个Activity时，调用上述两个方法会出现什么情况呢？（即Activity1 - Activity2 -Activity3（在Activity3调用上述两个方法））

答：

结束Activity3（当前 Activity ）& 结束进程
再次重新开启进程 & 启动 Activity1 、 Activity2

即在Android 中，调用上述Dalvik VM本地方法结果是：

结束当前 Activity & 结束进程
之后再重新开启进程 & 启动之前除当前 Activity 外的已启动的 Activity

原因：** Android中的ActivityManager时刻监听着进程**。一旦发现进程被非正常结束，它将会试图去重启这个进程。
应用场景当任务栈只剩下当前Activity（即退出了其余 Activity后），调用即可退出该进程，即在（步骤1）结束当前 App 所有的 Activity 后，调用该方法即可一键退出App（更多体现在结束进程上）

注：与 “在最后一个Activity调用 finish（）”的区别：finish（）不会结束进程，而上述两个方法会

至此，关于 一键退出App 的两个步骤讲解完毕。

3. Demo地址

关于上述说的方法Demo都在Carson_Ho的Github地址：一键退出App

4. 总结

在需要实现一键退出 App 功能时，实际上是需要完成2个步骤：步骤1：一键结束当前App所有的Activity 步骤2：一键结束当前App进程
每个步骤的方法总结如下

下面我将继续对 Android中的知识进行深入讲解，有兴趣可以继续关注Carson_Ho的安卓开发笔记

Android 应用技巧：手把手教你优雅实现 “一键退出 App”

前言

目录

1. 需求本质

2. 功能实现

2.1 （步骤1）一键结束当前 App 所有 Activity

2.1.1 实现方法类型

2.1.2 具体介绍

a. 通过 Android 组件：Activity

方法2：采用Activity启动标记位

方法3：通过系统任务栈

b. 通过 Android 组件： BroadcastReceiver

c. 自身实现

方法1：创建链表

方法2：RxBus

2.2 （步骤2）一键结束当前 App 进程

3. Demo地址

4. 总结

请点赞！因为你的鼓励是我写作的最大动力！

欢迎关注carson_ho的微信公众号

Android 应用技巧： 手把手教你 优雅实现 “一键退出 App”

前言

目录

1. 需求本质

2. 功能实现

2.1 （步骤1）一键结束当前 App 所有 Activity

2.1.1 实现方法类型

2.1.2 具体介绍

a. 通过 Android 组件：Activity

方法2：采用Activity启动标记位

方法3：通过系统任务栈

b. 通过 Android 组件： BroadcastReceiver

c. 自身实现

方法1：创建 链表

方法2：RxBus

2.2 （步骤2）一键结束当前 App 进程

3. Demo地址

4. 总结

请点赞！因为你的鼓励是我写作的最大动力！

欢迎关注carson_ho的微信公众号

Android 应用技巧：手把手教你优雅实现 “一键退出 App”

方法1：创建链表