如何以编程方式退出android应用程序


How to quit android application programmatically

我找到了一些以编程方式退出Android应用程序的代码。 通过在onDestroy()中调用以下任何一个代码，它会完全退出应用程序吗？

  • System.runFinalizersOnExit(true)
    (要么)
  • android.os.Process.killProcess(android.os.Process.myPid());

    • 我不想在单击退出按钮后在后台运行我的应用程序。
    请问我可以使用这些代码中的任何一个来退出我的应用程序吗？ 如果可以，我可以使用哪些代码？ 这是退出Android应用程序的好方法吗？

    相关讨论

    从API 16开始，您可以使用finishAffinity方法，该方法似乎非常接近通过其名称和Javadoc描述关闭所有相关活动：

    this.finishAffinity();

    Finish this activity as well as all activities immediately below it in the current task that have the same affinity. This is typically used when an application can be launched on to another task (such as from an ACTION_VIEW of a content type it understands) and the user has used the up navigation to switch out of the current task and into its own task. In this case, if the user has navigated down into any other activities of the second application, all of those should be removed from the original task as part of the task switch.

    Note that this finish does not allow you to deliver results to the previous activity, and an exception will be thrown if you are trying to do so.

    从API 21开始，您可以使用非常相似的命令

    finishAndRemoveTask();

    Finishes all activities in this task and removes it from the recent tasks list.

    相关讨论

    1
    2
    getActivity().finish();
    System.exit(0);

    这是退出应用程序的最佳方式。!!!

    对我来说最好的解决方案。

    相关讨论

    finishAffinity();

    System.exit(0);

    如果您只使用finishAffinity();而不使用System.exit(0);，您的应用程序将退出，但分配的内存仍将由您的手机使用，因此......如果您想要干净且真正退出应用程序，请同时使用它们。

    这是最简单的方法，可以在任何地方使用，退出应用程序真实，你可以打开很多活动仍然可以放弃所有没有问题。

    单击按钮时的示例

    1
    2
    3
    4
    5
    6
    public void exitAppCLICK (View view) {

        finishAffinity();
        System.exit(0);

    }

    或者如果你想要一些不错的东西，例如带有3个按钮的警告对话框是NO和CANCEL

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    // alertdialog for exit the app
    AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);

    // set the title of the Alert Dialog
    alertDialogBuilder.setTitle("your title");

    // set dialog message
    alertDialogBuilder
            .setMessage("your message")
            .setCancelable(false)
            .setPositiveButton("YES"),
                    new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog,
                                            int id) {
                            // what to do if YES is tapped
                            finishAffinity();
                            System.exit(0);
                        }
                    })

            .setNeutralButton("CANCEL"),
                    new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog,
                                            int id) {
                            // code to do on CANCEL tapped
                            dialog.cancel();
                        }
                    })

            .setNegativeButton("NO"),
                    new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog,
                                            int id) {
                            // code to do on NO tapped
                            dialog.cancel();
                        }
                    });

    AlertDialog alertDialog = alertDialogBuilder.create();

    alertDialog.show();
    相关讨论

    如果你确实需要杀死应用程序，请认真考虑：为什么不让OS找出何时何地释放资源？

    否则，如果你真的很确定，请使用

    1
    finish();

    作为对@dave appleton评论的反应：第一件事是读了大问题/答案组合@gabriel发布：退出一个应用程序不赞成？

    现在假设我们已经有了这个问题，这里的问题仍然有一个答案，就是如果你正在做任何退出的事情你需要的代码是finish()。显然你可以有不止一个活动等等，但这不是重点。让我们运行一些用例

  • 你想让用户因内存使用和"不在后台运行"而退出所有内容吗？Doubtfull。让用户在后台停止某些活动，但让操作系统杀死任何不需要的资源。
  • 您希望用户不要转到您应用的上一个活动吗？好吧，要么配置它没有，要么你需要一个额外的选项。如果back = previous-activity的大部分时间都有效，那么如果他/她想要做其他事情，用户是否只会按回家？
  • 如果您需要某种重置，您可以查看您的应用程序是否/如何/等退出，如果您的活动再次获得焦点，您可以对此采取措施，显示一个新屏幕，而不是重新启动您所在的位置。

    • 所以最后，当然，finish()并没有杀死它，但它仍然是你需要的工具。如果有"杀死所有活动"的用例，我还没有找到它。

    相关讨论

    我认为在某些情况下应用程序应该是kill。例如，有一个应用程序只能在登录后使用。登录活动有两个按钮，"登录"和"取消"。当您单击"取消"按钮时，它肯定意味着"终止应用程序"。没有人希望应用程序在后台运行。所以我同意某些情况需要关闭应用程序。

    相关讨论

    android中没有应用程序退出，
    SampleActivity.this.finish();将完成当前的活动。

    当您从一个活动切换到另一个活动时，请完成前一个活动

    1
    2
    3
    Intent homeintent = new Intent(SampleActivity.this,SecondActivity.class);
    startActivity(homeintent);
    SampleActivity.this.finish();
    相关讨论

    创建一个ExitActivity并在清单中声明它。并调用ExitActivity.exit(context)退出应用程序。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    public class ExitActivity extends AppCompatActivity {

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

        public static void exit(Context context) {
            Intent intent = new Intent(context, ExitActivity.class);
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
            context.startActivity(intent);
        }

    }
    相关讨论

    这取决于您想要关闭应用的速度。

    关闭应用程序的一种安全方法是finishAffinity();

    在所有流程完成处理后，它会关闭您的app。
    这可能需要一些时间。
    如果以这种方式关闭应用程序，并在短时间后重新启动它，则新应用程序可能在同一进程中运行。使用旧应用程序的所有未完成的进程和单例对象。

    如果你想确定，你的应用程序是完全关闭使用System.exit(0);

    这将立即关闭您的应用程序。
    但是，您可能会损坏应用程序已打开的文件或共享首选项上的编辑未完成。所以要小心使用。

    如果将watchdog与长时间运行的任务结合使用，则可以看到不同方法的影响。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    new ANRWatchDog(2000).setANRListener(new ANRWatchDog.ANRListener() {
        public void onAppNotResponding(ANRError error) {
            MainActivity.this.finishAffinity();
            System.exit(0);
        }
    }).start();
    for(int i = 0; i < 10; ++i){
        --i;
    }

    这会在2秒后杀死您的应用，而不会显示ANR对话框或类似内容。如果删除System.exit(0)，运行此代码并在关闭后重新启动应用程序，您将遇到一些奇怪的行为，因为无限循环仍在运行。

    您可以使用API?? 21中的finishAndRemoveTask ()

    public void finishAndRemoveTask ()

    Finishes all activities in this task and removes it from the recent tasks list.

    如果你在Activity，最好使用finish()，如果你在Fragment，最好使用getActivity().finish()。

    如果您想完全退出应用程序，请使用：

    1
    2
    getActivity().finish();
    System.exit(0);

    首先，这种方法需要最小Api 16。

    我将此解决方案分为3个部分，以更广泛地解决这个问题。

    1.如果要在活动中退出应用程序，请使用以下代码段：

    1
    2
    3
    4
    5
    if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
                finishAffinity();
            } else if(Build.VERSION.SDK_INT>=21){
                finishAndRemoveTask();
            }

    2.如果要退出具有Activity访问权限的非Activity类中的应用程序，请使用以下代码段：

    1
    2
    3
    4
    5
        if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
                    getActivity().finishAffinity();
                } else if(Build.VERSION.SDK_INT>=21){
                    getActivity().finishAndRemoveTask();
                }

    3.如果要退出非Activity类中的应用程序而无法访问Service等活动，我建议您使用BroadcastReceiver。您可以将此方法添加到项目中的所有活动中。

    创建LocalBroadcastManager和BroadcastReceiver实例变量。如果需要，可以替换getPackageName()+"。closeapp"。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    LocalBroadcastManager mLocalBroadcastManager;
    BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if(intent.getAction().equals(getPackageName()+".closeapp")){
                if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
                    finishAffinity();
                } else if(Build.VERSION.SDK_INT>=21){
                    finishAndRemoveTask();
                }
            }
        }
    };

    将这些添加到Activity的onCreate()方法中。

    1
    2
    3
    4
        mLocalBroadcastManager = LocalBroadcastManager.getInstance(this);
        IntentFilter mIntentFilter = new IntentFilter();
        mIntentFilter.addAction(getPackageName()+".closeapp");
        mLocalBroadcastManager.registerReceiver(mBroadcastReceiver, mIntentFilter);

    另外，不要忘记在Activity的onDestroy()方法中调用unregister接收器

    1
        mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);

    对于退出应用程序，您必须使用我在PlayService类中使用的LocalBroadcastManager发送广播，该类扩展了Service。

    1
    2
    3
    4
      LocalBroadcastManager localBroadcastManager = LocalBroadcastManager
                                    .getInstance(PlayService.this);
                            localBroadcastManager.sendBroadcast(new Intent(
                                    getPackageName() +".closeapp"));

    从应用程序退出的简单方法

    1
    2
    3
    4
    Intent homeIntent = new Intent(Intent.ACTION_MAIN);
    homeIntent.addCategory(Intent.CATEGORY_HOME);
    homeIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    startActivity(homeIntent);
    相关讨论

    1
    2
    3
    4
    5
    public void quit() {
            int pid = android.os.Process.myPid();
            android.os.Process.killProcess(pid);
            System.exit(0);
        }
    相关讨论

    我不确定这是不是不赞成，但这就是我这样做的方式......

    第1步 - 我通常有一个包含我想要全局访问的方法和变量的类。在这个例子中，我将其称为"App"类。在应用程序具有的每个活动的类中创建一个静态Activity变量。然后创建一个名为"close"的静态方法，如果它们不为null，将在每个Activity变量上运行finish()方法。如果您有主/父活动，请将其关闭：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    public class App
    {
        ////////////////////////////////////////////////////////////////
        // INSTANTIATED ACTIVITY VARIABLES
        ////////////////////////////////////////////////////////////////

            public static Activity activity1;
            public static Activity activity2;
            public static Activity activity3;

        ////////////////////////////////////////////////////////////////
        // CLOSE APP METHOD
        ////////////////////////////////////////////////////////////////

            public static void close()
            {
                if (App.activity3 != null) {App.activity3.finish();}
                if (App.activity2 != null) {App.activity2.finish();}
                if (App.activity1 != null) {App.activity1.finish();}
            }
    }

    第2步 - 在每个活动中，覆盖onStart()和onDestroy()方法。在onStart()中，将App类中的静态变量设置为"this"。在onDestroy()中，将其设置为null。例如，在"Activity1"类中：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    @Override
    public void onStart()
    {
        // RUN SUPER | REGISTER ACTIVITY AS INSTANTIATED IN APP CLASS

            super.onStart();
            App.activity1 = this;
    }

    @Override
    public void onDestroy()
    {
        // RUN SUPER | REGISTER ACTIVITY AS NULL IN APP CLASS

            super.onDestroy();
            App.activity1 = null;
    }

    第3步 - 当您想关闭应用时，只需从任何地方拨打App.close()即可。所有实例化的活动都将关闭！由于您只是关闭活动而不是杀死应用程序本身(如您的示例中所示)，因此Android可以从那里接管并进行任何必要的清理。

    同样，我不知道这是否会因任何原因而不受欢迎。如果是这样，我很乐意阅读有关它为什么以及如何改进的评论！

    相关讨论

    我认为你在寻找的是这个

    1
    activity.moveTaskToBack(Boolean nonRoot);

    退出申请是不是很害怕？浏览此链接。它回答了你的问题。系统完成了杀死应用程序的工作。

    假设您有两个活动A和B.您从A导航到B.当您单击后退按钮时，您的活动B将从后台堆叠中弹出并销毁。后堆栈活动A中的先前活动需要关注。

    您应该将其留给系统来决定何时终止该应用程序。

    public void finish()

    在您的活动完成后调用此选项并应关闭。

    假设你有很多活动。你可以使用动作栏。点击主页图标naviagate到你的应用程序的MainActivity。在MainActivity中单击后退按钮以退出应用程序。

    要退出应用程序，您可以使用以下内容：

    1
    2
    3
    getActivity().finish();
    Process.killProcess(Process.myPid());
    System.exit(1);

    同样要停止服务也请调用以下方法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    private void stopServices() {        
        final ActivityManager activityManager = SystemServices.getActivityManager(context);
        final List<ActivityManager.RunningServiceInfo> runningServices = activityManager.getRunningServices(Integer.MAX_VALUE);
        final int pid = Process.myPid();
        for (ActivityManager.RunningServiceInfo serviceInfo : runningServices) {
            if (serviceInfo.pid == pid && !SenderService.class.getName().equals(serviceInfo.service.getClassName())) {
                try {
                    final Intent intent = new Intent();
                    intent.setComponent(serviceInfo.service);
                    context.stopService(intent);
                } catch (SecurityException e) {
                     // handle exception
                }
            }
        }
    }

    我们希望代码强大而简单。
    此解决方案适用于旧设备和较新设备。

    1
    2
    3
    4
    5
    6
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
            getActivity().finishAffinity();
        } else{
            getActivity().finish();
            System.exit( 0 );
        }

    这可能是非常晚的，并且根据指导原则，您不应该自己处理生命周期过程(因为操作系统会为您执行此操作)。建议您在所有活动中使用"finish()"在onReceive()＆amp;中注册广播接收器。无论何时你想戒掉，你都可以简单地传递一个表明所有活动必须关闭的意图.....
    虽然请确保在onDestroy()方法中"取消注册"接收器。

    这不是一个好的决定，因为它违反了Android的应用程序处理原则。 Android不会杀死任何进程，除非它绝对是不可避免的。这可以帮助应用程序更快地启动，因为它们始终保存在内存中。因此，您需要一个非常特殊的理由来终止您的应用程序。

    相关讨论

    与@MobileMateo类似，但在Kotlin中

    1
    2
    3
    4
    5
    6
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
        this.finishAffinity()
    } else{
        this.finish()
        System.exit(0)
    }

    按钮点击退出应用程序的正确和准确的解决方案是使用以下代码：

    // On按钮返回按下事件

    1
    2
    3
    4
    5
    public void onBackPressed()
    {
       moveTaskToBack(true);
       finish();
    }
    相关讨论

    如果您正在使用Kotlin，退出应用程序和System.exit()的替代方法的正确方法是内置方法

    1
    exitProcess(0)

    请参阅文档。

    作为参数的数字0表示出口是预期的并且没有发生错误。

    @Sivi的回答关闭了应用程序。但回来后，如果你有一些儿童活动，可能会打开另一个未完成的活动。我在活动中添加了noHistory:true，因此返回的应用程序从MainActivity开始。

    1
    2
    3
    4
    <activity
          android:name=".MainActivity"
          android:noHistory="true">
    </activity>

    这会杀死任何东西;)

    1
    2
    int p = android.os.Process.myPid();
    android.os.Process.killProcess(p);

    试试这个

    1
    2
    int pid = android.os.Process.myPid();
    android.os.Process.killProcess(pid);

    我发现从活动中退出应用程序的最简单方法，不破坏Android的逻辑，并且不在现有活动中添加更多代码并传递额外内容，如下所示：

    1
    2
    3
    4
    5
    6
    7
    public static void quitApplication (Activity currentActivity) {
        Intent intent = new Intent (currentActivity, QuitApplicationActivity.class);
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);

        currentActivity.startActivity (intent);
        currentActivity.finish ();
    }

    QuitApplicationActivity是：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class QuitApplicationActivity extends AppCompatActivity {

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

            finish ();
        }
    }

    只是在终止应用程序的残酷方法列表中添加一个：

    Process.sendSignal(Process.myPid(), Process.SIGNAL_KILL);

    相关讨论

    你可以退出完整的应用程序。从而

    1
    2
    3
    4
    Intent intent = getBaseContext().getPackageManager()
                 .getLaunchIntentForPackage(getBaseContext().getPackageName());
    intent .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    startActivity(intent);

    它将100％工作。祝你好运！

    相关讨论

    在您的onbackpressed覆盖方法中编写此代码

    1
    2
    3
    4
    5
    6
    7
    @Override
    public void onBackPressed() {
        Intent intent = new Intent(Intent.ACTION_MAIN);
        intent.addCategory(Intent.CATEGORY_HOME);
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        startActivity(intent);
    }

    只需在后退键上使用finish()按onKeypressed()

    相关讨论