Quando inizi a programmare in un linguaggio come C ++ o Java, la prima cosa che viene insegnata è il metodo principale, il punto che il sistema operativo chiamerà quando avvieremo la nostra applicazione.
In Android non esiste un metodo principale in quanto tale, ma ci sono diversi metodi della nostra attività che verranno richiamati da SSOO quando si verificheranno eventi importanti. In questo capitolo studieremo in profondità cosa sono questi eventi e come funzionano. il ciclo completo di un'attività da Android. La documentazione ufficiale offre un'ampia spiegazione di questo argomento, qui studieremo gli elementi più importanti insieme ad alcuni errori comuni durante la loro gestione.
Il ciclo di vita di Android segue questo schema:
Eventi del ciclo di vita
- onCreate (pacchetto)
- Rappresenta il momento in cui l'attività viene creata. Questo metodo verrà normalmente generato dalla procedura guidata durante la creazione di una nuova attività su Android, ed è qui che creeremo tutto ciò di cui l'attività avrà bisogno. Se abbiamo precedentemente salvato i dati dell'attività in un oggetto Bundle, possiamo usarlo per rigenerarlo. Normalmente non lo useremo.
- onStart ()
- L'attività proseguirà essere sullo schermo, sebbene non necessariamente visibile. Se veniamo da uno stop, passeremo prima su onRestart ().
- onRestart ()
- Precedente a onStart () quando si arriva da una chiamata a onStop ().
- onResume ()
- L'attività inizierà rispondere all'interazione utente.
- onPause ()
- L'attività lo farà smetti di rispondere all'interazione dell'utente.
- onStop ()
- L'attività è andata completamente a sfondo.
- onDestroy ()
- attività sarà distrutto e le tue risorse rilasciate.
Quando avremo bisogno di implementare uno di questi metodi, lo faremo aggiungendo alla nostra attività con questi profili:
la classe pubblica MyActivity estende Activity {protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); ...} protected void onStart () {super.onStart (); ...} protected void onRestart () {super.onRestart (); ...} protected void onResume () {super.onResume (); ...} protected void onPause () {... super.onPause (); } protetto void onStop () {... onStop (); } protected void onDestroy () {... super.onDestroy (); }}
È importante mantenere chiamata al metodo superclasse per non incontrare sorprese. I compiti di ogni evento che sono al di sopra della nostra attività devono essere mantenuti. Questa chiamata andrà all'inizio degli eventi di input e alla fine degli eventi di output. In questo modo eviteremo sorprese, poiché gli elementi dell'attività di cui abbiamo bisogno ma che non sarà sotto il nostro controllo verranno creati prima di utilizzarli, e verranno poi distrutti.
Non dobbiamo aggiungere tutti gli eventi, quelli di cui non abbiamo bisogno useranno l'implementazione predefinita. I metodi che useremo spesso - e non è consigliabile toccare gli altri - sono onCreate, onPause e onRestart.
Il significato di onCreate è chiaro: è il luogo in cui caricheremo le risorse di cui abbiamo bisogno, le visualizzazioni e qualsiasi altra cosa di cui abbiamo bisogno. Per l'output, l'unico metodo su cui ci concentreremo è onPause. Il motivo per evitare onStop e onDestroy è che non abbiamo alcun controllo su di essi. onPause verrà eseguito ogni volta che l'applicazione esce dal primo piano, mentre le altre due verranno eseguite dal sistema operativo in base alle proprie esigenze. Potrebbero non essere mai giustiziati! Questo viene fatto per evitare il costo di creare l'attività più e più volte se passiamo dall'attività al desktop e viceversa, e il sistema operativo libererà le risorse utilizzate solo se ne ha bisogno, e non deve partecipare a tutte i processi aperti.
Ciò implica che supporremo che l'applicazione morirà dopo l'esecuzione di onPause e che sia nostra ultima possibilità per salvare i dati che dobbiamo salvare e interrompere i servizi che stiamo utilizzando, come la geolocalizzazione. Se abbiamo interrotto i servizi, il posto appropriato per riavviarli è onRestart.
Gli altri metodi non avremo bisogno di usare molto. Un caso comune in cui avremo bisogno sarà quando integreremo librerie di terze parti, come Facebook o Flurry. In questi casi, ci verrà chiesto di abbinare i metodi della nostra attività al tuo codice. Ad esempio, per registrare una sessione Flurry ci verrà chiesto di avviare la sessione nel metodo onStart.
Alcune idee utili
- Ricorda a cosa serve ogni evento. Avrai sempre bisogno di onCreate, e molto spesso avrai bisogno di onPause e onResume per interrompere e riavviare i servizi più consumati.
- Non toccare gli altri eventi se non ne hai bisogno espressamente.
- Non fidarti di onStop e onDestroy, potrebbero non essere mai chiamati. Salva tutto ciò di cui hai bisogno in onPause.
- Evita di utilizzare variabili statiche non finali. L'app può ancora essere caricata quando torni e manterrà i valori che hanno lasciato. Se non hai altra scelta che usarli, assicurati di reimpostare i loro valori quando torni in primo piano.
Maggiori informazioni - Guida di base alla programmazione in Android
