Xamarin.Android
Cycle de vie de l'application - Xamarin.Andorid

Introduction

Remarques

Cycle de vie de l'application

Tout d'abord, vous devez savoir que vous pouvez étendre la classe Android.Application pour pouvoir accéder à deux méthodes importantes liées au cycle de vie des applications:

• OnCreate - Appelé au démarrage de l'application, avant la création de tout autre objet d'application (comme MainActivity).

• OnTerminate - Cette méthode est destinée aux environnements de processus émulés. Il ne sera jamais appelé sur un appareil Android de production, où les processus sont supprimés simplement en les tuant; Aucun code utilisateur (y compris ce rappel) n'est exécuté lors de cette opération. De la documentation: https://developer.android.com/reference/android/app/Application.html#onTerminate ()

Dans l'application Xamarin.Android, vous pouvez étendre la classe Application de la manière présentée ci-dessous. Ajoutez une nouvelle classe appelée "MyApplication.cs" à votre projet:

[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();
    }
}

Comme vous l'avez écrit ci-dessus, vous pouvez utiliser la méthode OnCreate. Vous pouvez par exemple initialiser la base de données locale ici ou configurer une configuration supplémentaire.

Il existe également d'autres méthodes qui peuvent être remplacées comme: OnConfigurationChanged ou OnLowMemory.

Cycle de vie de l'activité

Le cycle de vie de l'activité est beaucoup plus complexe. Comme vous le savez, l'activité est une seule page dans l'application Android où l'utilisateur peut interagir avec elle.

Sur le diagramme ci-dessous, vous pouvez voir à quoi ressemble le cycle de vie d'une activité Android:

Comme vous pouvez le constater, il existe un flux spécifique de cycle de vie d'activité. Dans l'application mobile, vous avez bien sûr des méthodes dans chaque classe d'activité qui gèrent un fragment de cycle de vie spécifique:

[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");
    }
}

Il y a une bonne description dans la documentation officielle d'Android:

• La durée de vie totale d'une activité se produit entre le premier appel à onCreate (Bundle) et un seul appel final à onDestroy (). Une activité effectuera toutes les configurations de l'état "global" dans onCreate () et libèrera toutes les ressources restantes dans onDestroy (). Par exemple, si un thread s'exécute en arrière-plan pour télécharger des données du réseau, il peut créer ce thread dans onCreate (), puis arrêter le thread dans onDestroy ().

• La durée de vie visible d'une activité se produit entre un appel à onStart () et un appel correspondant à onStop (). Pendant ce temps, l’utilisateur peut voir l’activité à l’écran, bien qu’il puisse ne pas être au premier plan et interagir avec l’utilisateur. Entre ces deux méthodes, vous pouvez gérer les ressources nécessaires pour afficher l'activité à l'utilisateur. Par exemple, vous pouvez enregistrer un BroadcastReceiver dans onStart () pour surveiller les modifications qui ont un impact sur votre interface utilisateur, puis annuler son enregistrement dans onStop () lorsque l'utilisateur ne voit plus ce que vous affichez. Les méthodes onStart () et onStop () peuvent être appelées plusieurs fois, à mesure que l'activité devient visible et masquée pour l'utilisateur.

• La durée de vie au premier plan d'une activité se produit entre un appel à onResume () et un appel correspondant à onPause (). Pendant ce temps, l'activité est devant toutes les autres activités et interagit avec l'utilisateur. Une activité peut souvent aller entre les états repris et mis en pause - par exemple lorsque le périphérique se met en veille, lorsqu'un résultat d'activité est délivré, qu'une nouvelle intention est délivrée - le code de ces méthodes doit donc être relativement léger.

Cycle de vie des fragments

Comme vous le savez, vous pouvez avoir une activité mais des fragments différents intégrés. C'est pourquoi le cycle de vie des fragments est également important pour les développeurs.

Sur le diagramme ci-dessous, vous pouvez voir à quoi ressemble le cycle de vie d'un fragment Android:

Comme décrit dans la documentation officielle d'Android, vous devez implémenter au moins trois méthodes:

• OnCreate - le système appelle cela lors de la création du fragment. Dans votre implémentation, vous devez initialiser les composants essentiels du fragment que vous souhaitez conserver lorsque le fragment est suspendu ou arrêté, puis repris.

• OnCreateView - Le système appelle cela lorsqu'il est temps que le fragment dessine son interface utilisateur pour la première fois. Pour dessiner une interface utilisateur pour votre fragment, vous devez renvoyer une vue de cette méthode qui est la racine de la présentation de votre fragment. Vous pouvez retourner null si le fragment ne fournit pas d'interface utilisateur.

• OnPause - Le système appelle cette méthode comme première indication que l'utilisateur quitte le fragment (bien que cela ne signifie pas toujours que le fragment est détruit). C'est généralement là que vous devez commettre les modifications qui doivent être persistées au-delà de la session utilisateur en cours (car l'utilisateur risque de ne pas revenir).

Voici un exemple d'implémentation dans 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();
    }
}

Bien sûr, vous pouvez ajouter des méthodes supplémentaires si vous souhaitez gérer différents états.

Exemple complet sur GitHub

Si vous souhaitez obtenir un projet de base avec les méthodes décrites ci-dessous, vous pouvez télécharger le modèle d'application Xamarin.Android à partir de mon GitHub. Vous pouvez trouver des exemples pour:

• Méthodes de cycle de vie des applications
• Méthodes de cycle de vie d'activité
• Méthodes de cycle de vie des fragments

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