Differenza tra onStart () e onResume ()


176

Non riesco a ottenere il significato di onStart()stato di transizione. Il onResume()metodo viene sempre chiamato dopo onStart(). Perché non può essere l' onResume()invocato dopo onRestart()e i onCreate()metodi che si escludono onStart()? Qual è il suo scopo?

Perché non possiamo vivere senza onStart(). Lo considero ancora ridondante (probabilmente perché non ne capisco completamente il significato).


Cerca qui il ciclo di vita dell'applicazione: d.android.com/guide/topics/fundamentals.html
ykatchou,

Questa roba è facile. Prova a spiegare questo WITH Fragments, ora questa è la programmazione Android per te!
Scott Biggs,

Le risposte di seguito non hanno un codice reale con spiegazione. Questo è il codice che lo spiega con un frammento.
Atul,

Risposte:


306

Perché non può essere l'onResume () viene invocato dopo i metodi onRestart () e onCreate () escludendo solo onStart ()? Qual è il suo scopo?

OK, poiché la mia prima risposta è stata piuttosto lunga, non la estenderò ulteriormente, quindi proviamo questo ...

public DriveToWorkActivity extends Activity
    implements onReachedGroceryStoreListener {
}

public GroceryStoreActivity extends Activity {}

NOTA BENE: ho deliberatamente lasciato fuori le chiamate a cose come super.onCreate(...)ecc. Questo è pseudo-codice quindi dammi una licenza artistica qui. ;)

I metodi per DriveToWorkActivityseguire ...

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, quindi è un altro lungo (scusate gente). Ma ecco la mia spiegazione ...

onResume()è quando comincio a guidare ed onPause()è quando mi fermo temporaneamente. Quindi guido e poi raggiungo una luce rossa, quindi mi fermo ... la luce diventa verde e riprendo. Un'altra luce rossa e mi fermo, poi verde quindi riprendo. Il onPause() -> onResume() -> onPause() -> onResume()ciclo è stretto e si verifica molte volte durante il mio viaggio.

Il ciclo dall'essere fermato indietro attraverso un riavvio (preparandosi a continuare il mio viaggio) per ricominciare è forse meno comune. In un caso, individuo il negozio di alimentari e GroceryStoreActivityviene avviato (forzando il mio DriveToWorkActivityal punto di onStop()). Quando torno dal negozio, passo attraverso onRestart()e onStart()poi riprendo il mio viaggio.

Potrei mettere il codice che è onStart()in entrambi onCreate()e onRestart()e non preoccuparmi di ignorare onStart()affatto, ma più ciò che deve essere fatto tra onCreate() -> onResume()e onRestart() -> onResume(), più sto duplicando le cose.

Quindi, per requote ancora una volta ...

Perché non può essere l'onResume () viene invocato dopo i metodi onRestart () e onCreate () escludendo solo onStart ()?

Se non si esegue l'override, onStart()questo è effettivamente ciò che accade. Sebbene il onStart()metodo di Activityverrà chiamato implicitamente, l'effetto nel tuo codice è efficace onCreate() -> onResume()o onRestart() -> onResume().


Ciò implica che sia onCreate()e onRestart()avrebbe condiviso un sacco di codice comune, giusto?
Dheeraj Vepakomma,

1
@Dheeraj: No non necessariamente. Questo è uno pseudo codice e ha lo scopo di illustrare come utilizzare ogni fase del Activityciclo di vita. La fase di creazione onCreate(...)potrebbe fare molto quando si tratta di creare un'istanza dei membri dell'istanza (elementi dell'interfaccia utente, ecc.), Ma non è necessario un riavvio. In realtà molti Activitiesnon hanno davvero bisogno di implementare più di onCreate(...), onResume()e onPause()gli altri metodi sono disponibili per i casi in cui potresti dover fare altre cose e la chiave è capire dove inserire il codice.
Squonk,

1
Questo è il motivo per cui sono arrivato a odiare l'API di Android rispetto a iOS e persino a WP7 ... Ho realizzato un gioco che funziona su tutti e tre in C # e devo dire che sono davvero deluso da Google e Android. Sembra che manchino nel dipartimento di progettazione Lingua / API. Mi auguro che qualche altro rly Phone OS Linux prende il sopravvento, Cuz I votare per l'Open Source in generale ...
zezba9000

2
@ Tim: OK, escogita un design migliore. Come gestiresti uno scenario su un telefono cellulare quando qualcuno utilizza un'app (la tua app) e riceve improvvisamente una telefonata? Il progettista dell'app non chiama esplicitamente i Activitymetodi del ciclo di vita: è il sistema operativo Android che lo fa e lo fa in modo molto efficiente (supponendo che lo sviluppatore dell'app sappia cosa stanno facendo e anche i codici in modo efficiente). Se fai molto sviluppo Android, capirai perché le cose funzionano nel modo in cui funzionano - non è perfetto al 100% ma è abbastanza buono.
Squonk,

9
Penso che la risposta di Nilesh di seguito sia molto più chiara. La differenza chiave tra onStarte onResumeè quella di "visibilità" e "interazione dell'utente". Questa metafora della guida di un'auto è confusa e non molto utile.
KJ,

142

Risposta breve:

Non possiamo vivere senza onStart perché quello è lo stato in cui l'attività diventa "visibile" per l'utente, ma l'utente non può "interagire" con essa, ma potrebbe essere perché si sovrappone con qualche altra piccola finestra di dialogo. Questa capacità di interagire con l'utente è quella che differenzia onStart e onResume. Pensalo come una persona dietro una porta a vetri. Puoi vedere la persona ma non puoi interagire (parlare / ascoltare / stringere la mano) con lui. OnResume è come l'apriporta dopo il quale è possibile iniziare l'interazione.

Inoltre onRestart () è il meno compreso. Possiamo porre la domanda sul perché non andare direttamente su onStart () o onResume () dopo onStop () invece di onRestart (). Diventa più facile capire se notiamo che onRestart () è parzialmente equivalente a onCreate () se la parte di creazione viene omessa. Fondamentalmente entrambi gli stati portano a onStart () (ovvero l'attività diventa visibile). Quindi entrambi gli stati devono "preparare" le cose da mostrare. OnCreate ha la responsabilità aggiuntiva di "creare" i contenuti da visualizzare

Quindi le loro strutture di codice potrebbero adattarsi a qualcosa del tipo:

onCreate()
{
     createNecessaryObjects();

     prepareObjectsForDisplay();
}


onRestart()
{
     prepareObjectsForDisplay();

}

L'intera confusione è causata dal fatto che Google ha scelto nomi non intuitivi anziché qualcosa come segue:

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] 

Il diagramma delle attività potrebbe essere interpretato come:

Ciclo di vita delle attività Android


4
Quando lo spiego agli studenti, uso forseOnInvisible () invece di onStop (). E usa forseOnDestroy () invece di onDestroy (). Questi nomi funzionano bene come spiegazioni che trovo. Pensavo che non avrei voluto che Google cambiasse davvero con questi nomi.
Stephan Branczyk il

Mi piacciono i tuoi nomi suggeriti, aiutano a dare un senso a questa parte della ridicola API di Android. Ho ancora una domanda in generale sul ciclo di vita. In tutti i diagrammi mostra che c'è un percorso da onPause direttamente a onResume. Non credo di aver mai visto quel percorso effettivamente seguito in ogni caso. Prende sempre il percorso da onStop a onStart. Cosa potrebbe innescare l'altro percorso?
Dewey Vozel,

@StephanBranczyk perché usi forse ... ()? Perchè forse"?
Marian Paździoch,

1
@Damnum, Per la spiegazione più recente del ciclo di vita delle attività, ti suggerisco di dare un'occhiata al corso intermedio Android Udacity creato da Google. È gratuito, supponendo che tu faccia clic sul pulsante blu per accedere ai suoi materiali gratuitamente e non sul pulsante di prova (né sul pulsante nanodegree). udacity.com/course/developing-android-apps--ud853
Stephan Branczyk

1
@Damnum, ti suggerirei di porre quella domanda nel forum di udacity in relazione al video che hai guardato. Ma fondamentalmente, penso che dipenda dalla finestra di dialogo utilizzata, che si tratti di un'attività di dialogo o solo di un dialogo.
Stephan Branczyk,

29

onStart()chiamato quando l'attività sta diventando visibile all'utente. onResume()chiamato quando l'attività inizierà a interagire con l'utente. In questi casi potresti voler fare diverse cose.

Vedi questo link per riferimento.



10

Il libro "Ciao, Android, Presentazione della piattaforma di sviluppo mobile di Google" offre una bella spiegazione del ciclo di vita delle app Android. Fortunatamente hanno il capitolo particolare online come estratto. Vedi il grafico a pagina 39 in http://media.pragprog.com/titles/eband3/concepts.pdf

A proposito, questo libro è altamente raccomandato per i principianti Android!


2
Bella immagine e buon libro, ma ancora non dà una risposta perché abbiamo davvero bisogno del metodo onStart () e quali cose speciali che possiamo fare in esso non possiamo fare in onResume ().
Eugene,

8
onStart () NON viene chiamato, se l'app è stata messa in pausa. L'app viene "messa in pausa" se un'altra app si concentra ma NON oscura completamente l'app. Quindi puoi fare cose diverse nello stato "in pausa" rispetto a come faresti nello stato "Interrotto". Pertanto, puoi fare cose diverse se la tua app viene "ripresa" dallo stato di pausa rispetto a quella che faresti se la tua app viene "avviata" dallo stato di arresto o dall'inizio completo. Questo aiuta?
Martin Booka Weser,

7

Un esempio particolarmente esagerato è quando si decide di mostrare una finestra di dialogo gestita da un'attività mediante showDialog(). Se l'utente ruota lo schermo mentre la finestra di dialogo è ancora aperta (la chiamiamo "modifica della configurazione"), l'attività principale passerà attraverso tutte le chiamate del ciclo di vita finale fino a quando onDestroy()non verrà ricreata, e tornerà indietro attraverso i cicli di vita. Ciò che potresti non aspettarti, tuttavia, è che onCreateDialog()e onPrepareDialog()(i metodi che vengono chiamati quando lo fai showDialog()e ora di nuovo automaticamente per ricreare la finestra di dialogo - automaticamente poiché si tratta di una finestra di dialogo gestita) vengono chiamati tra onStart() e onResume(). Il punto qui è che la finestra di dialogo non copre l'intero schermo e quindi rende visibile parte dell'attività principale. È un dettaglio ma è importante!


7

onStart()

  1. Chiamato dopo onCreate (Bundle) o dopo onRestart () seguito da onResume () .
  2. puoi registrare un BroadcastReceiver onStart()per monitorare le modifiche che influiscono sulla tua UI, devi annullare la registrazione in onStop ()
  3. Le classi derivate devono richiamare l'implementazione di questo metodo da parte della super classe. In caso contrario, verrà generata un'eccezione.

onResume()

  1. Chiamato dopo onRestoreInstanceState (Bundle), onRestart () o onPause ()
  2. Inizia animazioni, apri dispositivi ad accesso esclusivo (come la videocamera)

onStart() normalmente invia il lavoro a un thread in background, i cui valori di ritorno sono:

  • START_STICKY per riavviare automaticamente se ucciso, per mantenerlo attivo.

  • START_REDELIVER_INTENT per il riavvio automatico e riprovare se il servizio è stato interrotto prima di stopSelf ().

onResume()viene chiamato dal sistema operativo dopo che il dispositivo è in modalità sospensione o dopo che un avviso o un'altra attività figlio a schermo parziale lascia visibile una parte della finestra precedente, quindi è necessario un metodo per reinizializzare i campi (all'interno di una struttura di prova con una cattura di eccezioni ). Una situazione del genere non può onStop()essere invocata alla chiusura del bambino.

onResume()viene chiamato senza onStart()quando l'attività riprende dallo sfondo

Per maggiori dettagli puoi visitare Android_activity_lifecycle_gotcha e il ciclo di vita delle attività


in realtà mi fermo quando la mia app passa in background
deadfish

5

Speriamo che una semplice spiegazione: -

onStart () -> chiamato quando l'attività diventa visibile, ma potrebbe non essere in primo piano (ad es. un AlertFragment è in primo piano o qualsiasi altro possibile caso d'uso).

onResume () -> chiamato quando l'attività è in primo piano o l'utente può interagire con l'attività.


4

onStart()significa che è Activityentrato nello stato visibile e il layout è stato creato ma non può interagire con questo layout di attività.

Resume() significa che ora puoi interagire con il layout delle attività.


1

Nota che ci sono cose che accadono tra le chiamate a onStart () e onResume (). Vale a dire, su NewIntent (), che ho dolorosamente scoperto.

Se stai usando il flag SINGLE_TOP e invii alcuni dati alla tua attività, usando gli extra di intento, sarai in grado di accedervi solo su onNewIntent (), che viene chiamato dopo onStart () e prima di onResume (). Quindi di solito, prenderai i nuovi dati (forse solo modificati) dagli extra e li imposterai su alcuni membri della classe, o userai setIntent () per impostare il nuovo intento come intento dell'attività originale ed elaborare i dati in onResume ().


0

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

onResume()Chiamato appena prima che l'attività inizi a interagire con l'utente. A questo punto l'attività si trova nella parte superiore dello stack di attività, con l'input dell'utente che vi passa. Sempre seguito da onPause().

onPause()Chiamato quando il sistema sta per iniziare a riprendere un'altra attività. Questo metodo viene in genere utilizzato per eseguire il commit di modifiche non salvate a dati persistenti, per interrompere animazioni e altre cose che potrebbero consumare CPU e così via. Dovrebbe fare tutto ciò che fa molto rapidamente, perché l'attività successiva non verrà ripresa fino al suo ritorno. Seguito da onResume()se l'attività ritorna in primo piano o da onStop()se diventa invisibile per l'utente.


0

Non sono sicuro che questo valga come una risposta, ma ecco il video di YouTube dal corso di Google (Sviluppo di app Android con Kotlin) che spiega la differenza.

  • All'inizio viene chiamato quando l'attività diventa visibile
  • On Pause viene chiamato quando l'attività perde lo stato attivo (come appare una finestra di dialogo)
  • Il pulsante Riprendi viene chiamato quando l'attività diventa attiva (come quando una finestra di dialogo scompare)
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.