Diferencia entre onStart () y onResume ()

No puedo entender el significado del onStart()estado de transición. El onResume()método siempre se llama después onStart(). ¿Por qué no se puede onResume()invocar después onRestart()y los onCreate()métodos simplemente se excluyen onStart()? ¿Cual es su propósito?

¿Por qué no podemos vivir sin él onStart()? Todavía lo considero redundante (probablemente porque no entiendo su significado por completo).

¿Por qué no puede ser que se invoque onResume () después de que los métodos onRestart () y onCreate () solo excluyan onStart ()? ¿Cual es su propósito?

OK, como mi primera respuesta fue bastante larga, no la extenderé más, así que intentemos esto ...

public DriveToWorkActivity extends Activity
    implements onReachedGroceryStoreListener {
}

public GroceryStoreActivity extends Activity {}

TENGA EN CUENTA: he omitido deliberadamente las llamadas a cosas como super.onCreate(...)etc. Esto es un seudocódigo, así que deme una licencia artística aquí. ;)

Los métodos a DriveToWorkActivityseguir ...

protected void onCreate(...) {
    openGarageDoor();
    unlockCarAndGetIn();
    closeCarDoorAndPutOnSeatBelt();
    putKeyInIgnition();
}

protected void onStart() {
    startEngine();
    changeRadioStation();
    switchOnLightsIfNeeded();
    switchOnWipersIfNeeded();
}

protected void onResume() {
    applyFootbrake();
    releaseHandbrake();
    putCarInGear();
    drive();
}

protected void onPause() {
    putCarInNeutral();
    applyHandbrake();
}

protected void onStop() {
    switchEveryThingOff();
    turnOffEngine();
    removeSeatBeltAndGetOutOfCar();
    lockCar();
}

protected void onDestroy() {
    enterOfficeBuilding();
}

protected void onReachedGroceryStore(...) {
    Intent i = new Intent(ACTION_GET_GROCERIES, ...,  this, GroceryStoreActivity.class);
}

protected void onRestart() {
    unlockCarAndGetIn();
    closeDoorAndPutOnSeatBelt();
    putKeyInIgnition();
}

OK, entonces es otra larga (lo siento amigos). Pero aquí está mi explicación ...

onResume()es cuando empiezo a conducir y onPause()es cuando llego a una parada temporal. Entonces conduzco y luego alcanzo una luz roja, así que me detengo ... la luz se pone verde y reanudo. Otra luz roja y me detengo, luego verde, así que reanudo. El onPause() -> onResume() -> onPause() -> onResume()ciclo es apretado y ocurre muchas veces durante mi viaje.

El bucle desde que se detiene de nuevo a través de un reinicio (preparación para continuar mi viaje) para comenzar de nuevo es quizás menos común. En un caso, veo la tienda de comestibles y GroceryStoreActivityse inicia (forzándome DriveToWorkActivityal punto de onStop()). Cuando regreso de la tienda, paso onRestart()y onStart()luego reanudo mi viaje.

Podría poner el código que está en onStart()ambos onCreate()y onRestart()no molestarme en anularlo, onStart()pero cuanto más se deba hacer entre onCreate() -> onResume()y onRestart() -> onResume(), más duplicaré las cosas.

Entonces, para volver a cotizar una vez más ...

¿Por qué no puede ser que se invoque onResume () después de que los métodos onRestart () y onCreate () solo excluyan onStart ()?

Si no anula, onStart()entonces esto es efectivamente lo que sucede. Aunque el onStart()método de Activityse llamará implícitamente, el efecto en su código es efectivamente onCreate() -> onResume()o onRestart() -> onResume().

Respuesta corta:

No podemos vivir sin onStart porque ese es el estado en el que la actividad se vuelve "visible" para el usuario, pero el usuario aún no puede "interactuar" con ella porque puede estar solapada con algún otro pequeño diálogo. Esta capacidad de interactuar con el usuario es la que diferencia onStart y onResume. Piense en ello como una persona detrás de una puerta de cristal. Puedes ver a la persona pero no puedes interactuar (hablar / escuchar / darle la mano) con ella. OnResume es como el abridor de puerta después del cual puede comenzar la interacción.

Además, onRestart () es el menos comprendido. Podemos hacernos la pregunta de por qué no ir directamente a onStart () o onResume () después de onStop () en lugar de onRestart (). Se vuelve más fácil de entender si notamos que onRestart () es parcialmente equivalente a onCreate () si se omite la parte de creación. Básicamente, ambos estados conducen a onStart () (es decir, la actividad se hace visible). Así que ambos estados tienen que "preparar" las cosas que se mostrarán. OnCreate tiene la responsabilidad adicional de "crear" las cosas que se mostrarán

Entonces sus estructuras de código podrían ajustarse a algo como:

onCreate()
{
     createNecessaryObjects();

     prepareObjectsForDisplay();
}


onRestart()
{
     prepareObjectsForDisplay();

}

Toda la confusión se debe a que Google eligió nombres no intuitivos en lugar de los siguientes:

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 podría interpretarse como:

onStart()se llama cuando la actividad se vuelve visible para el usuario. onResume()llamado cuando la actividad comenzará a interactuar con el usuario. Es posible que desee hacer cosas diferentes en estos casos.

Vea este enlace para referencia.

onResume() se llama:

1. después onStart()
2. cuando Activityviene al primer plano.

Desde http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle :

El libro "Hola, Android, presentando la plataforma de desarrollo móvil de Google" da una buena explicación del ciclo de vida de las aplicaciones de Android. Afortunadamente, tienen el capítulo particular en línea como un extracto. Vea el gráfico en la página 39 en http://media.pragprog.com/titles/eband3/concepts.pdf

Por cierto, este libro es muy recomendable para principiantes de Android.

Un ejemplo particularmente intenso es cuando decides mostrar un Diálogo administrado desde una Actividad usando showDialog(). Si el usuario gira la pantalla mientras el cuadro de diálogo aún está abierto (lo llamamos "cambio de configuración"), la Actividad principal pasará por todas las llamadas de ciclo de vida hasta el final onDestroy(), se volverá a crear y volverá a subir a través de los ciclos de vida. Sin embargo, es posible que no espere eso onCreateDialog()y onPrepareDialog()(los métodos que se llaman cuando lo hace showDialog()y ahora de nuevo automáticamente para recrear el diálogo, automáticamente ya que es un diálogo administrado) se llaman entre onStart() y onResume(). El punto aquí es que el diálogo no cubre la pantalla completa y, por lo tanto, deja visible parte de la actividad principal. ¡Es un detalle pero sí importa!

onStart()

1. Llamado después de onCreate (Bundle) o después de onRestart () seguido de onResume () .
2. puede registrar un BroadcastReceiver onStart()para monitorear los cambios que afectan su interfaz de usuario, debe cancelar su registro en onStop ()
3. Las clases derivadas deben llamar a la implementación de este método por parte de la superclase. Si no lo hacen, se lanzará una excepción.

onResume()

1. Llamado después de onRestoreInstanceState (Bundle), onRestart () o onPause ()
2. Comience las animaciones, abra los dispositivos de acceso exclusivo (como la cámara)

onStart() normalmente despacha el trabajo a un subproceso en segundo plano, cuyos valores de retorno son:

• START_STICKY para reiniciar automáticamente si se mata, para mantenerlo activo.

• START_REDELIVER_INTENT para reinicio automático y vuelva a intentar si el servicio se eliminó antes de stopSelf ().

onResume()el sistema operativo lo llama después de que el dispositivo se pone en suspensión o después de que una alerta u otra actividad secundaria de pantalla parcial deja visible una parte de la ventana anterior, por lo que es necesario reiniciar los campos (dentro de una estructura de prueba con una captura de excepciones) ) Tal situación no hace onStop()que se invoque cuando el niño cierra.

onResume()se llama sin onStart()cuando la actividad se reanuda desde el fondo

Para obtener más detalles, puede visitar Android_activity_lifecycle_gotcha y Activity Lifecycle

Ojalá una explicación simple: -

onStart () -> llamado cuando la actividad se hace visible, pero puede no estar en primer plano (por ejemplo, un AlertFragment está en la parte superior o cualquier otro caso de uso posible).

onResume () -> llamado cuando la actividad está en primer plano, o el usuario puede interactuar con la Actividad.

onStart()significa que se Activityingresa en estado visible y se crea el diseño, pero no puede interactuar con este diseño de actividad.

Resume() significa que ahora puedes interactuar con el diseño de la actividad.

Tenga en cuenta que hay cosas que suceden entre las llamadas a onStart () y onResume (). A saber, onNewIntent (), que he descubierto dolorosamente.

Si está utilizando el indicador SINGLE_TOP y envía algunos datos a su actividad, utilizando intenciones adicionales, solo podrá acceder a él en onNewIntent (), que se llama después de onStart () y antes de onResume (). Por lo tanto, generalmente tomará los datos nuevos (tal vez solo modificados) de los extras y los configurará para algunos miembros de la clase, o usará setIntent () para establecer el nuevo intento como el intento de actividad original y procesar los datos en onResume ().

Referencia a http://developer.android.com/training/basics/activity-lifecycle/starting.html

onResume()Llamado justo antes de que la actividad comience a interactuar con el usuario. En este punto, la actividad está en la parte superior de la pila de actividades, con la entrada del usuario. Siempre seguido por onPause().

onPause()Se llama cuando el sistema está a punto de comenzar a reanudar otra actividad. Este método se usa generalmente para confirmar cambios no guardados en datos persistentes, detener animaciones y otras cosas que pueden estar consumiendo CPU, etc. Debe hacer lo que hace muy rápidamente, porque la próxima actividad no se reanudará hasta que regrese. Seguido ya sea onResume()si la actividad vuelve al frente o onStop()si se vuelve invisible para el usuario.

No estoy seguro de si esto cuenta como una respuesta, pero aquí está el video de YouTube del curso de Google (Desarrollo de aplicaciones de Android con Kotlin) que explica la diferencia.

• Al iniciar se llama cuando la actividad se hace visible
• En pausa se llama cuando la actividad pierde el foco (como un cuadro de diálogo emergente)
• Al reanudar se llama cuando la actividad se enfoca (como cuando desaparece un diálogo)