Liaison d’un fichier .AAR

  • Article
  • 8 minutes de lecture

Important

Nous examinons actuellement l’utilisation de liaison personnalisée sur la plateforme Xamarin. Prenez cette enquête pour informer les efforts de développement futurs.

Cette procédure pas à pas fournit des instructions pas à pas pour créer une bibliothèque de liaisons Java Xamarin.Android à partir d’un Android . Fichier AAR.

Vue d’ensemble

Archive Android (. Le fichier AAR) est le format de fichier des bibliothèques Android. Un. Le fichier AAR est une archive .ZIP qui contient les éléments suivants :

  • Code Java compilé
  • ID de ressource
  • Ressources
  • Métadonnées (par exemple, déclarations d’activité, autorisations)

Dans ce guide, nous allons parcourir les principes de base de la création d’une bibliothèque de liaisons pour un seul . Fichier AAR. Pour obtenir une vue d’ensemble de la liaison de bibliothèque Java en général (avec un exemple de code de base), consultez Liaison d’une bibliothèque Java.

Important

Un projet de liaison ne peut inclure qu’un seul . Fichier AAR. Si le . AAR dépend d’autres . AAR, alors ces dépendances doivent être contenues dans leur propre projet de liaison, puis référencées. Voir bogue 44573.

Procédure pas à pas

Nous allons créer une bibliothèque de liaisons pour un exemple de fichier d’archive Android créé dans Android Studio, textanalyzer.aar. Ce. AAR contient une TextCounter classe avec des méthodes statiques qui comptent le nombre de voyelles et de consonnes dans une chaîne. De plus, textanalyzer.aar contient une ressource d’image pour vous aider à afficher les résultats de comptage.

Nous allons utiliser les étapes suivantes pour créer une bibliothèque de liaisons à partir de l’élément . Fichier AAR :

  1. Créez un projet de bibliothèque de liaisons Java.

  2. Ajoutez un seul . Fichier AAR dans le projet. Un projet de liaison ne peut contenir qu’un seul . AAR.

  3. Définissez l’action de génération appropriée pour le . Fichier AAR.

  4. Choisissez une infrastructure cible que le . AAR prend en charge.

  5. Générez la bibliothèque de liaisons.

Une fois que nous avons créé la bibliothèque de liaisons, nous allons développer une petite application Android qui invite l’utilisateur à entrer une chaîne de texte, des appels. Méthodes AAR pour analyser le texte, récupère l’image à partir du . AAR et affiche les résultats avec l’image.

L’exemple d’application accède à la TextCounter classe de textanalyzer.aar :

package com.xamarin.textcounter;

public class TextCounter
{
    ...
    public static int numVowels (String text) { ... };
    ...
    public static int numConsonants (String text) { ... };
    ...
}

En outre, cet exemple d’application récupère et affiche une ressource d’image empaquetée dans textanalyzer.aar :

Xamarin monkey image

Cette ressource d’image se trouve à res/drawable/monkey.png dans textanalyzer.aar.

Création de la bibliothèque de liaisons

Avant de commencer avec les étapes ci-dessous, téléchargez l’exemple de fichier archive Textanalyzer.aar Android :

  1. Créez un projet de bibliothèque de liaisons à partir du modèle Bibliothèque de liaisons Android. Vous pouvez utiliser Visual Studio pour Mac ou Visual Studio (les captures d’écran ci-dessous montrent Visual Studio, mais Visual Studio pour Mac est très similaire). Nommez la solution AarBinding :

    Create AarBindings project

  2. Le modèle inclut un dossier Jars dans lequel vous ajoutez votre . AAR(s) au projet De bibliothèque de liaisons. Cliquez avec le bouton droit sur le dossier Jars , puis sélectionnez Ajouter > un élément existant :

    Add existing item

  3. Accédez au fichier textanalyzer.aar téléchargé précédemment, sélectionnez-le, puis cliquez sur Ajouter :

    Add textanalayzer.aar

  4. Vérifiez que le fichier textanalyzer.aar a été correctement ajouté au projet :

    The textanalyzer.aar file was added

  5. Définissez l’action de génération pour textanalyzer.aar sur LibraryProjectZip. Dans Visual Studio pour Mac, cliquez avec le bouton droit sur textanalyzer.aar pour définir l’action de génération. Dans Visual Studio, l’action de génération peut être définie dans le volet Propriétés) :

    Setting the textanalyzer.aar build action to LibraryProjectZip

  6. Ouvrez les propriétés du projet pour configurer le Framework cible. Si le . AAR utilise toutes les API Android, définissez le Framework cible sur le niveau d’API que le . AAR s’attend. (Pour plus d’informations sur le paramètre target Framework et les niveaux d’API Android en général, consultez Présentation des niveaux d’API Android.)

    Définissez le niveau d’API cible pour votre bibliothèque de liaisons. Dans cet exemple, nous sommes libres d’utiliser le dernier niveau d’API de plateforme (niveau API 23) car notre textanalyzer n’a pas de dépendance sur les API Android :

    Setting the target level to API 23

  7. Générez la bibliothèque de liaisons. Le projet De bibliothèque de liaisons doit être généré avec succès et produire une .DLL de sortie à l’emplacement suivant : AarBinding/bin/Debug/AarBinding.dll

Utilisation de la bibliothèque de liaisons

Pour utiliser ce .DLL dans votre application Xamarin.Android, vous devez d’abord ajouter une référence à la bibliothèque de liaisons. Utiliser les étapes suivantes :

  1. Nous créons cette application dans la même solution que la bibliothèque de liaisons pour simplifier cette procédure pas à pas. (L’application qui consomme la bibliothèque de liaisons peut également résider dans une autre solution.) Créez une application Xamarin.Android : cliquez avec le bouton droit sur la solution et sélectionnez Ajouter une nouvelle Project. Nommez le nouveau project BindingTest :

    Create new BindingTest project

  2. Cliquez avec le bouton droit sur le nœud Références du projet BindingTest , puis sélectionnez Ajouter une référence...:

    Click Add Reference

  3. Sélectionnez le projet AarBinding créé précédemment, puis cliquez sur OK :

    Check the AAR binding project

  4. Ouvrez le nœud Références du projet BindingTest pour vérifier que la référence AarBinding est présente :

    AarBinding is listed under References

Si vous souhaitez afficher le contenu du projet Bibliothèque de liaisons, vous pouvez double-cliquer sur la référence pour l’ouvrir dans l’Explorateur d’objets. Vous pouvez voir le contenu mappé de l’espace Com.Xamarin.Textcounter de noms (mappé à partir du package Java com.xamarin.textanalyzezr ) et vous pouvez afficher les membres de la TextCounter classe :

Viewing the Object Browser

La capture d’écran ci-dessus met en évidence les deux TextAnalyzer méthodes que l’exemple d’application appelle : NumConsonants (qui encapsule la méthode Java numConsonants sous-jacente) et NumVowels (qui encapsule la méthode Java numVowels sous-jacente).

Accéder. AAR Types

Après avoir ajouté une référence à votre application qui pointe vers la bibliothèque de liaisons, vous pouvez accéder aux types Java dans le . AAR comme vous le feriez pour accéder aux types C# (grâce aux wrappers C#). Le code d’application C# peut appeler TextAnalyzer des méthodes comme illustré dans cet exemple :

using Com.Xamarin.Textcounter;
...
int numVowels = TextCounter.NumVowels (myText);
int numConsonants = TextCounter.NumConsonants (myText);

Dans l’exemple ci-dessus, nous appelons des méthodes statiques dans la TextCounter classe. Toutefois, vous pouvez également instancier des classes et des méthodes d’instance d’appel. Par exemple, si votre . AAR encapsule une classe appelée Employee qui a la méthode buildFullNamed’instance, vous pouvez instancier MyClass et l’utiliser comme indiqué ici :

var employee = new Com.MyCompany.MyProject.Employee();
var name = employee.BuildFullName ();

Les étapes suivantes ajoutent du code à l’application afin qu’elle invite l’utilisateur à rechercher du texte, utilise TextCounter pour analyser le texte, puis affiche les résultats.

Remplacez la disposition BindingTest (Main.axml) par le code XML suivant. Cette disposition comporte une EditText entrée de texte et deux boutons pour lancer des voyelles et des nombres de consonnes :

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation             ="vertical"
    android:layout_width            ="fill_parent"
    android:layout_height           ="fill_parent" >
    <TextView
        android:text                ="Text to analyze:"
        android:textSize            ="24dp"
        android:layout_marginTop    ="30dp"
        android:layout_gravity      ="center"
        android:layout_width        ="wrap_content"
        android:layout_height       ="wrap_content" />
    <EditText
        android:id                  ="@+id/input"
        android:text                ="I can use my .AAR file from C#!"
        android:layout_marginTop    ="10dp"
        android:layout_gravity      ="center"
        android:layout_width        ="300dp"
        android:layout_height       ="wrap_content"/>
    <Button
        android:id                  ="@+id/vowels"
        android:layout_marginTop    ="30dp"
        android:layout_width        ="240dp"
        android:layout_height       ="wrap_content"
        android:layout_gravity      ="center"
        android:text                ="Count Vowels" />
    <Button
        android:id                  ="@+id/consonants"
        android:layout_width        ="240dp"
        android:layout_height       ="wrap_content"
        android:layout_gravity      ="center"
        android:text                ="Count Consonants" />
</LinearLayout>

Remplacez le contenu de MainActivity.cs par le code suivant. Comme indiqué dans cet exemple, les gestionnaires d’événements de bouton appellent des méthodes encapsulées TextCounter qui résident dans le . AAR et utilisez des toasts pour afficher les résultats. Notez l’instruction using de l’espace de noms de la bibliothèque liée (dans ce cas, Com.Xamarin.Textcounter) :

using System;
using Android.App;
using Android.Content;
using Android.Runtime;
using Android.Views;
using Android.Widget;
using Android.OS;
using Android.Views.InputMethods;
using Com.Xamarin.Textcounter;

namespace BindingTest
{
    [Activity(Label = "BindingTest", MainLauncher = true, Icon = "@drawable/icon")]
    public class MainActivity : Activity
    {
        InputMethodManager imm;

        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);

            SetContentView(Resource.Layout.Main);

            imm = (InputMethodManager)GetSystemService(Context.InputMethodService);

            var vowelsBtn = FindViewById<Button>(Resource.Id.vowels);
            var consonBtn = FindViewById<Button>(Resource.Id.consonants);
            var edittext = FindViewById<EditText>(Resource.Id.input);
            edittext.InputType = Android.Text.InputTypes.TextVariationPassword;

            edittext.KeyPress += (sender, e) =>
            {
                imm.HideSoftInputFromWindow(edittext.WindowToken, HideSoftInputFlags.NotAlways);
                e.Handled = true;
            };

            vowelsBtn.Click += (sender, e) =>
            {
                int count = TextCounter.NumVowels(edittext.Text);
                string msg = count + " vowels found.";
                Toast.MakeText (this, msg, ToastLength.Short).Show ();
            };

            consonBtn.Click += (sender, e) =>
            {
                int count = TextCounter.NumConsonants(edittext.Text);
                string msg = count + " consonants found.";
                Toast.MakeText (this, msg, ToastLength.Short).Show ();
            };

        }
    }
}

Compilez et exécutez le projet BindingTest . L’application démarre et présente la capture d’écran à gauche (initialisée EditText avec du texte, mais vous pouvez l’appuyer pour la modifier). Lorsque vous appuyez sur COUNT VOYELS, un toast affiche le nombre de voyelles comme indiqué à droite :

Screenshots from running BindingTest

Essayez d’appuyer sur le bouton COUNT CONSONANTS . En outre, vous pouvez modifier la ligne de texte et appuyer à nouveau sur ces boutons pour tester les différents nombres de voyelles et de consonnes.

Accéder. Ressources AAR

L’outil Xamarin fusionne les données R à partir du . AAR dans la classe Ressource de votre application. Par conséquent, vous pouvez accéder à . Ressources AAR de votre disposition (et du code-behind) de la même façon que vous accédez aux ressources qui se trouvent dans le chemin des ressources de votre projet.

Pour accéder à une ressource d’image, vous utilisez le nom Resource.Drawable pour l’image empaquetée dans le . AAR. Par exemple, vous pouvez référencerimage.png dans le . Fichier AAR à l’aide de @drawable/image:

<ImageView android:src="@drawable/image" ... />

Vous pouvez également accéder aux dispositions des ressources qui résident dans le . AAR. Pour ce faire, vous utilisez le nom Resource.Layout pour la disposition empaquetée dans le . AAR. Par exemple :

var a = new ArrayAdapter<string>(this, Resource.Layout.row_layout, ...);

L’exemple textanalyzer.aar contient un fichier image qui se trouve à res/drawable/monkey.png. Nous allons accéder à cette ressource d’image et l’utiliser dans notre exemple d’application :

Modifiez la disposition BindingTest (Main.axml) et ajoutez une ImageView à la fin du LinearLayout conteneur. Cela ImageView affiche l’image trouvée à @drawable/singe; cette image sera chargée à partir de la section de ressource de textanalyzer.aar :

    ...
    <ImageView
        android:src                 ="@drawable/monkey"
        android:layout_marginTop    ="40dp"
        android:layout_width        ="200dp"
        android:layout_height       ="200dp"
        android:layout_gravity      ="center" />

</LinearLayout>

Compilez et exécutez le projet BindingTest . L’application démarre et présente la capture d’écran à gauche : lorsque vous appuyez sur COUNT CONSONANTS, les résultats s’affichent comme indiqué à droite :

BindingTest displaying consonant count

Félicitations ! Vous avez correctement lié une bibliothèque Java . AAR!

Résumé

Dans cette procédure pas à pas, nous avons créé une bibliothèque de liaisons pour un . Fichier AAR, ajout de la bibliothèque bindings à une application de test minimale et exécution de l’application pour vérifier que notre code C# peut appeler du code Java résidant dans le . Fichier AAR. En outre, nous avons étendu l’application pour accéder à une ressource image qui réside dans le . Fichier AAR.