¿Qué está haciendo exactamente el método Activity.finish ()?

Estoy desarrollando aplicaciones de Android por un tiempo, y seguí una gran cantidad de publicaciones sobre el ciclo de vida de la actividad y el ciclo de vida de la aplicación.

Sé que el método Activity.finish() llama en algún lugar en el camino a Activity.onDestroy() , y también elimina la actividad de la stack, y supongo que de alguna manera apunta al sistema operativo y al recolector de basura que puede “hacer su truco” y liberar el recuerdo cuando le parece un buen momento para hacerlo …

Llegué a esta publicación: ¿renunciar a una aplicación no está bien? y lea la respuesta de Mark Murphy.

Me hizo un poco confundido acerca de qué es exactamente lo que hace el método finish() .

¿Hay alguna posibilidad de que llame a finish() y onDestroy() no se llamará?

Al llamar a finish() en una actividad, se ejecuta el método onDestroy() este método puede hacer cosas como:

  1. Descartar los cuadros de diálogo que estaba gestionando la actividad.
  2. Cierre todos los cursores que estaba gestionando la actividad.
  3. Cierre cualquier diálogo de búsqueda abierto

Además, onDestroy() no es un destructor. En realidad, no destruye el objeto. Es solo un método que se llama basado en un cierto estado. Por lo tanto, su instancia sigue viva y muy bien * después de que la superclase onDestroy() ejecute y onDestroy() mantiene los procesos por si el usuario desea reiniciar la aplicación, esto hace que la fase de inicio sea más rápida. El proceso no hará nada y si la memoria necesita ser recuperada, el proceso será asesinado

Mis 2 centavos en la respuesta de @K_Anas. Realicé una prueba simple en el método finish (). Métodos de callback importantes enumerados en el ciclo de vida de la actividad

  1. Llamar a finish () en onCreate (): onCreate () -> onDestroy ()
  2. Llamar a finish () en onStart (): onCreate () -> onStart () -> onStop () -> onDestroy ()
  3. Llamar a finish () en onResume (): onCreate () -> onStart () -> onResume () -> onPause () -> onStop () -> onDestroy ()

Lo que quiero decir es que las contrapartes de los métodos junto con cualquier método intermedio se llaman cuando se ejecuta finish ().

p.ej:

  onCreate() counter part is onDestroy() onStart() counter part is onStop() onPause() counter part is onResume() 

onDestroy() está destinado a la limpieza final, liberando recursos que puedas por tu cuenta, cerrando conexiones abiertas, lectores, escritores, etc. Si no lo anula, el sistema hace lo que debe.

por otro lado, finish() solo le permite al sistema saber que el progtwigdor quiere que la Activity actual se termine. Y, por lo tanto, llama onDestroy() después de eso.

Algo para tener en cuenta:

no es necesario que solo una llamada para finish() desencadene una llamada a onDestroy() . No. Como sabemos, el sistema android es libre de matar actividades si se siente que hay recursos necesarios para la Activity actual que se necesitan para ser liberados.

También note si llama a finish () después de un bash, no puede volver a la actividad anterior con el botón “atrás”

 startActivity(intent); finish(); 

El método Finish () destruirá la actividad actual. Puede utilizar este método en los casos en que no desea que esta actividad se cargue una y otra vez cuando el usuario presiona el botón Atrás. Básicamente, borra la actividad de la stack actual.

Varias respuestas y notas afirman que finish () puede omitir onPause () y onStop () y ejecutar onDestroy () directamente. Para ser justos, la documentación de Android en este ( http://developer.android.com/reference/android/app/Activity.html ) señala “La actividad está terminando o siendo destruida por el sistema”, que es bastante ambigua, pero podría sugerir que finish () puede saltar a onDestroy ().

El JavaDoc en finish () es similarmente decepcionante ( http://developer.android.com/reference/android/app/Activity.html#finish () ) y en realidad no nota qué método (s) se llaman en respuesta para finalizar ().

Así que escribí esta mini aplicación a continuación, que registra cada estado al ingresar. Incluye un botón que llama a finish () para que pueda ver los registros de los métodos que se activan. Este experimento sugiere que finish () también llama a OnPause () y onStop (). Aquí está la salida que obtengo:

 2170-2170/? D/LIFECYCLE_DEMO﹕ INSIDE: onCreate 2170-2170/? D/LIFECYCLE_DEMO﹕ INSIDE: onStart 2170-2170/? D/LIFECYCLE_DEMO﹕ INSIDE: onResume 2170-2170/? D/LIFECYCLE_DEMO﹕ User just clicked button to initiate finish() 2170-2170/? D/LIFECYCLE_DEMO﹕ INSIDE: onPause 2170-2170/? D/LIFECYCLE_DEMO﹕ INSIDE: onStop 2170-2170/? D/LIFECYCLE_DEMO﹕ INSIDE: onDestroy package com.mvvg.apps.lifecycle; import android.app.Activity; import android.os.Bundle; import android.util.Log; import android.view.View; import android.view.View.OnClickListener; import android.widget.Button; import android.widget.LinearLayout; import android.widget.Toast; public class AndroidLifecycle extends Activity { private static final String TAG = "LIFECYCLE_DEMO"; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Log.d(TAG, "INSIDE: onCreate"); setContentView(R.layout.activity_main); LinearLayout layout = (LinearLayout) findViewById(R.id.myId); Button button = new Button(this); button.setOnClickListener(new OnClickListener() { @Override public void onClick(View view) { Toast.makeText(AndroidLifecycle.this, "Initiating finish()", Toast.LENGTH_SHORT).show(); Log.d(TAG, "User just clicked button to initiate finish()"); finish(); } }); layout.addView(button); } @Override protected void onStart() { super.onStart(); Log.d(TAG, "INSIDE: onStart"); } @Override protected void onStop() { super.onStop(); Log.d(TAG, "INSIDE: onStop"); } @Override protected void onDestroy() { super.onDestroy(); Log.d(TAG, "INSIDE: onDestroy"); } @Override protected void onPause() { super.onPause(); Log.d(TAG, "INSIDE: onPause"); } @Override protected void onResume() { super.onResume(); Log.d(TAG, "INSIDE: onResume"); } } 

@ user3282164 De acuerdo con el ciclo de vida de la actividad , debe pasar por onPause() -> onStop() -> onDestroy() al llamar a finish() .

El diagtwig no muestra ninguna ruta recta desde [Actividad en ejecución] a [ onDestroy() ] causada por el sistema.

El documento onStop () dice: ” Tenga en cuenta que nunca se puede llamar a este método, en situaciones de poca memoria donde el sistema no tiene suficiente memoria para mantener el proceso de su actividad ejecutándose después de llamar a su método onPause ().

Mi estudio muestra que el método finish() realmente coloca algunas operaciones de destrucción en la cola, pero la Actividad no se destruye inmediatamente. La destrucción está progtwigda sin embargo.

Por ejemplo, si coloca finish() en la callback de onActivityResult() , mientras onResume() aún no se ha ejecutado, se ejecutará primero onResume() y solo después de que se onStop() y onDestroy() .

NOTA: onDestroy() no se puede llamar en absoluto, como se indica en la documentación .

al finalizar la llamada en onCreate () no se llamará a onDestroy () directamente como dijo @prakash. La operación finish() ni siquiera comenzará hasta que devuelva el control a Android.

Llamar a finish () en onCreate () : onCreate () -> onStart () -> onResume () . Si el usuario sale de la aplicación, llamará a -> onPause () -> onStop () -> onDestroy ()

Llamar a finish () en onStart () : onCreate () -> onStart () -> onStop () -> onDestroy ()

Llamar a finish () en onResume () : onCreate () -> onStart () -> onResume () -> onPause () -> onStop () -> onDestroy ()

Para obtener más información, consulte el siguiente oncreate continuous after finish & about finish ()

Además de @rommex respuesta anterior, también he notado que finish() pone en cola la destrucción de la actividad y que depende de la prioridad de la actividad.

Si llamo a finish() después de onPause() , veo onStop() y onDestroy() llamados inmediatamente.

Si llamo a finish() después de onStop() , no veo onDestroy() hasta 5 minutos después.

Según mi observación, parece que el final está en cola y cuando miré las adb shell dumpsys activity activities , se estableció en finishing=true , pero como ya no está en primer plano, no se priorizó su destrucción.

En resumen, nunca se garantiza que onDestroy() , pero incluso en el caso de que se llame, podría retrasarse.

Parece que la única respuesta correcta aquí hasta el momento ha sido dada por romnex: “onDestroy () no se puede llamar en absoluto”. Aunque en la práctica, en casi todos los casos, no hay garantía: la documentación sobre el acabado () solo promete que el resultado de la actividad se propaga nuevamente a la persona que llama, pero nada más. Además, la documentación del ciclo de vida aclara que el OS puede cancelar la actividad tan pronto como finalice onStop () (o incluso antes en dispositivos más antiguos), lo que, aunque poco probable y por lo tanto poco frecuente en una prueba simple, puede significar que la actividad puede ser asesinado mientras o incluso antes de que se ejecute onDestroy ().

Por lo tanto, si desea asegurarse de que haya terminado algún trabajo cuando llame a finish (), no podrá ponerlo en Destroy (), pero tendrá que hacerlo en el mismo lugar donde llama a finish (), justo antes de llamarlo.

finish () simplemente envía de vuelta a la actividad anterior en Android, o puede decir que se está dando un paso atrás en la aplicación

    Intereting Posts