Comment utiliser notre librairie Android avec Xamarin

Comment utiliser notre librairie Android avec Xamarin

Dans nos précédents articles, nous avons toujours utilisé Android Studio pour réaliser nos applications, cependant ce n'est pas le seul outil disponible. En effet, certains de nos clients utilisent Xamarin et C# pour réaliser leurs applications mobiles. Cette semaine, nous allons voir comment créer une application Android qui utilise nos modules à l'aide de Xamarin.




Xamarin est un outil qui permet, entre autre, d’écrire des applications mobiles en C#. Depuis 2016, date à laquelle Microsoft a racheté Xamarin, cet outil est intégré directement dans Visual Studio. Comme la plupart des frameworks informatiques, Xamarin est supposé faire gagner du temps durant le développement et permettre de réutiliser le code sur toutes les plateformes.

Pour tester cet outil, nous allons écrire une petite application qui va simplement afficher la liste des modules Yoctopuce détectés lors de la pression d'un bouton. Nous partons du principe que vous connaissez un minimum le fonctionnement de nos modules. Si ce n'est pas le cas, nous vous conseillons de commencer par la lecture des premiers articles de la série "Pour les débutants", plus particulièrement celui sur la structure logique des modules Yoctopuce. Il est aussi conseillé de lire notre tutoriel sur l'utilisation de nos modules sous Android.

Dans cet article, nous avons utilisé Visual Studio Community 2019 sous Windows 10, mais la procédure est identique avec toutes les versions de Visual Studio qui supportent Xamarin.

Créer un projet "Android Bindings library"


Xamarin utilise C# comme language de programation, mais notre librairie est écrite en Java. La solution pour utiliser ces langages dans une même application est de créer un projet "Android Bindings library" qui va créer un "wrapper" C# pour notre librairie.

Ce "wrapper" est en fait un fichier .dll qui contient du code C# et la librairie Java.
Ce fichier .dll pourra ensuite être utilisé directement dans votre application Android Xamarin.

On commence donc à créer un projet "Android Bindings library" que l'on appel "YoctoAPIBindings".

Il faut créer un projet Android Bindings library pour convertir notre librairie Java en C#
Il faut créer un projet Android Bindings library pour convertir notre librairie Java en C#



Ce projet contient un sous-répertoire Jars dans lequel il faut ajouter toutes les librairies Android écrites en Java que l'on va utiliser plus tard. Dans notre cas, il y a besoin d'ajouter uniquement le fichier YoctoAPI.aar, qui est la version précompilée de notre librairie Android.

Pour ce faire, il faut télécharger notre librairie Android depuis notre site web et déziper l'archive sur votre disque. Dans le sous-répertoire "Binaries", vous trouverez le fichier YoctoAPI.aar.

Pour ajouter ce fichier YoctoAPI.aar au projet Visual Studio, il faut faire un clic droit sur le sous-répertoire Jars et sélectionner "Add"->"Existing Item...".

Il faut ajouter le fichier YoctoAPI.aar au projet
Il faut ajouter le fichier YoctoAPI.aar au projet



La dernière étape est de changer la propriété "build action" du fichier YoctoAPI.aar et de sélectionner "LibraryProjectZip".

Attention à bien metre la propriété build action à LibraryProjectZip
Attention à bien metre la propriété build action à LibraryProjectZip



Voilà, la "Android Binding library" est prête à être compilée. Il faut aller dans le menu "Build" et sélectionner "Build solution", ou utiliser le raccourci clavier Ctrl+Shift+B. Le fichier YoctoAPIBindings.dll généré se trouve dans le sous-répertoire /bin/Debug/ ou /bin/Release.

Utiliser YoctoAPIBindings.dll


Maintenant que l'on a "converti" notre librairie en librairie utilisable par Xamarin, nous allons voir comment réaliser une application très basique qui liste des modules Yoctopuce détectés. Il s'agit en fait de l'application "Doc-Inventory" qui est présente dans la documentation et que vous pouvez retrouver dans la librairie Yoctopuce pour Android (en Java).

Pour ce faire, il faut créer un deuxième projet de type "Android App (Xamarin)" avec Visual Studio. Dans notre cas, nous allons l'appeler "DemoApp", et nous sommes partis d'un projet simple (Blank App).

Le deuxième projet est de type Android App (Xamarin)
Le deuxième projet est de type Android App (Xamarin)



Il faut ensuite ajouter une référence sur le fichier YoctoAPIBindings.dll que nous venons de compiler. Cela peut être fait à l'aide d'un clic droit sur le noeud "References" dans le panneau "Solution Explorer" ou à l'aide du menu avec "Project" -> "Add Reference...".

Dans la fenêtre "Reference Manager", il faut utiliser bouton "Browse..." et sélectionner le fichier YoctoAPIBindings.dll, et cliquer sur "OK".

La fenêtre Reference Manager permet d'ajouter la librairie de binding
La fenêtre Reference Manager permet d'ajouter la librairie de binding



Il en reste plus qu'à utiliser la librairie Yoctopuce directement depuis le code C#.

Les conventions C#


Lors de la génération de la librairie de binding, Xamarin a automatiquement renommé certaines fonctions et certaines propriétés pour s'adapter aux conventions C#.

Premièrement, le packagename java com.yoctopuce.YoctoAPI est transformé en namespace Com.Yoctopuce.YoctoAPI. Donc dans tous les fichiers qui utilisent la librairie Yoctopuce il faut ajouter le code suivant:

using Com.Yoctopuce.YoctoAPI;



De plus, toutes les méthodes sont converties en PascalCase et les setter / getter Java sont convertis en propriété C#.

Par exemple le code Java suivant:

import com.yoctopuce.YoctoAPI.*;

YRelay relay = YRelay.FirstRelay();
YModule module = relay.get_module();
if (module.isOnline())
{
    String serial = module.get_serialNumber();
    module.set_beacon(YModule.BEACON_ON);
    module.reboot(3);
}



devient:

using Com.Yoctopuce.YoctoAPI;

YRelay relay = YRelay.FirstRelay();
YModule module = relay.Module;
if (module.IsOnline)
{
    string serial = module.SerialNumber;
    module.SetBeacon(YModule.BeaconOn);
    module.Reboot(3);
}



C'est un peu pénible quand on a l'habitude des conventions Yoctopuce, mais heureusement la complétion automatique de Visual Studio fonctionne assez bien.

Dans le case de notre application, le code C# est le suivant:

using Android.App;
using Android.OS;
using Android.Support.V7.App;
using Android.Runtime;
using Android.Widget;
using Com.Yoctopuce.YoctoAPI;

namespace DemoApp
{
  [Activity(Label = "@string/app_name", Theme = "@style/AppTheme", MainLauncher = true)]
  public class MainActivity : AppCompatActivity
  {
    protected override void OnCreate(Bundle savedInstanceState)
    {
      base.OnCreate(savedInstanceState);
      Xamarin.Essentials.Platform.Init(this, savedInstanceState);
      // Set our view from the "main" layout resource
      SetContentView(Resource.Layout.activity_main);
      var button = FindViewById<Button>(Resource.Id.ButtonRefresh);
      button.Click += (sender, e) => { this.RefreshInventory(); };
    }

    private void RefreshInventory()
    {
      LinearLayout layout =FindViewById<LinearLayout>(Resource.Id.InventoryList);
      layout.RemoveAllViews();

      YAPI.UpdateDeviceList();
      YModule module = YModule.FirstModule();
      while (module != null)
      {
        string line = module.SerialNumber + " (" + module.ProductName + ")";
        TextView tx = new TextView(this);
        tx.Text = line;
        layout.AddView(tx);
        module = module.NextModule();
      }
    }

    protected override void OnStart()
    {
      base.OnStart();
      YAPI.EnableUSBHost(this);
      YAPI.RegisterHub("usb");
    }

    protected override void OnStop()
    {
      YAPI.FreeAPI();
      base.OnStop();
    }

    public override void OnRequestPermissionsResult(int requestCode,
                  string[] permissions,
                  [GeneratedEnum] Android.Content.PM.Permission[] grantResults)
    {
      Xamarin.Essentials.Platform.OnRequestPermissionsResult(requestCode,
                                               permissions, grantResults);
      base.OnRequestPermissionsResult(requestCode, permissions, grantResults);
    }
  }
}



Hormis la syntaxe C# et les renommages des fonctions pour suivre les conventions C#, le code est très similaire à la version Java. Pour plus de détails sur les fonctions YAPI.XXX, vous pouvez lire notre article sur l'utilisation de nos modules sous Android.

Une différence majeur par rapport la version Java de la même application: Il n'est pas nécessaire de déclarer l'utilisation du port USB dans le fichier AndroidManifest.xml. Visiblement Xamarin se charge tout seul d’autoriser l'application à utiliser le port USB.

Voilà un screenshot de l'application final:

L'application Android Xamarin avec la librairie Yoctopuce
L'application Android Xamarin avec la librairie Yoctopuce



Les deux projets Visual Studio (l'application et la librairie de binding) sont disponibles sur GitHub: https://github.com/yoctopuce-examples/xamarin_demo

Conclusion


Comme nous venons de le voir, il est possible d'utiliser la librairie dans Xamarin sans trop de difficultés, toutefois nous ne sommes pas complètement satisfaits de la conversion des noms de fonction et de constante faite par le compilateur. Nous allons continuer à investiguer Xamarin pour voir s'il n'y a pas moyen de simplifier encore un peu les choses...


Commenter aucun commentaire Retour au blog












Yoctopuce, get your stuff connected.