Le développement d'applications mobiles avec Xamarin.Android offre une intégration profonde avec Visual Studio, permettant une conception d'interface utilisateur fluide et une gestion native des ressources. Pour maîtriser cette plateforme, il est essentiel de comprendre l'organisation des fichiers et le fonctionnement interne des activités.

Structure d'un projet Xamarin.Android

Lors de la création d'un nouveau projet, une arborescence spécifique est générée. Voici les dossiers clés à connaître :

Le répertoire Assets

Les fichiers placés dans ce dossier sont intégrés tels quels dans le package final de l'application. Contrairement aux ressources standards, ils ne reçoivent pas d'identifiant de ressource unique. On y accède via le gestionnaire d'actifs (AssetManager).

// Exemple de lecture d'un fichier texte depuis les Assets
string contenuTexte;
using (var lecteur = new StreamReader(Assets.Open("info_config.txt")))
{
    contenuTexte = lecteur.ReadToEnd();
}
monComposantTextuel.Text = contenuTexte;
SetContentView(monComposantTextuel);

Le répertoire Resources

Ce dossier est subdivisé en plusieurs sous-répertoires essentiels :

• Drawable : Contient les images et les ressources graphiques, souvent déclinées en plusieurs résolutions.
• Layout : Héberge les fichiers AXML défiinssant l'interface utilisateur.
• Values : Stocke les fichiers XML de configuraton comme strings.xml, styles.xml ou colors.xml.

Dans un fichier de mise en page (ex: main_layout.axml), la structure suit une logique XML spécifique :

<RelativeLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <Button
        android:id="@+id/btnValidation"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/label_valider" />

</RelativeLayout>

Les préfixes utilisés dans le XML ont des rôles précis :

• @id/ : Définit un identifiant unique pour manipuler l'élément en C#.
• @string/ : Référence une chaîne de caractères définie dans le fichier Strings.xml pour faciliter la localisation.

Gestion de la fermeture par double pression

Une fonctionnalité courante consiste à demander une confirmation avant de quitter l'application. Cela se réalise en surchargeant la méthode OnKeyDown dans l'activité principale.

private DateTime? _instantPrecedent;

public override bool OnKeyDown(Keycode keyCode, KeyEvent e)
{
    if (keyCode == Keycode.Back && e.Action == KeyEventActions.Down)
    {
        var delai = DateTime.Now - (_instantPrecedent ?? DateTime.MinValue);
        
        if (delai.TotalSeconds > 2)
        {
            _instantPrecedent = DateTime.Now;
            Toast.MakeText(this, "Appuyez à nouveau pour quitter", ToastLength.Short).Show();
            return true;
        }
        else
        {
            Finish();
        }
        return true;
    }
    return base.OnKeyDown(keyCode, e);
}

Le cycle de vie d'une Activité

Comprendre le cycle de vie est crucial pour gérer correctement la mémoire et l'état de l'application. Voici les étapes majeures :

1. OnCreate : Appelée lors de la création initiale de l'activité. C'est ici que l'on initialise les vues.
2. OnStart : L'activité devient visible pour l'utilisateur.
3. OnResume : L'activité passe au premier plan et devient interactive.
4. OnPause : Le système s'apprête à mettre une autre activité au premier plan. Utile pour sauvegarder des données non enregistrées.
5. OnStop : L'activité n'est plus visible. Elle est toujours en mémoire mais peut être tuée par le système en cas de besoin.
6. OnRestart : Appelée si l'activité revient au premier plan après avoir été arrêtée.
7. OnDestroy : Appelée avant que l'activité ne soit définitivement supprimée de la mémoire.

Si le système manque de ressources alors qu'une activité est en arrière-plan (étapes OnPause ou OnStop), il peut purger l'activité. Dans ce cas, lors du retour de l'utilisateur, le cycle redémarre depuis OnCreate.