Cierre la aplicación y abra la pantalla de inicio en Android

Tengo dos actividades diferentes. El primero lanza el segundo. En la segunda actividad, System.exit(0) para forzar el cierre de la aplicación, pero la primera actividad se muestra automáticamente en lugar de que la aplicación regrese a la pantalla de inicio. ¿Cómo puedo evitar esto y obtener que la aplicación regrese a la pantalla de inicio?

Deberías pensar realmente en no salir de la aplicación. Así no es como funcionan las aplicaciones de Android.

Respuesta corta: llame a moveTaskToBack(true) en su Activity lugar de System.exit() . Esto ocultará su aplicación hasta que el usuario quiera volver a usarla.

La respuesta más larga comienza con otra pregunta: ¿por qué quieres matar tu aplicación?

El sistema operativo Android maneja la gestión de memoria y los procesos, así que mi consejo es que deje que Android se preocupe por esto. Si el usuario quiere abandonar su aplicación, puede presionar el botón Inicio y su aplicación desaparecerá de manera efectiva. Si el teléfono necesita más memoria más adelante, el SO terminará su aplicación.

Siempre que responda adecuadamente a los eventos del ciclo de vida , ni usted ni el usuario deben preocuparse de si su aplicación aún se está ejecutando o no.

Entonces, si quiere ocultar su aplicación, llame a moveTaskToBack() y deje que Android decida cuándo matarlo.

La forma más fácil de lograr esto se muestra a continuación (sin afectar la administración de la memoria nativa de Android. No implica la muerte del proceso).

  1. Lanzar una actividad usando esta intención:

     Intent intent = new Intent(this, FinActivity.class); intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); startActivity(intent); finish(); 
  2. En la actividad de destino FinActivity.class , llame a finish () en onCreate .

Pasos Explicados:

  1. Crea un bash que borra todas las demás actividades (FLAG_ACTIVITY_CLEAR_TOP) y elimina la actividad actual.

  2. La actividad se destruye a sí misma. Una alternativa es que puede hacer una pantalla de inicio en finActivity. Esto es opcional

Android tiene un mecanismo para cerrar una aplicación de forma segura según su documentación. En la última actividad que se sale (normalmente 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) garantiza que todos los objetos se finalicen y que se recoja la basura cuando la aplicación finalice. Por ejemplo:

 public void onDestroy() { super.onDestroy(); /* * Notify the system to finalize and collect all objects of the * application on exit so that the process running the application can * be killed by the system without causing issues. NOTE: If this is set * to true then the process will not be killed until all of its threads * have closed. */ System.runFinalizersOnExit(true); /* * Force the system to close the application down completely instead of * retaining it in the background. The process that runs the application * will be killed. The application will be completely created as a new * application in a new process if the user starts the application * again. */ System.exit(0); } 

Finalmente, Android no notificará a una aplicación del evento de la tecla INICIO , por lo que no podrá cerrar la aplicación cuando se presione la tecla INICIO . Android reserva el evento clave HOME a sí mismo para que un desarrollador no pueda evitar que los usuarios abandonen su aplicación.

También puede especificar noHistory = “true” en la etiqueta para la primera actividad o finalizar la primera actividad tan pronto como inicie la segunda (como dijo David).

AFAIK, “forzar cierre” elimina el proceso que aloja la JVM en la que se ejecuta la aplicación y System.exit () finaliza la JVM que ejecuta la instancia de la aplicación. Ambas son formas de terminaciones abruptas y no recomendables para el flujo normal de aplicaciones.

Del mismo modo que no es aconsejable buscar excepciones para cubrir los flujos lógicos que un progtwig podría emprender.

¡Utilizo este método para cerrar las Actividades!

 public static void closeAllBelowActivities(Activity current) { boolean flag = true; Activity below = current.getParent(); if (below == null) return; System.out.println("Below Parent: " + below.getClass()); while (flag) { Activity temp = below; try { below = temp.getParent(); temp.finish(); } catch (Exception e) { flag = false; } } } 

Cuando inicie la segunda actividad, finish() la primera inmediatamente:

 startActivity(new Intent(...)); finish(); 

android.os.Process.killProcess(android.os.Process.myPid()); funciona bien, pero se recomienda dejar que la plataforma Android se preocupe por la gestión de la memoria 🙂

No puede hacer System.exit (), no es seguro.

Puede hacer esto: Process.killProcess (Process.myPid ());

Yo uso esto:

1) La actividad principal llama a la actividad secundaria con el método “startActivityForResult”

2) En la actividad secundaria cuando está cerrando:

 int exitCode = 1; // Select the number you want setResult(exitCode); finish(); 

3) Y en la actividad principal anula el método “onActivityResult”:

 public void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); int exitCode = 1; if(resultCode == exitCode) { super.setResult(exitCode); // use this if you have more than 2 activities finish(); } } 

Esto funciona bien para mi.

Usa el método de finish . Es el método más simple y fácil.

 this.finish(); 

Tenga en cuenta que cuando se trabaja con aplicaciones que usan conexiones de socket persistentes, el método finish() no libera la conexión. En circunstancias normales, finish() es la mejor opción, pero si necesitas salir de una aplicación y liberar todo el recurso que está utilizando, utiliza killProcess . No tuve problemas para usarlo.

Inicie la segunda actividad con startActivityForResult y en la segunda actividad devuelva un valor que una vez en el método onActivityResult de la primera actividad cierre la aplicación principal. Creo que esta es la forma correcta en que lo hace Android.

Prueba lo siguiente. Esto funciona para mi.

 ActivityManager am = (ActivityManager) this.getSystemService(ACTIVITY_SERVICE); List taskInfo = am.getRunningTasks(1); ComponentName componentInfo = taskInfo.get(0).topActivity; am.restartPackage(componentInfo.getPackageName()); 

En realidad es tranquilo y tranquilo.

La forma en que hago esto es guardando un indicador en una variable estática disponible para todos. Luego, cuando salgo, configuro esta bandera y todas mis actividades verifican esta bandera en onResume . Si la bandera está configurada, System.exit en esa actividad.

De esta forma, todas las actividades verificarán la bandera y se cerrarán correctamente si se establece la bandera.

Está usted equivocado. Hay una forma de matar una aplicación. En una clase con la aplicación de killApp , usamos algún campo, por ejemplo, killApp . Cuando comenzamos la pantalla de bienvenida (primera actividad) en onResume() , establecemos un parámetro para false para el campo killApp . En cada actividad que tenemos cuando onResume() se llama al final, llamamos a algo así:

 if(AppClass.killApp()) finish(); 

Cada actividad que está llegando a la pantalla tiene que llamar a onResume() . Cuando se llama, tenemos que verificar si nuestro campo killApp es verdadero. Si es cierto, las actividades actuales llaman finish() . Para invocar la acción completa, usamos la siguiente construcción. Por ejemplo, en la acción de un botón:

 AppClass.setkillApplication(true); finish(); return; 

Esto es lo que hice para cerrar la aplicación: en mi aplicación tengo una clase de actividad base, agregué una bandera estática llamada “applicationShutDown”. Cuando necesito cerrar la aplicación, la configuro en verdadero.

En la actividad base onCreate y onResume después de llamar a las llamadas súper, pruebo esta bandera. Si el “applicationShutDown” es verdadero, llamo finish en la Actividad actual.

Esto funcionó para mí:

 protected void onResume() { super.onResume(); if(BaseActivity.shutDownApp) { finish(); return; }} 

Digamos que tienes una stack de actividades como A> B> C> D> E. Estás en la actividad D y quieres cerrar tu aplicación. Esto es lo que harás:

En la Actividad de donde desea cerrar (Actividad D) –

 Intent intent = new Intent(D.this,A.class); intent.putExtra("exit", "exit"); intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP| Intent.FLAG_ACTIVITY_SINGLE_TOP); startActivity(intent); 

En su RootActivity (es decir, su actividad base, aquí Actividad A) –

 @Override protected void onNewIntent(Intent intent) { super.onNewIntent(intent); if (intent.hasExtra("exit")) { setIntent(intent); } } @Override protected void onResume() { super.onResume(); if (getIntent() != null) { if (("exit").equalsIgnoreCase(getIntent().getStringExtra(("exit")))) { onBackPressed(); } } } 

onNewIntent se usa porque si la actividad está activa, obtendrá el primer bash que la inició. No el nuevo. Para más detalles – Documentación

Ejecute la segunda actividad usando la actividad de inicio para el resultado:

 Intent intent = new Intent(FirstActivity.this, SecondActivity.class); //This line is important intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT); startActivityForResult(intent, REQUEST_CODE); 

Agregue esta función a la primera Actividad:

 @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); if(rquestCode == REQUEST_CODE) if(resultCode == RESULT_CANCELED) finish(); } 

Y agrega esto a la segunda Actividad:

 @Override public boolean onKeyDown(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) { Log.i(TAG, "Back key pressed"); setResult(RESULT_CANCELED); finish(); return true; } return super.onKeyDown(keyCode, event); } 

No es recomendable, pero aún puedes usar esto. Mejor ir con esta solución en caso de que necesite salir de la aplicación.

Según mi opinión, la mejor solución es finalizar cada actividad en tu aplicación como se muestra a continuación.

Paso 1. Mantener una variable estática en mainactivity. Decir,

 public static boolean isQuit = false; 

Paso 2. Al hacer clic en el evento de un botón, establezca esta variable en verdadero.

 mainactivity.isQuit = true; finish(); 

Paso 3. Y en cada actividad de su aplicación, tenga el método de onrestart como se muestra a continuación.

 @Override protected void onRestart() { // TODO Auto-generated method stub super.onRestart(); if(mainactivity.isQuit) finish(); } 

Resolví un problema similar: MainActivity inicia BrowserActivity, y necesito cerrar la aplicación, cuando el usuario presiona Atrás en BrowserActivity, no para volver a MainActivity. Entonces, en MainActivity:

 public class MainActivity extends AppCompatActivity { private static final String TAG = "sm500_Rmt.MainActivity"; private boolean m_IsBrowserStarted = false; 

y luego, en OnResume:

  @Override protected void onResume() { super.onResume(); if(m_IsBrowserStarted) { Log.w(TAG, "onResume, but it's return from browser, just exit!"); finish(); return; } Log.w(TAG, "onResume"); 

… luego continúa OnResume. Y, cuando inicie BrowserActivity:

  Intent intent = new Intent(this, BrowserActivity.class); intent.putExtra(getString(R.string.IPAddr), ip); startActivity(intent); m_IsBrowserStarted = true; 

¡Y parece que funciona bien! 🙂