studio - regresar a un activity anterior android

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

Question

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 pila, 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á?

Answer 1

@ user3282164 De acuerdo con el ciclo de vida de la http://developer.android.com/reference/android/app/Activity.html , debe pasar por onPause() -> onStop() -> onDestroy() al llamar a finish() .

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

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 () " .

Answer 2

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

Answer 3

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 pila actual.

Answer 4

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á programada sin embargo.

Por ejemplo, si coloca finish() en la devolución de llamada 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 documentation .

Answer 5

Mis 2 centavos en la respuesta de @K_Anas. Realicé una prueba simple en el método finish (). Métodos de devolución de llamada 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()

Answer 6

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 documentation 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.

Answer 7

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

startActivity(intent);
finish();

Answer 8

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

}

Answer 9

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

Answer 10

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

Answer 11

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 programador 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.