Cómo salir de la aplicación de Android mediante programación

Encontré algunos códigos para salir de una aplicación de Android mediante programación. Al llamar a cualquiera de los siguientes códigos en onDestroy (), ¿saldrá por completo de la aplicación?

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

No quiero ejecutar mi aplicación en segundo plano después de hacer clic en el botón Salir. Pls me sugiere ¿puedo usar cualquiera de estos códigos para salir de mi aplicación? Si es así, ¿qué código puedo usar? ¿Es una buena forma de salir de la aplicación en Android?

Desde API 16 puede usar el método finishAffinity, que parece estar muy cerca de cerrar todas las actividades relacionadas por su nombre y descripción Javadoc:

this.finishAffinity();

Finalice esta actividad, así como todas las actividades inmediatamente debajo de ella en la tarea actual que tengan la misma afinidad. Esto se usa generalmente cuando una aplicación se puede iniciar en otra tarea (como desde una ACTION_VIEW de un tipo de contenido que comprende) y el usuario ha utilizado la navegación hacia arriba para cambiar de la tarea actual a su propia tarea. En este caso, si el usuario se ha desplazado hacia abajo a cualquier otra actividad de la segunda aplicación, todas ellas deben eliminarse de la tarea original como parte del cambio de tarea.

Tenga en cuenta que este final no le permite entregar resultados a la actividad anterior, y se lanzará una excepción si está intentando hacerlo.

Desde API 21 puedes usar un comando muy similar

finishAndRemoveTask();

Finaliza todas las actividades en esta tarea y la elimina de la lista de tareas recientes.

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

¡Esta es la mejor manera de salir de tu aplicación!

La mejor solución para mi.

finishAffinity();

System.exit(0);

Si lo usará solo finishAffinity();sin System.exit(0);su aplicación, se cerrará, pero la memoria asignada seguirá siendo utilizada por su teléfono, así que ... si desea una aplicación limpia y realmente cerrada, use ambas.

Este es el método más simple y funciona en cualquier lugar, salga de la aplicación de verdad, puede tener mucha actividad abierta y se cerrará sin problemas.

ejemplo en un clic de botón

public void exitAppCLICK (View view) {

    finishAffinity();
    System.exit(0);

}

o si desea algo agradable, ejemplo con un cuadro de diálogo de alerta con 3 botones SÍ NO y CANCELAR

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

Por favor, piense mucho si necesita eliminar la aplicación: ¿por qué no dejar que el sistema operativo descubra dónde y cuándo liberar los recursos?

De lo contrario, si está absolutamente seguro, use

finish();

Como reacción al comentario de @dave appleton: Lo primero que debe leer es el gran combo de preguntas / respuestas que @gabriel publicó: ¿Está mal cerrar una aplicación?

Ahora suponiendo que tengamos eso, la pregunta aquí todavía tiene una respuesta, ya que el código que necesita si está haciendo algo para dejar de fumar es finish() . Obviamente, puede tener más de una actividad, etc., etc., pero ese no es el punto. Vamos a ejecutar algunos de los casos de uso

1. ¿Desea dejar que el usuario abandone todo debido al uso de memoria y "no se ejecuta en segundo plano? Dudoso. Deje que el usuario detenga ciertas actividades en segundo plano, pero deje que el sistema operativo elimine cualquier recurso innecesario.
2. ¿Desea que un usuario no vaya a la actividad anterior de su aplicación? Bueno, o configúrelo para que no lo haga, o necesita una opción adicional. Si la mayor parte del tiempo la actividad back = previous funciona, ¿no presionaría el usuario a casa si quiere hacer algo más?
3. Si necesita algún tipo de reinicio, puede averiguar si / cómo / etc. se cerró su aplicación, y si su actividad se enfoca nuevamente, puede tomar medidas al respecto, mostrando una nueva pantalla en lugar de reiniciar donde estaba.

Así que al final, por supuesto, finish()no mata a todo, pero creo que sigue siendo la herramienta que necesitas. Si hay un caso de uso para "matar todas las actividades", aún no lo he encontrado.

Creo que esa aplicación debería ser matar en algún caso. Por ejemplo, hay una aplicación que se puede usar solo después de iniciar sesión. La actividad de inicio de sesión tiene dos botones, 'iniciar sesión' y 'cancelar'. Cuando haces clic en el botón "cancelar", definitivamente significa "Finalizar la aplicación". Nadie quiere la aplicación viva en segundo plano. Así que estoy de acuerdo en que algunos casos necesitan cerrar la aplicación.

Crea un ExitActivityy declaralo en manifiesto. Y llame ExitActivity.exit(context)para salir de la aplicación.

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

}

No hay aplicaciones que se cierren en Android cierra la , SampleActivity.this.finish (); finalizará la actividad actual.

Cuando cambies de una actividad a otra, termina la anterior.

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

En primer lugar, este enfoque requiere min Api 16.

Dividiré esta solución en 3 partes para resolver este problema más ampliamente.

1. Si desea salir de la aplicación en una Actividad, use este fragmento de código:

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

2. Si desea salir de la aplicación en una clase que no sea Activity y que tenga acceso a Activity, use este fragmento de código:

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

3. Si desea salir de la aplicación en una clase que no sea de Actividad y no puede acceder a Actividad como Servicio, le recomiendo que use BroadcastReceiver. Puede agregar este enfoque a todas sus actividades en su proyecto.

Cree variables de instancia LocalBroadcastManager y BroadcastReceiver. Puede reemplazar getPackageName () + ". Closeapp" si lo desea.

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

Agregue estos al método de Actividad onCreate ().

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

Además, no olvide llamar al receptor para cancelar el registro en el método de actividad onDestroy ()

mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);

Para salir de la aplicación, debe enviar la transmisión utilizando LocalBroadcastManager que uso en mi clase PlayService que extiende el Servicio.

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

Puedes usar finishAndRemoveTask ()desde API 21

public void finishAndRemoveTask ()

Finaliza todas las actividades en esta tarea y la elimina de la lista de tareas recientes.

Depende de qué tan rápido quieras cerrar tu aplicación.

Una forma segura de cerrar su aplicación es terminarAffinity ();

Cierra su aplicación después de que todos los procesos hayan finalizado el procesamiento. Esto puede necesitar algo de tiempo. Si cierra su aplicación de esta manera y la reinicia después de un corto tiempo, es posible que su nueva aplicación se ejecute en el mismo proceso. Con todos los procesos no terminados y objetos singleton de la aplicación anterior.

Si quiere estar seguro de que su aplicación está cerrada, use System.exit (0);

Esto cerrará tu aplicación inmediatamente. Pero es posible que dañe los archivos que su aplicación ha abierto o que una edición en las preferencias compartidas no termine. Así que usa esto con cuidado.

Si usa watchdog en combinación con una tarea de larga duración, puede ver las influencias de los diferentes métodos.

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

Esto mata su aplicación después de 2 segundos sin mostrar un cuadro de diálogo ANR o algo así. Si elimina System.exit (0) , ejecute este código y reinicie la aplicación después de que se cierre, experimentará un comportamiento extraño, porque el bucle sin fin todavía se está ejecutando.

Debería usarlo mejor finish()si está dentro Activityo getActivity().finish()si está en elFragment .

Si desea salir por completo de la aplicación, use:

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

Forma fácil y sencilla de salir de la aplicación

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

Queremos un código que sea robusto y simple. Esta solución funciona en dispositivos antiguos y dispositivos más nuevos.

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

Creo que lo que estás buscando es esto

activity.moveTaskToBack(Boolean nonRoot);

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

Similar a @MobileMateo, pero en Kotlin

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

No estoy seguro de si esto está mal visto o no, pero así es como lo hago ...

Paso 1: generalmente tengo una clase que contiene métodos y variables a los que quiero acceder globalmente. En este ejemplo, lo llamaré la clase "Aplicación". Cree una variable de actividad estática dentro de la clase para cada actividad que tenga su aplicación. Luego, cree un método estático llamado "cerrar" que ejecutará el finish()método en cada una de esas variables de Actividad si NO son nulas . Si tiene una actividad principal / principal, ciérrela al final:

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

Paso 2: en cada una de sus actividades, anule los métodos onStart()y onDestroy(). En onStart(), establezca la variable estática en su clase de aplicación igual a " this". En onDestroy(), póngalo igual a null. Por ejemplo, en la clase "Actividad1":

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

Paso 3 - Cuando quieras cerrar tu aplicación, simplemente llamaApp.close() desde cualquier lugar. ¡Todas las actividades instanciadas se cerrarán! Dado que solo está cerrando actividades y no está matando la aplicación en sí (como en sus ejemplos), Android es libre de hacerse cargo de allí y hacer cualquier limpieza necesaria.

Nuevamente, no sé si esto estaría mal visto por alguna razón. Si es así, ¡me encantaría leer comentarios sobre por qué es y cómo se puede mejorar!

¿Salir de una aplicación está mal visto? . Ir a través de este enlace. Responde tu pregunta. El sistema hace el trabajo de matar una aplicación.

Suponga que tiene dos actividades A y B. Navega de A a B. Cuando hace clic en el botón Atrás, su actividad B aparece de la columna y se destruye. La actividad anterior en la actividad A de la pila posterior se enfoca.

Debe dejar que el sistema decida cuándo matar la aplicación.

vacío público finish()

Llame a esto cuando termine su actividad y deba cerrarse.

Supongamos que tienes muchas actividades. puedes usar la barra de acción. Al hacer clic en el icono de inicio, navegue a MainActivity de su aplicación. En MainActivity, haga clic en el botón Atrás para salir de la aplicación.

Para salir de su aplicación, puede usar lo siguiente:

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

También para detener los servicios también llame al siguiente método:

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

Esto puede ser muy tarde y también según las pautas que se supone que no debes manejar el proceso del ciclo de vida por ti mismo (ya que el sistema operativo lo hace por ti). Una sugerencia sería que registre un receptor de transmisión en todas sus actividades con " finish()" en sus onReceive() y cuando quiera dejarlo, puede simplemente pasar una intención que indique que todas las actividades deben cerrarse ..... Aunque asegúrese de hacerlo " anule el registro "del receptor en sus onDestroy()métodos.

No es una buena decisión, porque va en contra de los principios de procesamiento de aplicaciones de Android. Android no mata ningún proceso a menos que sea absolutamente inevitable. Esto ayuda a que las aplicaciones se inicien más rápido, porque siempre se mantienen en la memoria. Por lo tanto, necesita una razón muy especial para eliminar el proceso de su aplicación.

La solución correcta y exacta para salir de la aplicación al hacer clic en el botón es usar el siguiente código:

// Al presionar el botón Volver evento

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

Si está utilizando Kotlin, la forma correcta de salir de la aplicación y alternativa System.exit()es un método incorporado

exitProcess(0)

Ver la documentación .

Número 0como parámetro significa que la salida está prevista y no se produjo ningún error.

Esto matará cualquier cosa;)

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

Prueba esto

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

La forma más fácil que encontré para salir de una aplicación de una actividad, sin romper la lógica de Android y sin agregar más código en las actividades existentes y pasar extras es la siguiente:

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

el QuitApplicationActivityser:

public class QuitApplicationActivity extends AppCompatActivity {

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

        finish ();
    }
}

La respuesta de @Sivi cierra la aplicación. Pero a cambio, si tiene algunas actividades secundarias, podría abrirse otra actividad inacabada. He añadido noHistory:truea mis actividades por lo que la aplicación de retorno se inicia desde MainActivity.

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

Solo para agregar uno a la lista de métodos brutales para terminar una aplicación:

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

puedes cerrar tus aplicaciones completas. así

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

Funcionará al 100%. ¡La mejor de las suertes!

Simplemente use el acabado () al presionar la tecla Atrás en Keypressed ()