¿Cómo cerrar la aplicación de Android?

Quiero cerrar mi aplicación, para que ya no se ejecute en segundo plano.

¿Como hacer eso? ¿Es esta una buena práctica en la plataforma Android?

Si confío en el botón "Atrás", cierra la aplicación, pero permanece en segundo plano. Incluso hay una aplicación llamada "TaskKiller" solo para eliminar esas aplicaciones en segundo plano.

Android tiene un mecanismo para cerrar una aplicación de forma segura según su documentación. En la última Actividad que sale (generalmente la Actividad principal que apareció por primera vez cuando se inició la aplicación) simplemente coloque un par de líneas en el método onDestroy (). La llamada a System.runFinalizersOnExit (true) asegura que todos los objetos se finalizarán y se recolectará la basura cuando la aplicación salga. También puede eliminar una aplicación rápidamente a través de android.os.Process.killProcess (android.os.Process.myPid ()) si lo prefiere. La mejor manera de hacer esto es poner un método como el siguiente en una clase auxiliar y luego llamarlo cuando la aplicación deba ser eliminada. Por ejemplo, en el método de destrucción de la actividad raíz (suponiendo que la aplicación nunca mate esta actividad):

Además, Android no notificará a una aplicación el evento de la tecla INICIO , por lo que no puede cerrar la aplicación cuando se presiona la tecla INICIO . Android se reserva el evento clave HOME para que un desarrollador no pueda evitar que los usuarios abandonen su aplicación. Sin embargo, puede determinar si se presiona la tecla INICIO estableciendo una marca en verdadero en una clase auxiliar que asume que se ha presionado la tecla INICIO , luego cambiando la marca a falso cuando ocurre un evento que muestra que la tecla INICIO no se presionó y luego comprobando si la tecla INICIO se presionó en el método onStop () de la actividad.

No olvide manejar la tecla INICIO para cualquier menú y en las actividades que inician los menús. Lo mismo ocurre con la tecla BUSCAR . A continuación hay algunas clases de ejemplo para ilustrar:

Aquí hay un ejemplo de una actividad raíz que mata la aplicación cuando se destruye:

package android.example;

/**
 * @author Danny Remington - MacroSolve
 */

public class HomeKey extends CustomActivity {

    public void onDestroy() {
        super.onDestroy();

        /*
         * Kill application when the root activity is killed.
         */
        UIHelper.killApp(true);
    }

}

Aquí hay una actividad abstracta que se puede extender para manejar la tecla INICIO para todas las actividades que la extienden:

package android.example;

/**
 * @author Danny Remington - MacroSolve
 */

import android.app.Activity;
import android.view.Menu;
import android.view.MenuInflater;

/**
 * Activity that includes custom behavior shared across the application. For
 * example, bringing up a menu with the settings icon when the menu button is
 * pressed by the user and then starting the settings activity when the user
 * clicks on the settings icon.
 */
public abstract class CustomActivity extends Activity {
    public void onStart() {
        super.onStart();

        /*
         * Check if the app was just launched. If the app was just launched then
         * assume that the HOME key will be pressed next unless a navigation
         * event by the user or the app occurs. Otherwise the user or the app
         * navigated to this activity so the HOME key was not pressed.
         */

        UIHelper.checkJustLaunced();
    }

    public void finish() {
        /*
         * This can only invoked by the user or the app finishing the activity
         * by navigating from the activity so the HOME key was not pressed.
         */
        UIHelper.homeKeyPressed = false;
        super.finish();
    }

    public void onStop() {
        super.onStop();

        /*
         * Check if the HOME key was pressed. If the HOME key was pressed then
         * the app will be killed. Otherwise the user or the app is navigating
         * away from this activity so assume that the HOME key will be pressed
         * next unless a navigation event by the user or the app occurs.
         */
        UIHelper.checkHomeKeyPressed(true);
    }

    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.settings_menu, menu);

        /*
         * Assume that the HOME key will be pressed next unless a navigation
         * event by the user or the app occurs.
         */
        UIHelper.homeKeyPressed = true;

        return true;
    }

    public boolean onSearchRequested() {
        /*
         * Disable the SEARCH key.
         */
        return false;
    }
}

Aquí hay un ejemplo de una pantalla de menú que maneja la tecla INICIO :

/**
 * @author Danny Remington - MacroSolve
 */

package android.example;

import android.os.Bundle;
import android.preference.PreferenceActivity;

/**
 * PreferenceActivity for the settings screen.
 * 
 * @see PreferenceActivity
 * 
 */
public class SettingsScreen extends PreferenceActivity {
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.layout.settings_screen);
    }

    public void onStart() {
        super.onStart();

        /*
         * This can only invoked by the user or the app starting the activity by
         * navigating to the activity so the HOME key was not pressed.
         */
        UIHelper.homeKeyPressed = false;
    }

    public void finish() {
        /*
         * This can only invoked by the user or the app finishing the activity
         * by navigating from the activity so the HOME key was not pressed.
         */
        UIHelper.homeKeyPressed = false;
        super.finish();
    }

    public void onStop() {
        super.onStop();

        /*
         * Check if the HOME key was pressed. If the HOME key was pressed then
         * the app will be killed either safely or quickly. Otherwise the user
         * or the app is navigating away from the activity so assume that the
         * HOME key will be pressed next unless a navigation event by the user
         * or the app occurs.
         */
        UIHelper.checkHomeKeyPressed(true);
    }

    public boolean onSearchRequested() {
        /*
         * Disable the SEARCH key.
         */
        return false;
    }

}

Aquí hay un ejemplo de una clase auxiliar que maneja la tecla HOME en la aplicación:

package android.example;

/**
 * @author Danny Remington - MacroSolve
 *
 */

/**
 * Helper class to help handling of UI.
 */
public class UIHelper {
    public static boolean homeKeyPressed;
    private static boolean justLaunched = true;

    /**
     * Check if the app was just launched. If the app was just launched then
     * assume that the HOME key will be pressed next unless a navigation event
     * by the user or the app occurs. Otherwise the user or the app navigated to
     * the activity so the HOME key was not pressed.
     */
    public static void checkJustLaunced() {
        if (justLaunched) {
            homeKeyPressed = true;
            justLaunched = false;
        } else {
            homeKeyPressed = false;
        }
    }

    /**
     * Check if the HOME key was pressed. If the HOME key was pressed then the
     * app will be killed either safely or quickly. Otherwise the user or the
     * app is navigating away from the activity so assume that the HOME key will
     * be pressed next unless a navigation event by the user or the app occurs.
     * 
     * @param killSafely
     *            Primitive boolean which indicates whether the app should be
     *            killed safely or quickly when the HOME key is pressed.
     * 
     * @see {@link UIHelper.killApp}
     */
    public static void checkHomeKeyPressed(boolean killSafely) {
        if (homeKeyPressed) {
            killApp(true);
        } else {
            homeKeyPressed = true;
        }
    }

    /**
     * Kill the app either safely or quickly. The app is killed safely by
     * killing the virtual machine that the app runs in after finalizing all
     * {@link Object}s created by the app. The app is killed quickly by abruptly
     * killing the process that the virtual machine that runs the app runs in
     * without finalizing all {@link Object}s created by the app. Whether the
     * app is killed safely or quickly the app will be completely created as a
     * new app in a new virtual machine running in a new process if the user
     * starts the app again.
     * 
     * <P>
     * <B>NOTE:</B> The app will not be killed until all of its threads have
     * closed if it is killed safely.
     * </P>
     * 
     * <P>
     * <B>NOTE:</B> All threads running under the process will be abruptly
     * killed when the app is killed quickly. This can lead to various issues
     * related to threading. For example, if one of those threads was making
     * multiple related changes to the database, then it may have committed some
     * of those changes but not all of those changes when it was abruptly
     * killed.
     * </P>
     * 
     * @param killSafely
     *            Primitive boolean which indicates whether the app should be
     *            killed safely or quickly. If true then the app will be killed
     *            safely. Otherwise it will be killed quickly.
     */
    public static void killApp(boolean killSafely) {
        if (killSafely) {
            /*
             * Notify the system to finalize and collect all objects of the app
             * on exit so that the virtual machine running the app can be killed
             * by the system without causing issues. NOTE: If this is set to
             * true then the virtual machine will not be killed until all of its
             * threads have closed.
             */
            System.runFinalizersOnExit(true);

            /*
             * Force the system to close the app down completely instead of
             * retaining it in the background. The virtual machine that runs the
             * app will be killed. The app will be completely created as a new
             * app in a new virtual machine running in a new process if the user
             * starts the app again.
             */
            System.exit(0);
        } else {
            /*
             * Alternatively the process that runs the virtual machine could be
             * abruptly killed. This is the quickest way to remove the app from
             * the device but it could cause problems since resources will not
             * be finalized first. For example, all threads running under the
             * process will be abruptly killed when the process is abruptly
             * killed. If one of those threads was making multiple related
             * changes to the database, then it may have committed some of those
             * changes but not all of those changes when it was abruptly killed.
             */
            android.os.Process.killProcess(android.os.Process.myPid());
        }

    }
}

¡SI! Sin duda, puede cerrar su aplicación para que ya no se ejecute en segundo plano. Como otros han comentado, finish()la forma recomendada por Google no significa que su programa esté cerrado.

System.exit(0);

Ahí cerrará su aplicación sin dejar nada ejecutándose en segundo plano. Sin embargo, use esto sabiamente y no deje los archivos abiertos, las manijas de las bases de datos abiertas, etc. Estas cosas normalmente se limpiarían mediante el finish()comando.

Personalmente ODIO cuando elijo Salir en una aplicación y realmente no sale.

Así es como lo hice:

Acabo de poner

Intent intent = new Intent(Main.this, SOMECLASSNAME.class);
Main.this.startActivityForResult(intent, 0);

dentro del método que abre una actividad, luego dentro del método de SOMECLASSNAME que está diseñado para cerrar la aplicación que puse:

setResult(0);
finish();

Y puse lo siguiente en mi clase principal:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if(resultCode == 0) {
        finish();
    }
}

Solo para responder mi propia pregunta ahora después de tanto tiempo (ya que CommonsWare comentó sobre la respuesta más popular que dice que NO debemos hacer esto):

Cuando quiero salir de la aplicación:

1. Comienzo mi primera actividad (ya sea pantalla de bienvenida o cualquier actividad que esté actualmente en la parte inferior de la pila de actividades) con FLAG_ACTIVITY_CLEAR_TOP(que cerrará todas las demás actividades iniciadas después, lo que significa que todas ellas). Simplemente haga que esta actividad esté en la pila de actividades (no la termine por alguna razón por adelantado).
2. Llamo finish()a esta actividad

Esto es, funciona bastante bien para mí.

Simplemente escriba este código en su botón SALIR, haga clic.

Intent intent = new Intent(getApplicationContext(), MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.putExtra("LOGOUT", true);
startActivity(intent);

Y en el método onCreate () de su MainActivity.class escriba debajo del código como primera línea,

if (getIntent().getBooleanExtra("LOGOUT", false))
{
    finish();
}

No es posible usar las API de framework. Es a discreción del sistema operativo (Android) decidir cuándo un proceso debe eliminarse o permanecer en la memoria. Esto es por razones de eficiencia: si el usuario decide reiniciar la aplicación, ya está allí sin tener que cargarla en la memoria.

Así que no, no solo se desaconseja , es imposible hacerlo.

Para salir de formas de aplicación:

Camino 1:

llamar finish();y anular onDestroy();. Pon el siguiente código en onDestroy():

System.runFinalizersOnExit(true)

o

android.os.Process.killProcess(android.os.Process.myPid());

Camino 2:

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

Camino 3:

Quit();

protected void Quit() {
    super.finish();
}

Camino 4:

Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.putExtra("EXIT", true);
startActivity(intent);

if (getIntent().getBooleanExtra("EXIT", false)) {
     finish();
}

Camino 5:

A veces, las llamadas finish()solo saldrán de la actividad actual, no de toda la aplicación. Sin embargo, hay una solución para esto. Cada vez que inicies un activity, comienza a usarlo startActivityForResult(). Cuando desee cerrar toda la aplicación, puede hacer algo como lo siguiente:

setResult(RESULT_CLOSE_ALL);
finish();

Luego, defina la onActivityResult(...)devolución de llamada de cada actividad para que cuando una activityregrese con el RESULT_CLOSE_ALLvalor, también llame a finish():

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch(resultCode){
        case RESULT_CLOSE_ALL:{
            setResult(RESULT_CLOSE_ALL);
            finish();
        }
    }
    super.onActivityResult(requestCode, resultCode, data);
}

Así es como Windows Mobile ha funcionado ... bueno ... ¡siempre! Esto es lo que Microsoft tiene que decir al respecto:

http://blogs.msdn.com/windowsmobile/archive/2006/10/05/The-Emperor-Has-No-Close.aspx (¿es triste que haya recordado el título de la publicación del blog desde 2006? Encontré el artículo en Google buscando "el emperador no tiene cerca" jajaja)

En breve:

Si el sistema necesita más memoria mientras la aplicación está en segundo plano, cerrará la aplicación. Pero, si el sistema no necesita más memoria, la aplicación permanecerá en la RAM y estará lista para volver rápidamente la próxima vez que el usuario la necesite.

Muchos comentarios en esta pregunta en O'Reilly sugieren que Android se comporta de la misma manera, cerrando aplicaciones que no se han usado durante un tiempo solo cuando Android necesita la memoria que están usando.

Dado que esta es una característica estándar, cambiar el comportamiento para cerrar con fuerza cambiaría la experiencia del usuario. Muchos usuarios se habrían acostumbrado al rechazo suave de sus aplicaciones de Android, por lo que cuando descartan una con la intención de volver a ella después de realizar otras tareas, pueden sentirse bastante frustrados de que el estado de la aplicación se restablezca o que tarde más abrir. Me quedaría con el comportamiento estándar porque es lo que se espera.

Llamar al finish()método en una Actividad tiene el efecto deseado en esa actividad actual.

ninguna de las respuestas anteriores funciona bien en mi aplicación

aquí está mi código de trabajo

en su botón de salida:

Intent intent = new Intent(getApplicationContext(), MainActivity.class);
ComponentName cn = intent.getComponent();
Intent mainIntent = IntentCompat.makeRestartActivityTask(cn);
mainIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
mainIntent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
mainIntent.putExtra("close", true);
startActivity(mainIntent);
finish();

ese código es para cerrar cualquier otra actividad y llevar MainActivity a la cima ahora en su MainActivity:

if( getIntent().getBooleanExtra("close", false)){
    finish();
}

Ponga una finish();declaración de la siguiente manera:

myIntent.putExtra("key1", editText2.getText().toString());

finish();

LoginActivity.this.startActivity(myIntent);

En cada actividad

@Override
    protected void onPause() {

        super.onPause();

        System.exit(0);

    }

Copie el código a continuación y pegue el archivo AndroidManifest.xml en Primera etiqueta de actividad.

<activity                        
            android:name="com.SplashActivity"
            android:clearTaskOnLaunch="true" 
            android:launchMode="singleTask"
            android:excludeFromRecents="true">              
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER"
                />
            </intent-filter>
        </activity>     

Agregue también este código a continuación en todo bajo Etiqueta de actividad en el archivo AndroidManifest.xml

 android:finishOnTaskLaunch="true"

No es posible con 2.3. Busco mucho y probé muchas aplicaciones. La mejor solución es instalar tanto (go taskmanager) como (reinicio rápido). Cuando los use juntos, funcionará y liberará la memoria. Otra opción es actualizar a Android Ice Cream Sandwich 4.0.4 que permite el control (cierre) de las aplicaciones.

Quería volver a la pantalla de inicio de mi dispositivo Android, así que simplemente usé:

moveTaskToBack(true);

El uso de finishAffinity()puede ser una buena opción si desea cerrar todas las actividades de la aplicación. Según los documentos de Android

Finish this activity as well as all activities immediately below it in the current task that have the same affinity.

public class CloseAppActivity extends AppCompatActivity
{
    public static final void closeApp(Activity activity)
    {
        Intent intent = new Intent(activity, CloseAppActivity.class);
        intent.addCategory(Intent.CATEGORY_HOME);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
                IntentCompat.FLAG_ACTIVITY_CLEAR_TASK);
        activity.startActivity(intent);
    }

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

y en manifiesto:

<activity
     android:name=".presenter.activity.CloseAppActivity"
     android:noHistory="true"
     android:clearTaskOnLaunch="true"/>

Luego puede llamar CloseAppActivity.closeApp(fromActivity)y la aplicación se cerrará.

Simplemente escriba el siguiente código en onBackPressed:

@Override
public void onBackPressed() {
    // super.onBackPressed();

    //Creating an alert dialog to logout
    AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
    alertDialogBuilder.setMessage("Do you want to Exit?");
    alertDialogBuilder.setPositiveButton("Yes",
            new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface arg0, int arg1) {
                    Intent intent = new Intent(Intent.ACTION_MAIN);
                    intent.addCategory(Intent.CATEGORY_HOME);
                    startActivity(intent);
                }
            });

    alertDialogBuilder.setNegativeButton("No",
            new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface arg0, int arg1) {

                }
            });

    //Showing the alert dialog
    AlertDialog alertDialog = alertDialogBuilder.create();
    alertDialog.show();
}

llamando a finish (); en el botón OnClick o en el menú

case R.id.menu_settings:

      finish();
     return true;

Creo que cerrará su actividad y toda la Sub actividad relacionada con ella.

public boolean onOptionsItemSelected(MenuItem item) {

        int id = item.getItemId();]
        if (id == R.id.Exit) {
            this.finishAffinity();
            return true;
        }

        return super.onOptionsItemSelected(item);
    }

La mejor y más corta forma de usar la tabla System.exit.

System.exit(0);

La VM detiene la ejecución y el programa se cerrará.

Utilice " this.FinishAndRemoveTask();": cierra la aplicación correctamente