android - una - protected void oncreate bundle savedinstancestate

Ciclo de vida de la actividad de Android: ¿para qué sirven todos estos métodos?

Question

¿Cuál es el ciclo de vida de una actividad de Android? ¿Por qué se onCreate() tantos métodos de sondeo similares ( onCreate() , onStart() , onResume() ) durante la inicialización y tantos otros ( onPause() , onStop() , onDestroy() ) al final?

¿Cuándo se llaman estos métodos y cómo deben usarse correctamente?

Answer 1

Agregar más información en la parte superior de la respuesta altamente calificada (Se agregó una sección adicional de KILLABLE y el siguiente conjunto de métodos, que se llamarán en el ciclo de vida):

Fuente: developer.android.com

Tenga en cuenta la columna " Acumulativo " en la tabla anterior: para aquellos métodos que están marcados como desechables, después de que el método devuelva el proceso que aloja la actividad, el sistema puede cancelarlo en cualquier momento sin que se ejecute otra línea de su código.

Debido a esto, debe usar el método onPause() para escribir cualquier dato persistente (como las ediciones del usuario) en el almacenamiento. Además, se llama al método onSaveInstanceState(Bundle) antes de colocar la actividad en ese estado de fondo, lo que le permite guardar cualquier estado de instancia dinámica de su actividad en el Bundle dado, para luego recibirlo en onCreate(Bundle) si la actividad necesita ser recreado

Tenga en cuenta que es importante guardar datos persistentes en onPause() lugar de onSaveInstanceState(Bundle) porque este último no forma parte de las devoluciones de llamada del ciclo de vida, por lo que no se llamará en todas las situaciones como se describe en su documentación.

Me gustaría añadir algunos métodos más. Estos no están listados como métodos de ciclo de vida, pero se llamarán durante el ciclo de vida dependiendo de algunas condiciones. Dependiendo de sus requisitos, es posible que tenga que implementar estos métodos en su aplicación para un manejo adecuado del estado.

onPostCreate(Bundle savedInstanceState)

Se llama cuando se completa el inicio de la actividad (después de haber onStart() y onRestoreInstanceState(Bundle) ).

onPostResume()

Se llama cuando se completa la reanudación de la actividad (después de onResume() llamado a onResume() ).

onSaveInstanceState(Bundle outState)

Llamado para recuperar el estado por instancia de una actividad antes de onCreate(Bundle) para que el estado se pueda restaurar en onCreate(Bundle) o onRestoreInstanceState(Bundle) (el Bundle completado por este método se pasará a ambos).

onRestoreInstanceState(Bundle savedInstanceState)

Este método se llama después de onStart() cuando la actividad se está reinicializando desde un estado guardado anteriormente, que se savedInstanceState aquí en savedInstanceState .

Mi código de aplicación utilizando todos estos métodos:

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    private EditText txtUserName;
    private EditText txtPassword;
    Button  loginButton;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d("Ravi","Main OnCreate");
        txtUserName=(EditText) findViewById(R.id.username);
        txtPassword=(EditText) findViewById(R.id.password);
        loginButton =  (Button)  findViewById(R.id.login);
        loginButton.setOnClickListener(this);

    }

    @Override
    public void onClick(View view) {
        Log.d("Ravi", "Login processing initiated");
        Intent intent = new Intent(this,LoginActivity.class);
        Bundle bundle = new Bundle();
        bundle.putString("userName",txtUserName.getText().toString());
        bundle.putString("password",txtPassword.getText().toString());
        intent.putExtras(bundle);
        startActivityForResult(intent,1);
       // IntentFilter
    }
    public void onActivityResult(int requestCode, int resultCode, Intent resIntent){
        Log.d("Ravi back result:", "start");
        String result = resIntent.getStringExtra("result");
        Log.d("Ravi back result:", result);
        TextView txtView = (TextView)findViewById(R.id.txtView);
        txtView.setText(result);

        Intent sendIntent = new Intent();
        //sendIntent.setPackage("com.whatsapp");
        sendIntent.setAction(Intent.ACTION_SEND);
        sendIntent.putExtra(Intent.EXTRA_TEXT, "Message...");
        sendIntent.setType("text/plain");
        startActivity(sendIntent);
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d("Ravi","Main Start");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d("Ravi","Main ReStart");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d("Ravi","Main Pause");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d("Ravi","Main Resume");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d("Ravi","Main Stop");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d("Ravi","Main OnDestroy");
    }

    @Override
    public void onPostCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
        super.onPostCreate(savedInstanceState, persistentState);
        Log.d("Ravi","Main onPostCreate");
    }

    @Override
    protected void onPostResume() {
        super.onPostResume();
        Log.d("Ravi","Main PostResume");
    }

    @Override
    public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {
        super.onSaveInstanceState(outState, outPersistentState);
    }

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

Actividad de inicio de sesión:

public class LoginActivity extends AppCompatActivity {

    private TextView txtView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        txtView = (TextView) findViewById(R.id.Result);
        Log.d("Ravi","Login OnCreate");
        Bundle bundle = getIntent().getExtras();
        txtView.setText(bundle.getString("userName")+":"+bundle.getString("password"));
        //Intent  intent = new Intent(this,MainActivity.class);
        Intent  intent = new Intent();
        intent.putExtra("result","Success");
        setResult(1,intent);
       // finish();
    }
}

salida: (antes de la pausa)

D/Ravi: Main OnCreate
D/Ravi: Main Start
D/Ravi: Main Resume
D/Ravi: Main PostResume

salida: (Después de reanudar desde pausa)

D/Ravi: Main ReStart
D/Ravi: Main Start
D/Ravi: Main Resume
D/Ravi: Main PostResume

Tenga en cuenta que onPostResume() se invoca aunque no se cita como método de ciclo de vida.

Answer 2

Comience desde lo básico Tengo muchos tutoriales relacionados con los componentes que tienen en cuenta el ciclo de vida ... usted aprende para el ciclo de vida a medida que su pregunta se https://www.youtube.com/watch?v=e-ews5dRMwI

Answer 3

Desde la página de desarrolladores de Android,

onPause ():

Se llama cuando el sistema está a punto de comenzar a reanudar una actividad anterior. Normalmente se usa para enviar cambios no guardados a datos persistentes, detener animaciones y otras cosas que pueden estar consumiendo CPU, etc. Las implementaciones de este método deben ser muy rápidas, ya que la siguiente actividad no se reanudará hasta que este método regrese. Seguido por onResume () si la actividad regresa al frente, o onStop () si se vuelve invisible para el usuario.

onStop ():

Se llama cuando la actividad ya no es visible para el usuario, porque se ha reanudado otra actividad y está cubriendo esta. Esto puede suceder ya sea porque se está iniciando una nueva actividad, se está llevando una existente frente a esta o se está destruyendo esta. Seguido de onRestart () si esta actividad vuelve a interactuar con el usuario, o onDestroy () si esta actividad va a desaparecer.

Ahora suponga que hay tres Actividades y usted va de A a B, luego se llamará a On Pausa de A ahora de B a C, luego se llamará a On Pausa de B y a On de Top de A.

La Actividad en pausa obtiene un Reanudar y Stopped se reinicia.

Cuando llame a this.finish() , se llamará onPause-onStop-onDestroy. Lo principal a recordar es: las actividades en pausa se detienen y la actividad se destruye cuando Android requiere memoria para otras operaciones.

Espero que esté lo suficientemente claro.

Answer 4

Me gusta esta pregunta y las respuestas a ella, pero hasta ahora no hay cobertura para devoluciones de llamadas de uso menos frecuente como onPostCreate () o onPostResume () . Steve Pomeroy ha intentado un diagrama que incluye estos y cómo se relacionan con el ciclo de vida del Fragmento de Android, en https://github.com/xxv/android-lifecycle . Revisé el diagrama grande de Steve para incluir solo la parte de la Actividad y lo formateé para una impresión de tamaño de carta de una página. Lo publiqué en formato PDF en https://github.com/code-read/android-lifecycle/blob/master/AndroidActivityLifecycle1.pdf y debajo está su imagen:

Answer 5

Toda la confusión se debe a que Google eligió nombres no intuitivos en lugar de algo como sigue:

onCreateAndPrepareToDisplay()   [instead of onCreate() ]
onPrepareToDisplay()            [instead of onRestart() ]
onVisible()                     [instead of onStart() ]
onBeginInteraction()            [instead of onResume() ]
onPauseInteraction()            [instead of onPause() ]
onInvisible()                   [instead of onStop]
onDestroy()                     [no change] 

El Diagrama de Actividad puede interpretarse como:

Answer 6

Véalo en Activity Lifecycle (en Android Developers).

onCreate() :

Se llama cuando se crea por primera vez la actividad. Aquí es donde debe hacer toda su configuración estática normal: crear vistas, vincular datos a listas, etc. Este método también le proporciona un Bundle que contiene el estado previamente congelado de la actividad, si lo hubiera. Siempre seguido por onStart ().

onRestart() :

Se llama después de que se haya detenido su actividad, antes de que se vuelva a iniciar. Siempre seguido por onStart ()

onStart() :

Se llama cuando la actividad se hace visible para el usuario. Seguido por onResume () si la actividad llega al primer plano, o onStop () si se oculta.

onResume() :

Llamado cuando la actividad comenzará a interactuar con el usuario. En este punto, su actividad se encuentra en la parte superior de la pila de actividades, con la participación del usuario. Siempre seguido de onPause ().

onPause () :

Llamado como parte del ciclo de vida de la actividad cuando una actividad pasa a un segundo plano, pero aún no se ha eliminado. La contraparte de onResume (). Cuando la actividad B se inicia al frente de la actividad A, esta devolución de llamada se invocará en A. B no se creará hasta que A on (Pausa) () regrese, así que asegúrese de no hacer nada largo aquí.

onStop() :

Llamado cuando ya no eres visible para el usuario. A continuación, recibirá onRestart (), onDestroy () o nada, dependiendo de la actividad posterior del usuario.

Tenga en cuenta que este método nunca se puede llamar, en situaciones de poca memoria donde el sistema no tiene suficiente memoria para mantener el proceso de su actividad en ejecución después de que se llame a su método onPause ().

onDestroy() :

La llamada final que recibes antes de que tu actividad sea destruida. Esto puede suceder ya sea porque la actividad está terminando (alguien llamado finish () en ella, o porque el sistema está destruyendo temporalmente esta instancia de la actividad para ahorrar espacio. Puede distinguir> estos dos escenarios con el método isFinishing ().

Cuando la Actividad se carga por primera vez, los eventos se llaman de la siguiente manera:

onCreate()
onStart()
onResume()

Cuando hace clic en el botón Teléfono, la Actividad pasa al fondo y se llaman los siguientes eventos:

onPause()
onStop()

Salga del marcador del teléfono y se llamarán los siguientes eventos:

onRestart()
onStart()
onResume()

Cuando hace clic en el botón Atrás O intenta terminar () la actividad, los eventos se llaman de la siguiente manera:

onPause()
onStop()
onDestroy()

Estados de actividad

El sistema operativo Android usa una cola de prioridad para ayudar a administrar las actividades que se ejecutan en el dispositivo. En función del estado en que se encuentre una determinada actividad de Android, se le asignará una cierta prioridad dentro del sistema operativo. Este sistema de prioridad ayuda a Android a identificar actividades que ya no están en uso, lo que permite que el sistema operativo recupere la memoria y los recursos. El siguiente diagrama ilustra los estados por los que puede pasar una actividad durante su vida útil:

Estos estados se pueden dividir en tres grupos principales de la siguiente manera:

Activo o en ejecución : las actividades se consideran activas o en ejecución si están en primer plano, también conocidas como la parte superior de la pila de actividades. Esto se considera la actividad de mayor prioridad en la pila de actividades de Android y, como tal, solo será eliminada por el sistema operativo en situaciones extremas, por ejemplo, si la actividad intenta usar más memoria de la que está disponible en el dispositivo, ya que esto podría hacer que la IU dejar de responder

En pausa : cuando el dispositivo entra en suspensión, o si una actividad sigue siendo visible pero está parcialmente oculta por una actividad nueva, no de tamaño completo o transparente, la actividad se considera en pausa. Las actividades en pausa siguen vivas, es decir, mantienen toda la información del estado y los miembros, y permanecen vinculadas al administrador de ventanas. Se considera que esta es la segunda actividad de mayor prioridad en la pila de actividades de Android y, como tal, solo la eliminará el sistema operativo si esta actividad satisface los requisitos de recursos necesarios para mantener la actividad activa / en ejecución estable y receptiva.

Detenidas : las actividades que están completamente ocultas por otra actividad se consideran detenidas o en segundo plano. Las actividades detenidas aún intentan retener su estado y la información de los miembros durante el mayor tiempo posible, pero se considera que las actividades detenidas son la prioridad más baja de los tres estados y, como tal, el sistema operativo eliminará primero las actividades en este estado para satisfacer los requisitos de recursos. de las actividades de mayor prioridad.

* Actividad de muestra para entender el ciclo de vida **.

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
public class MainActivity extends Activity {
    String tag = "LifeCycleEvents";
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.main);
       Log.d(tag, "In the onCreate() event");
    }
    public void onStart()
    {
       super.onStart();
       Log.d(tag, "In the onStart() event");
    }
    public void onRestart()
    {
       super.onRestart();
       Log.d(tag, "In the onRestart() event");
    }
    public void onResume()
    {
       super.onResume();
       Log.d(tag, "In the onResume() event");
    }
    public void onPause()
    {
       super.onPause();
       Log.d(tag, "In the onPause() event");
    }
    public void onStop()
    {
       super.onStop();
       Log.d(tag, "In the onStop() event");
    }
    public void onDestroy()
    {
       super.onDestroy();
       Log.d(tag, "In the onDestroy() event");
    }
}

Answer 7

Ciclo vital de androide

Hay siete métodos que administran el ciclo de vida de una aplicación de Android:

• onCreate()
• onStart()
• onResume()
• onRestart()
• en pausa ()
• onStop()
• onDestroy()

Responde para cuáles son todos estos métodos para:

Tomemos un escenario simple en el que saber en qué orden se llaman estos métodos nos ayudará a aclarar por qué se utilizan.

• Supongamos que está utilizando una aplicación de calculadora. Se llaman tres métodos sucesivos para iniciar la aplicación.

onCreate() - - -> onStart() - - -> onResume()

• Cuando estoy usando la aplicación de la calculadora, de repente una llamada llega al. La actividad de la calculadora pasa al fondo y otra actividad dice. Tratar con la llamada llega al primer plano, y ahora se llaman dos métodos en sucesión.

onPause() - - -> onStop()

• Ahora digamos que termino la conversación en el teléfono, la actividad de la calculadora se pone en primer plano desde el fondo, por lo que se llaman tres métodos sucesivamente.

onRestart() - - -> onStart() - - -> onResume()

• Finalmente, digamos que he terminado todas las tareas en la aplicación de la calculadora y quiero salir de la aplicación. Más adelante se llaman dos métodos sucesivos.

onStop() - - -> onDestroy()

Hay cuatro estados en los que puede existir una actividad:

• Estado de inicio
• Estado corriente
• Estado pausado
• Estado detenido

El estado inicial implica:

Creación de un nuevo proceso de Linux, asignación de nueva memoria para los nuevos objetos de la interfaz de usuario y configuración de la pantalla completa. Así que la mayor parte del trabajo está involucrado aquí.

El estado corriente implica:

Es la actividad (estado) que se encuentra actualmente en la pantalla. Este estado solo maneja cosas como escribir en la pantalla y tocar y hacer clic en los botones.

El estado pausado implica:

Cuando una actividad no está en primer plano y, en cambio, está en segundo plano, se dice que la actividad está en estado de pausa.

El estado detenido implica:

Una actividad detenida solo se puede comprar en primer plano reiniciándola y también se puede destruir en cualquier momento.

El administrador de actividades maneja todos estos estados de tal manera que la experiencia y el rendimiento del usuario son siempre los mejores, incluso en escenarios donde la nueva actividad se agrega a las actividades existentes.

Answer 8

La actividad tiene seis estados.

• Creado
• Empezado
• Reanudado
• En pausa
• Detenido
• Destruido

El ciclo de vida de la actividad tiene siete métodos.

• onCreate()
• onStart()
• onResume()
• onPause()
• onStop()
• onRestart()
• onDestroy()

Situaciones

• Al abrir la aplicación

  onCreate() --> onStart() -->  onResume()

• Cuando se presiona el botón Atrás y salir de la aplicación

  onPaused() -- > onStop() --> onDestory()

• Cuando se presiona el botón de inicio

  onPaused() --> onStop()

• Después de presionar el botón de inicio cuando vuelva a abrir la aplicación desde la lista de tareas recientes o haga clic en el icono

  onRestart() --> onStart() --> onResume()

• Al abrir una aplicación, otra aplicación desde la barra de notificaciones o la configuración abierta

  onPaused() --> onStop()

• El botón Atrás presionado desde otra aplicación o configuración que se utilice puede ver nuestra aplicación

  onRestart() --> onStart() --> onResume()

• Cuando se abre cualquier diálogo en pantalla.

  onPause()

• Después de descartar el diálogo o el botón Atrás del diálogo

  onResume()

• Cualquier teléfono está sonando y el usuario en la aplicación.

  onPause() --> onResume() 

• Cuando el usuario presiona el botón de respuesta del teléfono

  onPause()

• Después de la llamada final

  onResume()

• Cuando la pantalla del teléfono está apagada

  onPaused() --> onStop()

• Cuando la pantalla se vuelve a encender

  onRestart() --> onStart() --> onResume()