Diferencia entre onStart () y onResume ()

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

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

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

De acuerdo, como mi primera respuesta fue bastante larga, no voy a extenderla más, así que probemos esto …

 public DriveToWorkActivity extends Activity implements onReachedGroceryStoreListener { } public GroceryStoreActivity extends Activity {} 

TEN EN CUENTA: he super.onCreate(...) deliberadamente las llamadas a cosas como super.onCreate(...) etc. Esto es un super.onCreate(...) así que dame alguna licencia artística aquí. 😉

Los métodos para DriveToWorkActivity siguen …

 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 otro largo (lo siento amigos). Pero aquí está mi explicación …

onResume() es cuando comienzo a conducir y onPause() es cuando llego a una parada temporal. Así que conduzco y luego alcanzo una luz roja, así que pause … la luz se pone verde y reanudo. Otra luz roja y yo pausa, luego verde, así que reanudo. El onPause() -> onResume() -> onPause() -> onResume() es estricto y ocurre muchas veces durante mi viaje.

El ciclo de detenerse de nuevo a través de un reinicio (prepararse para continuar mi viaje) para comenzar de nuevo es quizás menos común. En un caso, veo la tienda de ulttwigrinos y se inicia GroceryStoreActivity (obligando a DriveToWorkActivity al punto de onStop() ). Cuando regreso de la tienda, continúo onRestart() y onStart() luego onStart() mi viaje.

Podría poner el código que está en onStart() en onCreate() y onRestart() y no molestarme en anular onStart() pero es necesario hacer más entre onCreate() -> onResume() y onRestart() -> onResume() , más estoy duplicando cosas.

Entonces, para volver a realizar una …

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

Si no anula onStart() entonces esto es efectivamente lo que sucede. Aunque el método de Activity onStart() se 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 no puede “interactuar” con ella, aunque puede estar superpuesto con algún otro diálogo pequeño. 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 vidrio. Puedes ver a la persona pero no puedes interactuar (hablar / escuchar / darle la mano) con él. OnResume es como el abridor de puerta después del cual puedes comenzar la interacción.

Además onRestart () es el menos entendido. 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 llevan a onStart () (es decir, la actividad se vuelve visible). Entonces 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 pueden 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 algo de la siguiente manera:

 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 diagtwig de actividad puede interpretarse como:

Ciclo de vida de actividad de Android

onStart() llamado 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 este caso.

Vea este enlace para referencia.

onResume() se llama:

  1. después de onStart()
  2. cuando la Activity llega al primer plano.

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

El libro “Hola, Android, Introducción a la plataforma de desarrollo móvil de Google” ofrece 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 los principiantes de Android!

Un ejemplo particularmente agresivo es cuando decide mostrar un diálogo gestionado desde una actividad usando showDialog() . Si el usuario gira la pantalla mientras el cuadro de diálogo aún está abierto (a esto lo llamamos “cambio de configuración”), la actividad principal pasará por todas las llamadas al ciclo de vida de finalización hasta onDestroy() , se recreará y volverá a subir los ciclos de vida Sin embargo, lo que no puede esperar es que onCreateDialog() y onPrepareDialog() (los métodos que se showDialog() cuando se showDialog() y ahora nuevamente para recrear automáticamente el diálogo, ya que es un diálogo administrado) se llamen onStart() y onResume() . La sugerencia 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. Se invoca después de onCreate (Bundle) o después de onReestart () seguido de onResume () .
  2. puede registrar un BroadcastReceiver en onStart() para monitorear los cambios que afectan su UI, debe anular el registro en onStop ()
  3. Las clases derivadas deben pasar 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 deRestoreInstanceState (Bundle), onRestart () o onPause ()
  2. Comience animaciones, abra dispositivos de acceso exclusivo (como la cámara)

onStart() normalmente envía trabajo a una onStart() fondo, cuyos valores de retorno son:

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

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

onResume() es invocado por el sistema operativo después de que el dispositivo se onResume() 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 campos (dentro de una estructura de prueba con un captura de excepciones). Tal situación no provoca que onStop() se invoque cuando el niño se 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

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

Resume() significa que ahora puede 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 penosamente descubrí.

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

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

onResume() llama justo antes de que la actividad comience a interactuar con el usuario. En este punto, la actividad se encuentra en la parte superior de la stack de actividades, con la entrada del usuario. Siempre seguido de onPause() .

onPause() Se onPause() 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 consumir CPU, y así sucesivamente. Debería hacer lo que haga muy rápidamente, porque la próxima actividad no se reanudará hasta que vuelva. Seguido por onResume() si la actividad vuelve al frente, o por onStop() si se vuelve invisible para el usuario.

Esperemos una explicación simple:

onStart () -> llamado cuando la actividad se vuelve 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.