Xamarin.Android
Ciclo di vita dell'app - Xamarin.Andorid

introduzione

Osservazioni

Ciclo di vita delle applicazioni

Prima di tutto devi sapere che puoi estendere la classe Android.Application in modo da poter accedere a due importanti metodi relativi al ciclo di vita delle app:

• OnCreate: chiamato quando l'applicazione viene avviata, prima che siano stati creati altri oggetti dell'applicazione (come MainActivity).

• OnTerminate: questo metodo è destinato all'uso in ambienti di processo emulati. Non verrà mai chiamato su un dispositivo Android di produzione, in cui i processi vengono rimossi semplicemente eliminandoli; Nessun codice utente (incluso questo callback) viene eseguito quando lo si fa. Dalla documentazione: https://developer.android.com/reference/android/app/Application.html#onTerminate ()

Nell'applicazione Xamarin.Android è possibile estendere la classe Application nel modo illustrato di seguito. Aggiungi una nuova classe chiamata "MyApplication.cs" al tuo progetto:

[Application]
public class MyApplication : Application
{
    public MyApplication(IntPtr handle, JniHandleOwnership ownerShip) : base(handle, ownerShip)
    {
    }

    public override void OnCreate()
    {
        base.OnCreate();
    }

    public override void OnTerminate()
    {
        base.OnTerminate();
    }
}

Come hai scritto sopra puoi usare il metodo OnCreate. Ad esempio, è possibile inizializzare il database locale o configurare una configurazione aggiuntiva.

Esistono anche altri metodi che possono essere sovrascritti come: OnConfigurationChanged o OnLowMemory.

Ciclo di vita delle attività

Il ciclo di vita delle attività è molto più complesso. Come sapete, Activity è una singola pagina nell'app Android in cui l'utente può interagire con esso.

Nello schema seguente puoi vedere come appare il ciclo di vita dell'Android Activity:

Come puoi vedere, esiste un flusso specifico del ciclo di vita delle attività. Nell'applicazione mobile sono naturalmente presenti metodi in ogni classe di attività che gestiscono un frammento specifico del ciclo di vita:

[Activity(Label = "LifecycleApp", MainLauncher = true, Icon = "@mipmap/icon")]
public class MainActivity : Activity
{
    protected override void OnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);
        Log.Debug("OnCreate", "OnCreate called, Activity components are being created");

        // Set our view from the "main" layout resource
        SetContentView(Resource.Layout.MainActivity);
    }

    protected override void OnStart()
    {
        Log.Debug("OnStart", "OnStart called, App is Active");
        base.OnStart();
    }

    protected override void OnResume()
    {
        Log.Debug("OnResume", "OnResume called, app is ready to interact with the user");
        base.OnResume();
    }

    protected override void OnPause()
    {
        Log.Debug("OnPause", "OnPause called, App is moving to background");
        base.OnPause();
    }

    protected override void OnStop()
    {
        Log.Debug("OnStop", "OnStop called, App is in the background");
        base.OnStop();
    }

    protected override void OnDestroy()
    {
        base.OnDestroy();
        Log.Debug("OnDestroy", "OnDestroy called, App is Terminating");
    }
}

C'è una buona descrizione nella documentazione ufficiale di Android:

• L'intera durata di un'attività avviene tra la prima chiamata a onCreate (Bundle) fino a una singola chiamata finale a onDestroy (). Un'attività eseguirà tutte le impostazioni dello stato "globale" in onCreate () e rilascerà tutte le risorse rimanenti in onDestroy (). Ad esempio, se ha un thread in esecuzione in background per scaricare i dati dalla rete, può creare quel thread in onCreate () e quindi interrompere il thread in onDestroy ().

• La durata visibile di un'attività si verifica tra una chiamata a onStart () fino alla corrispondente chiamata a onStop (). Durante questo periodo, l'utente può vedere l'attività sullo schermo, anche se potrebbe non essere in primo piano e interagire con l'utente. Tra questi due metodi è possibile conservare le risorse necessarie per mostrare l'attività all'utente. Ad esempio, è possibile registrare un BroadcastReceiver in onStart () per monitorare le modifiche che hanno un impatto sull'interfaccia utente e annullarne la registrazione in onStop () quando l'utente non vede più ciò che si sta visualizzando. I metodi onStart () e onStop () possono essere chiamati più volte, in quanto l'attività diventa visibile e nascosta all'utente.

• La durata in primo piano di un'attività si verifica tra una chiamata a onResume () fino alla corrispondente chiamata a onPause (). Durante questo periodo l'attività è di fronte a tutte le altre attività e interagisce con l'utente. Un'attività può spesso passare tra gli stati di ripresa e di pausa - ad esempio quando il dispositivo va in stop, quando viene consegnato un risultato di attività, quando viene consegnato un nuovo intento - quindi il codice in questi metodi dovrebbe essere abbastanza leggero.

Ciclo di vita del frammento

Come sai, puoi avere un'attività, ma in essa sono incorporati diversi frammenti. Ecco perché il ciclo di vita dei frammenti è importante anche per gli sviluppatori.

Nello schema seguente puoi vedere come appare il ciclo di vita del frammento di Android:

Come descritto nella documentazione ufficiale di Android, è necessario implementare almeno tre metodi:

• OnCreate: il sistema chiama questo quando crea il frammento. Nell'implementazione, è necessario inizializzare i componenti essenziali del frammento che si desidera conservare quando il frammento è in pausa o arrestato, quindi riprendere.

• OnCreateView: il sistema chiama questo quando è il momento per il frammento di disegnare la sua interfaccia utente per la prima volta. Per disegnare un'interfaccia utente per il frammento, è necessario restituire una vista da questo metodo che rappresenta la radice del layout del frammento. È possibile restituire null se il frammento non fornisce un'interfaccia utente.

• OnPause: il sistema chiama questo metodo come prima indicazione che l'utente lascia il frammento (sebbene non sempre significhi che il frammento è stato distrutto). Questo di solito è dove si dovrebbero commettere eventuali modifiche che dovrebbero essere mantenute oltre la sessione utente corrente (perché l'utente potrebbe non tornare).

Ecco un'implementazione di esempio in Xamarin.Android:

public class MainFragment : Fragment
{
    public override void OnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);

        // Create your fragment here
        // You should initialize essential components of the fragment
        // that you want to retain when the fragment is paused or stopped, then resumed.
    }

    public override View OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
    {
        // Use this to return your custom view for this Fragment
        // The system calls this when it's time for the fragment to draw its user interface for the first time.

        var mainView = inflater.Inflate(Resource.Layout.MainFragment, container, false);
        return mainView;
    }

    public override void OnPause()
    {
        // The system calls this method as the first indication that the user is leaving the fragment 

        base.OnPause();
    }
}

Ovviamente è possibile aggiungere ulteriori metodi qui se si desidera gestire stati diversi.

Esempio completo su GitHub

Se desideri ottenere un progetto di base con i metodi descritti di seguito, puoi scaricare il modello di applicazione Xamarin.Android dal mio GitHub. Puoi trovare esempi per:

• Metodi del ciclo di vita delle applicazioni
• Metodi del ciclo di vita delle attività
• Metodi del ciclo di vita dei frammenti

https://github.com/Daniel-Krzyczkowski/XamarinAndroid/tree/master/AndroidLifecycle/LifecycleApp