Différence entre onStart () et onResume ()

Je ne peux pas comprendre la signification de l' onStart()état de transition. La onResume()méthode est toujours appelée après onStart(). Pourquoi ne peut-il pas être onResume()invoqué après onRestart()et les onCreate()méthodes excluant simplement onStart()? Quel est son objectif?

Pourquoi ne pouvons-nous pas vivre sans onStart(). Je le considère toujours comme redondant (probablement parce que je ne comprends pas complètement sa signification).

Pourquoi est-ce que onResume () est invoqué après les méthodes onRestart () et onCreate () en excluant simplement onStart ()? Quel est son objectif?

OK, comme ma première réponse a été assez longue, je ne vais pas l'étendre davantage, alors essayons ceci ...

public DriveToWorkActivity extends Activity
    implements onReachedGroceryStoreListener {
}

public GroceryStoreActivity extends Activity {}

VEUILLEZ NOTER: J'ai délibérément laissé de côté les appels à des choses comme super.onCreate(...)etc. C'est un pseudo-code alors donnez-moi une licence artistique ici. ;)

Les méthodes pour DriveToWorkActivitysuivre ...

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, donc c'est un autre long (désolé les gens). Mais voici mon explication ...

onResume()c'est quand je commence à conduire et onPause()c'est quand je m'arrête temporairement. Alors je roule puis j'atteins un feu rouge donc je m'arrête ... le feu passe au vert et je reprends. Encore un feu rouge et je m'arrête, puis vert donc je reprends. La onPause() -> onResume() -> onPause() -> onResume()boucle est serrée et se produit plusieurs fois au cours de mon voyage.

La boucle entre l'arrêt du retour par un redémarrage (se préparer à poursuivre mon voyage) et le redémarrage est peut-être moins courante. Dans un cas, je repère l'épicerie et le GroceryStoreActivitydémarre (me forçant DriveToWorkActivityau point de onStop()). Quand je reviens du magasin, je passe onRestart()et onStart()je reprends mon voyage.

Je pourrais mettre le code qui est onStart()dans les deux onCreate()et onRestart()sans prendre la peine de remplacer onStart()du tout, mais plus il y a de choses à faire entre onCreate() -> onResume()et onRestart() -> onResume(), plus je duplique les choses.

Alors, pour recommencer une fois de plus ...

Pourquoi est-ce que onResume () est invoqué après les méthodes onRestart () et onCreate () en excluant simplement onStart ()?

Si vous ne remplacez pas, onStart()c'est effectivement ce qui se passe. Bien que la onStart()méthode de Activitysoit appelée implicitement, l'effet dans votre code est effectivement onCreate() -> onResume()ou onRestart() -> onResume().

Réponse courte:

Nous ne pouvons pas vivre sans onStart car c'est l'état où l'activité devient «visible» pour l'utilisateur, mais l'utilisateur ne peut pas encore «interagir» avec elle peut être parce qu'elle se chevauche avec une autre petite boîte de dialogue. Cette capacité à interagir avec l'utilisateur est celle qui différencie onStart et onResume. Pensez-y comme une personne derrière une porte vitrée. Vous pouvez voir la personne mais vous ne pouvez pas interagir (parler / écouter / serrer la main) avec elle. OnResume est comme l'ouvre-porte après lequel vous pouvez commencer l'interaction.

De plus, onRestart () est le moins compris. On peut se poser la question de savoir pourquoi ne pas aller directement à onStart () ou onResume () après onStop () au lieu de onRestart (). Cela devient plus facile à comprendre si l'on remarque que onRestart () est partiellement équivalent à onCreate () si la partie création est omise. Fondamentalement, les deux états mènent à onStart () (c'est-à-dire que l'activité devient visible). Les deux états doivent donc «préparer» les éléments à afficher. OnCreate a la responsabilité supplémentaire de «créer» les éléments à afficher

Ainsi, leurs structures de code pourraient correspondre à quelque chose comme:

onCreate()
{
     createNecessaryObjects();

     prepareObjectsForDisplay();
}


onRestart()
{
     prepareObjectsForDisplay();

}

Toute la confusion est due au fait que Google a choisi des noms non intuitifs au lieu de quelque chose comme suit:

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] 

Le diagramme d'activités peut être interprété comme:

onStart() appelée lorsque l'activité devient visible pour l'utilisateur. onResume()appelée lorsque l'activité commencera à interagir avec l'utilisateur. Vous voudrez peut-être faire des choses différentes dans ce cas.

Voir ce lien pour référence.

onResume() est appelé:

1. après onStart()
2. quand Activityvient au premier plan.

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

Le livre "Bonjour, Android, Présentation de la plate-forme de développement mobile de Google" donne une belle explication du cycle de vie des applications Android. Heureusement, ils ont le chapitre en ligne en tant qu'extrait. Voir le graphique à la page 39 sur http://media.pragprog.com/titles/eband3/concepts.pdf

Au fait, ce livre est fortement recommandé pour les débutants Android!

Un exemple particulièrement fougueux est lorsque vous décidez d'afficher une boîte de dialogue gérée à partir d'une activité à l'aide de showDialog(). Si l'utilisateur fait pivoter l'écran alors que la boîte de dialogue est toujours ouverte (nous appelons cela un «changement de configuration»), alors l'activité principale passera par tous les appels de fin de cycle de vie jusqu'à onDestroy(), sera recréée et remontera à travers les cycles de vie. Ce à quoi vous ne vous attendez peut-être pas, cependant, c'est que onCreateDialog()et onPrepareDialog()(les méthodes qui sont appelées quand vous le faites showDialog()et maintenant à nouveau automatiquement pour recréer la boîte de dialogue - automatiquement car il s'agit d'une boîte de dialogue gérée) sont appelées entre onStart() et onResume(). Le point ici est que la boîte de dialogue ne couvre pas le plein écran et laisse donc une partie de l'activité principale visible. C'est un détail mais ça compte!

onStart()

1. Appelé après onCreate (Bundle) ou après onRestart () suivi de onResume () .
2. vous pouvez enregistrer un BroadcastReceiver onStart()pour surveiller les changements qui ont un impact sur votre interface utilisateur, vous devez le désinscrire dans onStop ()
3. Les classes dérivées doivent appeler l'implémentation de cette méthode par la super classe. Si ce n'est pas le cas, une exception sera levée.

onResume()

1. Appelé après onRestoreInstanceState (Bundle), onRestart () ou onPause ()
2. Commencer les animations, ouvrir les appareils à accès exclusif (comme la caméra)

onStart() normalement distribuer le travail à un thread d'arrière-plan, dont les valeurs de retour sont:

• START_STICKY pour redémarrer automatiquement en cas de mort, pour le maintenir actif.

• START_REDELIVER_INTENT pour le redémarrage automatique et réessayer si le service a été tué avant stopSelf ().

onResume()est appelée par le système d'exploitation après la mise en veille de l'appareil ou après qu'une alerte ou une autre activité enfant en écran partiel laisse une partie de la fenêtre précédente visible, une méthode doit donc réinitialiser les champs (dans une structure try avec une capture d'exceptions ). Une telle situation ne provoque pas onStop()d'être invoquée lorsque l'enfant se ferme.

onResume()est appelé sans onStart()lorsque l'activité reprend à partir de l'arrière-plan

Pour plus de détails, vous pouvez visiter Android_activity_lifecycle_gotcha et cycle de vie des activités

Espérons une explication simple: -

onStart () -> appelé lorsque l'activité devient visible, mais peut ne pas être au premier plan (par exemple, un AlertFragment est en haut ou tout autre cas d'utilisation possible).

onResume () -> appelé lorsque l'activité est au premier plan, ou que l'utilisateur peut interagir avec l'activité.

onStart()signifie Activityentré dans l'état visible et la mise en page est créée mais ne peut pas interagir avec cette mise en page d'activité.

Resume() signifie maintenant que vous pouvez interagir avec la mise en page des activités.

Notez qu'il y a des choses qui se produisent entre les appels à onStart () et onResume (). À savoir, onNewIntent (), que j'ai douloureusement découvert.

Si vous utilisez l'indicateur SINGLE_TOP et que vous envoyez des données à votre activité, en utilisant des extras d'intention, vous ne pourrez y accéder que dans onNewIntent (), qui est appelé après onStart () et avant onResume (). Donc, généralement, vous prendrez les nouvelles données (peut-être seulement modifiées) des extras et les définirez sur certains membres de la classe, ou utilisez setIntent () pour définir la nouvelle intention comme intention d'activité d'origine et traiter les données dans onResume ().

Référence à http://developer.android.com/training/basics/activity-lifecycle/starting.html

onResume()Appelé juste avant que l'activité ne commence à interagir avec l'utilisateur. À ce stade, l'activité se trouve en haut de la pile d'activités, avec les entrées de l'utilisateur. Toujours suivi par onPause().

onPause()Appelé lorsque le système est sur le point de reprendre une autre activité. Cette méthode est généralement utilisée pour valider des modifications non enregistrées sur des données persistantes, arrêter des animations et d'autres choses qui peuvent consommer du processeur, etc. Il doit faire tout ce qu'il fait très rapidement, car la prochaine activité ne reprendra qu'au retour. Suivi soit par onResume()si l'activité revient au premier plan, soit par onStop()si elle devient invisible pour l'utilisateur.

Je ne sais pas si cela compte comme une réponse - mais voici la vidéo YouTube du cours de Google (Développement d'applications Android avec Kotlin) qui explique la différence.

• On Start est appelé lorsque l'activité devient visible
• On Pause est appelé lorsque l'activité perd le focus (comme une boîte de dialogue apparaît)
• On Resume est appelé lorsque l'activité obtient le focus (comme lorsqu'une boîte de dialogue disparaît)