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

Ответ 1

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

this.finishAffinity();

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

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

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

finishAndRemoveTask();

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

Ответ 2

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

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

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

Ответ 3

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

Ответ 4

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

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

finish();

Как реакция на комментарий @dave appleton: Первое, что прочитал большой вопрос/ответ, комбо @gabriel отправлено: Отказался от приложения, нахмурившегося?

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

• Вы хотите, чтобы пользователь оставил все из-за использования памяти и "не работал в фоновом режиме?" Doubtfull. Позвольте пользователю остановить определенные действия в фоновом режиме, но пусть ОС уничтожит любые ненужные ресурсы.
• Вы хотите, чтобы пользователь не переходил к предыдущему действию вашего приложения? Ну, либо настройте его так, чтобы он этого не сделал, либо вам нужен дополнительный вариант. Если в большинстве случаев работает back = previous-activity, не будет ли пользователь просто нажимать домой, если он хочет сделать что-то еще?
• Если вам нужен какой-то reset, вы можете узнать, было ли /how/etc ваше приложение закрыто, и если ваша активность снова становится фокусом, вы можете принять меры по этому поводу, показывая новый экран вместо перезапуска, где вы были.

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

Ответ 5

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

Ответ 6

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

Когда вы переключаетесь с одного действия на другое, продолжайте заканчивать предыдущий

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

Ответ 7

Создайте 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);
    }

}

Ответ 8

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

public void finishAndRemoveTask()

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

Ответ 9

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

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

Ответ 10

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

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

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

Ответ 11

Прежде всего, для этого подхода требуется min Api 16.

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

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

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

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

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

3. Если вы хотите выйти из приложения в классе non 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);

Кроме того, не забудьте вызвать деблокирующий приемник по методу onDestroy()

    mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);

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

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

Ответ 12

Я не уверен, что это неодобрительно, но это так, как я это делаю...

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

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":

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

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

Ответ 13

Легкий и простой способ выхода из приложения

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

Ответ 14

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

activity.moveTaskToBack(Boolean nonRoot);

Ответ 15

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

Ответ 16

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

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

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

public void finish()

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

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

Ответ 17

Чтобы выйти из приложения, вы можете использовать следующее:

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

Ответ 18

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

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

Ответ 19

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

Ответ 20

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

Ответ 21

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

//On Button Back нажатие события

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

Ответ 22

От вашей деятельности на верхнем уровне:

super.onBackPressed();

Ответ 23

Это убьет все;)

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

Ответ 24

Попробуй это

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

Ответ 25

Самый простой способ, по которому я нашел выход из приложения, не нарушая логики 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 ();
    }
}

Ответ 26

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

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

Ответ 27

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

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

Ответ 28

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

exitProcess(0)

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

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

Ответ 29

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

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

Ответ 30

вы можете закрыть свои приложения. таким образом

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

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