Как выйти из приложения Android программно

Я нашел некоторые коды для выхода из приложения Android программно. Вызов любого из следующего кода в onDestroy () полностью закроет приложение?

1. System.runFinalizersOnExit(true)
   (ИЛИ)
2. android.os.Process.killProcess(android.os.Process.myPid());

Я не хочу запускать приложение в фоновом режиме после нажатия кнопки «Выйти». Просьба предложить мне использовать любой из этих кодов для выхода из приложения? Если да, то какой код я могу использовать? Это хороший способ выйти из приложения в Android?

Начиная с API 16, вы можете использовать метод finishAffinity, который, кажется, довольно близок к закрытию всех связанных действий по его имени и описанию Javadoc:

this.finishAffinity();

Завершите это действие, а также все действия непосредственно под ним в текущей задаче, которые имеют ту же привязку. Это обычно используется, когда приложение может быть запущено для другой задачи (например, из ACTION_VIEW типа контента, который он понимает), и пользователь использовал навигацию вверх для переключения из текущей задачи в свою собственную. В этом случае, если пользователь перешел к другим действиям второго приложения, все они должны быть удалены из исходной задачи как часть переключения задачи.

Обратите внимание, что это завершение не позволяет вам доставлять результаты к предыдущему действию, и будет выдано исключение, если вы попытаетесь это сделать.

Начиная с API 21 вы можете использовать очень похожую команду

finishAndRemoveTask();

Завершает все действия в этой задаче и удаляет ее из списка недавних задач.

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

это лучший способ выйти из приложения. !!!

Лучшее решение для меня.

finishAffinity();

System.exit(0);

Если вы будете использовать только finishAffinity();без System.exit(0);приложения, оно будет закрыто, но выделенная память будет по-прежнему использоваться вашим телефоном, поэтому ... если вы хотите, чтобы приложение было чистым и действительно вышло, используйте их оба.

Это самый простой метод, который работает где угодно, выйдите из приложения по-настоящему, у вас может быть много открытых действий, и все будет без проблем.

пример по нажатию кнопки

public void exitAppCLICK (View view) {

    finishAffinity();
    System.exit(0);

}

или если вы хотите что-то приятное, например, с диалоговым окном предупреждения с 3 кнопками ДА НЕТ и ОТМЕНА

// 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();

Пожалуйста, подумайте над тем, нужно ли вам убить приложение: почему бы не позволить ОС выяснить, где и когда освободить ресурсы?

В противном случае, если вы абсолютно уверены, используйте

finish();

Как реакция на комментарий @dave Appleton: во-первых, прочитайте большой комбо-вопрос @gabriel, опубликованный: « Не одобряется ли выход из приложения?

Теперь, предполагая, что у нас это есть, вопрос здесь по-прежнему имеет ответ: код, который вам нужен, если вы что-то делаете с выходом - это finish(). Очевидно, что вы можете иметь более одного вида деятельности и т. Д., Но это не главное. Позволяет управлять некоторыми из вариантов использования

1. Вы хотите, чтобы пользователь прекратил все из-за использования памяти и «не работал в фоновом режиме?» Сомнительно. Позвольте пользователю остановить определенные действия в фоновом режиме, но позвольте ОС уничтожить все ненужные ресурсы.
2. Вы хотите, чтобы пользователь не переходил к предыдущей активности вашего приложения? Ну, или настройте его так, чтобы он не работал, или вам нужна дополнительная опция. Если большую часть времени работает задняя часть = предыдущая активность, не будет ли пользователь просто нажать домой, если он / она хочет сделать что-то еще?
3. Если вам нужен какой-то сброс, вы можете выяснить, было ли / как / и т.д. ваше приложение завершено, и если ваша активность снова сфокусировалась, вы можете принять меры, показав новый экран вместо того, чтобы перезапустить, где вы были.

Так что, в конце концов, конечно, finish()не убивает все, но это все еще инструмент, который вам нужен, я думаю. Если есть вариант «убить все действия», я его еще не нашел.

Я думаю, что приложение должно быть убито в некоторых случаях. Например, есть приложение, которое можно использовать только после входа в систему. У входа в систему есть две кнопки: «Войти» и «Отмена». Когда вы нажимаете кнопку «Отмена», это определенно означает «Завершить приложение». Никто не хочет приложение живым в фоновом режиме. Поэтому я согласен, что в некоторых случаях необходимо закрыть приложение.

Создайте ExitActivityи объявите это в декларации. И позвоните ExitActivity.exit(context)для выхода из приложения.

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);
    }

}

В Android нет выхода из приложения , SampleActivity.this.finish (); завершит текущую деятельность.

При переходе от одного занятия к другому продолжайте заканчивать предыдущее

Intent homeintent = new Intent(SampleActivity.this,SecondActivity.class);
startActivity(homeintent);
SampleActivity.this.finish();

Прежде всего, этот подход требует минимального Api 16.

Я разделю это решение на 3 части, чтобы решить эту проблему более широко.

1. Если вы хотите выйти из приложения в Activity, используйте этот фрагмент кода:

if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
    finishAffinity();
} else if(Build.VERSION.SDK_INT>=21){
    finishAndRemoveTask();
}

2. Если вы хотите , чтобы выйти из приложения в , не активность класса , который имеет доступ к деятельности , то используйте этот код:

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

3. Если вы хотите выйти из приложения в классе, отличном от Activity, и не можете получить доступ к Activity, например Service, я рекомендую вам использовать BroadcastReceiver. Вы можете добавить этот подход ко всем своим действиям в вашем проекте.

Создайте переменные экземпляра LocalBroadcastManager и BroadcastReceiver. Вы можете заменить getPackageName () + ". Closeapp", если хотите.

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();
            }
        }
    }
};

Добавьте это к методу onCreate () Activity.

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

Также не забудьте вызвать незарегистрированный получатель в методе Activity из onDestroy ().

mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);

Для выхода из приложения вы должны отправить широковещательную рассылку, используя LocalBroadcastManager, который я использую в своем классе PlayService, который расширяет Service.

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

Вы можете использовать finishAndRemoveTask ()из API 21

public void finishAndRemoveTask ()

Завершает все действия в этой задаче и удаляет ее из списка недавних задач.

Это зависит от того, как быстро вы хотите закрыть приложение.

Безопасный способ закрыть ваше приложение - finishAffinity ();

После закрытия всех процессов приложение закрывается. Это может занять некоторое время. Если вы закроете свое приложение таким образом и через короткое время перезапустите его, возможно, ваше новое приложение будет запущено в том же процессе. Со всеми незавершенными процессами и одиночными объектами старого приложения.

Если вы хотите быть уверены, что ваше приложение полностью закрыто, используйте System.exit (0);

Это немедленно закроет ваше приложение. Но возможно, что вы повредите файлы, которые открыты в вашем приложении, или редактирование общих настроек не завершится. Так что используйте это осторожно.

Если вы используете сторожевой таймер в сочетании с долгосрочным заданием, вы можете увидеть влияние различных методов.

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) , запустите этот код и перезапустите приложение после его закрытия, вы увидите странное поведение, потому что бесконечный цикл все еще работает.

Вам лучше использовать, finish()если вы находитесь в Activity, или getActivity().finish()если вы в Fragment.

Если вы хотите полностью выйти из приложения, используйте:

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

Простой и простой способ выйти из приложения

Intent homeIntent = new Intent(Intent.ACTION_MAIN);
homeIntent.addCategory(Intent.CATEGORY_HOME);
homeIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(homeIntent);

Мы хотим, чтобы код был надежным и простым. Это решение работает на старых устройствах и более новых устройствах.

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
        getActivity().finishAffinity();
    } else{
        getActivity().finish();
        System.exit( 0 );
    }

Я думаю, что вы ищете это

activity.moveTaskToBack(Boolean nonRoot);

public void quit() {
        int pid = android.os.Process.myPid();
        android.os.Process.killProcess(pid);
        System.exit(0);
    }

Аналогично @MobileMateo, но в Котлине

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
    this.finishAffinity()
} else{
    this.finish()
    System.exit(0)
}

Я не уверен, если это осуждается или нет, но это то, как я это делаю ...

Шаг 1 - У меня обычно есть класс, который содержит методы и переменные, к которым я хочу получить глобальный доступ. В этом примере я назову это классом «App». Создайте статическую переменную Activity внутри класса для каждого действия, которое есть в вашем приложении. Затем создайте статический метод с именем «close», который будет запускать finish()метод для каждой из этих переменных Activity, если они НЕ равны NULL . Если у вас есть основное / родительское действие, закройте его последним:

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(), установите статическую переменную в вашем классе приложения равной " this". В onDestroy(), установите его равным null. Например, в классе «Activity1»:

@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 может взять на себя эту задачу и выполнить любую необходимую очистку.

Опять же, я не знаю, будет ли это осуждено по любой причине. Если это так, я хотел бы прочитать комментарии о том, почему это так и как это можно улучшить!

Не одобряется ли выход из приложения? , Пройдите по этой ссылке. Это отвечает на ваш вопрос. Система выполняет работу по уничтожению приложения.

Предположим, у вас есть два действия A a B. Вы переходите от A к B. Когда вы нажимаете кнопку «Назад», ваше действие B извлекается из backstack и уничтожается. Предыдущее действие в заднем стеке A фокусируется.

Вы должны оставить это для системы, чтобы решить, когда убивать приложение.

общественная пустота finish()

Позвоните, когда ваша деятельность завершена и должна быть закрыта.

Предположим, у вас много занятий. Вы можете использовать панель действий. При нажатии на иконку дома перейдите к MainActivity вашего приложения. В MainActivity нажмите кнопку «Назад», чтобы выйти из приложения.

Для выхода из приложения вы можете использовать следующее:

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

Также для остановки сервисов тоже вызовите следующий метод:

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
            }
        }
    }
}

Это может быть очень поздно, а также в соответствии с инструкциями, которые вы не должны обрабатывать процесс жизненного цикла самостоятельно (как ОС делает это для вас). Предполагается, что вы зарегистрируете радиовещательного приемника во всех своих действиях с помощью " finish()" в их onReceive() &, если вы хотите выйти, вы можете просто передать намерение, указывающее, что все действия должны быть закрыты ..... Хотя убедитесь, что вы это делаете " Отмените регистрацию получателя в ваших onDestroy()методах.

Это не хорошее решение, потому что оно противоречит принципам обработки приложений Android. Android не убивает никакой процесс, если он не является абсолютно неизбежным. Это помогает приложениям запускаться быстрее, потому что они всегда хранятся в памяти. Поэтому вам нужна особая причина, чтобы убить процесс вашего приложения.

Правильное и точное решение для выхода из приложения по нажатию кнопки - использовать следующий код:

// На кнопке Back нажал событие

public void onBackPressed()
{ 
   moveTaskToBack(true);
   finish();
}

Если вы используете Kotlin, правильный способ выхода из приложения и альтернатива System.exit()- встроенный метод

exitProcess(0)

Смотрите документацию .

Число 0в качестве параметра означает, что выход предназначен и ошибки не произошло.

Это убьет все что угодно;)

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

Попробуй это

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

Я нашел самый простой способ выйти из приложения из действия, не нарушая логику Android и не добавляя больше кода в существующие действия и передавая дополнения, это следующее:

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существо:

public class QuitApplicationActivity extends AppCompatActivity {

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

        finish ();
    }
}

Ответ @Sivi закрывает приложение. Но по возвращении, если у вас есть какие-то дочерние действия, может быть открыто другое незаконченное действие. Я добавил noHistory:trueв свою деятельность, чтобы приложение по возвращении начиналось с MainActivity.

<activity 
      android:name=".MainActivity"
      android:noHistory="true">
</activity>

Просто чтобы добавить один в список жестоких методов завершения приложения:

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

Вы можете выйти из своих полных приложений. таким образом

Intent intent = getBaseContext().getPackageManager()
             .getLaunchIntentForPackage(getBaseContext().getPackageName());
intent .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

это будет работать на 100%. Удачи!

Просто используйте финиш () на клавишу возврата, нажмите на клавишу ()