Introduction à l'utilisation du NFC dans une application Android

Le NFC (pour Near Field Communication soit communication en champ proche) est une technologie qui n'est pas nouvelle, mais qui commence à apparaître dans nos Smartphones, et il y a fort à parier que son apparition va se généraliser dans les années à venir. Ce capteur permet l'envoi et la lecture de données sous forme de « TAG » entre deux terminaux, mais également entre un terminal et une puce (que je nommerai dans la suite « tag »), et ce sur de très courtes distances (de l'ordre de quelques centimètres). Il devient alors plus aisé pour les utilisateurs d'échanger des données, simplement en rapprochant leur téléphone d'une borne par exemple. Les applications pour ce capteur sont donc multiples (dont le paiement) et il faut que vous sachiez que beaucoup de chercheurs se penchent dessus depuis quelques années.

Depuis quelques mois le nouveau Androphone de Google, créé en coopération avec Samsung, embarque un capteur de ce type. Le SDK (Software Developement Kit) qui doit vous être familier si vous avez déjà développé ne serait-ce qu'un « hello world » s'est vu doter de deux nouvelles mises à jour (API 9 et 10 pour Android 2.3 Gingerbread) entre autres pour permettre de manipuler ce capteur. Bien que le capteur permette (au niveau physique) les trois modes du NFC (à savoir la lecture, l'envoi et l'émulation), actuellement seuls les deux premiers sont supportés par le SDK.

Nous allons donc voir dans ce tutoriel comment se servir de ces deux modes pour envoyer et recevoir des données d'un terminal à un autre. Je ne traiterai pas ici la lecture / écriture depuis / vers un tag physique (les puces), bien que la méthode soit assez proche. Cela fera l'objet d'un prochain tutoriel. Dans la suite de l'article, j'utiliserai le mot Tag pour désigner la structure de données transitant par le capteur NFC, et non la puce physique lisible par le capteur.

Pour une bonne compréhension de ce tutoriel, vous devrez disposer des connaissances de base en Java et en développement d'applications Android. Les notions d'Activity, Intent, Context et Manifest doivent vous être familières. Je ne me focaliserai donc pas sur la façon dont on code une application, ni sur la structure du projet, mais bien sur le code directement.

Tous les exemples qui suivent ont été codés pour la version 10 de l'API. Si vous ne l'avez pas encore installée, je vous invite à le faire avant de continuer.

Avant de commencer à programmer notre Activity gérer la lecture d'un Tag, il faut que le système sache que notre classe permet de le faire. Pour cela, on va déclarer dans le Manifest de notre application que notre classe (ici RActivity) gère la réception des TAG NFC.

<activity android:name=".RActivity" android:label="RActivity">
    <intent-filter>
        <action android:name="android.nfc.action.TAG_DISCOVERED"/>
        <category android:name="android.intent.category.DEFAULT"/>
    </intent-filter>
</activity>

Vous remarquerez les deux lignes atypiques dans la balise intent-filter qui servent à « inscrire » auprès du système notre Activity pour que lorsqu'un TAG arrive, le système propose (possiblement entre autres) la nôtre pour gérer l'évènement.

Notez qu'il est possible de s'inscrire à différents niveaux d'abstraction. Observez le schéma suivant qui montre comment le système détermine quelle Activity va être utilisée :

Celui-ci explique que lors de la découverte d'un TAG, le système va regarder si l'application au premier plan peut gérer l'événement. Sinon, il regarde s'il existe une (ou plusieurs) application(s) sur le système s'étant enregistrée(s) pour gérer les évènements de type « NDEF_DISCOVERED ».

Pour que l'application au premier plan puisse gérer directement la découverte d'un TAG, il est nécessaire de modifier quelque peu la méthode onResume() de l'Activity.

PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, new Intent(this, this.getClass()).addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP), 0);
mAdapter.enableForegroundDispatch(this, pendingIntent, null, null);

Remarquez ici que je passe deux fois null en paramètre pour intercepter tous les TAG, mais vous pouvez filtrer de la même manière que dans le Manifest les TAG à gérer. Le NDEF étant le nom donné au message contenu dans les TAG, il est donc à un niveau d'abstraction plus bas. Si tel est le cas, alors il lance l'application ou demande à l'utilisateur si plusieurs demandent la main. Sinon c'est TECH (pour technologie) découvert qui prendra la main pour le choix de l'Activity à lancer, sur le même principe que pour NDEF. Pour finir, le système en cherche une proposant ses services lorsqu'un TAG est découvert. Là encore, même chose en cas d'application(s) trouvée(s).

Une fois ceci fait, attaquons-nous à la partie Java du code. Créez dans votre classe une méthode (que je nommerai resoudreIntent) prenant en paramètre un Intent. Si vous êtes habitué au développement Android cela ne devrait pas vous choquer. Que va faire cette méthode ? Tout simplement vérifier la présence d'un TAG dans l'Intent courant et le cas échéant le lire.

Vérifions maintenant dans resoudreIntent la présence d'un Tag dans l'Intent passé en paramètre :

String action = intent.getAction();
if (NfcAdapter.ACTION_TAG_DISCOVERED.equals(action)){

Si votre condition est fausse, à vous de faire ce que vous désirez (ce ne sera le cas que si l'utilisateur peut lancer l'Activity « à la main »). Nous allons nous intéresser à la lecture de ce TAG s'il est présent. Nous allons récupérer trois objets : un de type Tag qui contiendra l'entête du TAG, un de type byte[] qui sera l'id du tag et un de type NdefMessage[] qui contiendra le message en lui-même. Je vous rappelle que nous ne nous intéressons pas ici à la lecture d'une puce Tag, mais juste à un message transitant par le NFC. C'est pourquoi nous n'allons récupérer que le message lui-même, et pas l'entête Tag.

Parcelable[] rawMsgs = intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES);
NdefMessage[] messages;
if (rawMsgs != null) {
    msgs = new NdefMessage[rawMsgs.length];
    for (int i = 0; i < rawMsgs.length; i++) {
        messages[i] = (NdefMessage) rawMsgs[i];
    }

Voici donc comment récupérer depuis un NDefMessage tous ces NdefRecord, puis pour chacun ses caractéristiques.

NdefRecord record = messages[i].getRecords()[i];
byte[] id = record.getId();
short tnf = record.getTnf();
byte[] type = record.getType();
String message = getTextData(record.getPayload());

La fonction getTextData est générique pour les TAG de type RTD_TEXT (texte brut). Elle est définie comme suit.

String getTextData(byte[] payload) {
    String texteCode = ((payload[0] & 0deux00) == 0) ' "UTF-8" : "UTF-16";
    int langageCodeTaille = payload[0] & 0077;
    return new String(payload, langageCodeTaille + 1, payload.length - langageCodeTaille - 1, texteCode);
}

Et voilà ! Maintenant vous êtes en mesure de récupérer sous forme d'une chaîne de caractères le contenu d'un message arrivé par le capteur NFC de votre terminal.

Voyons maintenant comment utiliser le capteur NFC pour envoyer des données à un autre terminal.

Contrairement à la réception où nous récupérons directement les données depuis l'Intent, pour envoyer un message nous allons avoir besoin de nous servir directement du capteur NFC. Et comme pour toute ressource sur Android, il faut avoir la permission appropriée. Rajoutons donc à notre Manifest la demande de permission.

<uses-permission android:name="android.permission.NFC" />

Pour être certain que le téléphone sur lequel votre application va être exécutée dispose d'un capteur NFC, vous pouvez rajouter cette ligne au Manifest pour interdire l'installation de votre application sur un téléphone non compatible.

<uses-feature android:name="android.hardware.nfc" android:required="true" />

Maintenant que nous avons le droit de manipuler le capteur NFC, récupérons l'objet le représentant. Ce code devant être placé dans votre Activity, this fait ici référence au Context.

NfcAdapter nfcAdapter = NfcAdapter.getDefaultAdapter(this);

Comme nous l'avons vu précédemment, la partie « données » d'un TAG est un NdefMessage, qui est constitué d'un ou plusieurs NdefRecord. Les données transitant sous forme de bytes, il va falloir encoder notre texte, tout en encodant le Charset pour que l'application de lecture puisse savoir comment décoder les données. Voici les fonctions qui vont encoder un message (un String) en un NdefRecord, puis encapsuler le NdefRecord dans un NdefMessage.

NdefRecord creerRecord(String message)
{
    byte[] langBytes = Locale.ENGLISH.getLanguage().getBytes(Charset.forName("US-ASCII"));
    byte[] textBytes = message.getBytes(Charset.forName("UTF-8"));
    char status = (char) (langBytes.length);
    byte[] data = new byte[1 + langBytes.length + textBytes.length];
    data[0] = (byte) status;
    System.arraycopy(langBytes, 0, data, 1, langBytes.length);
    System.arraycopy(textBytes, 0, data, 1 + langBytes.length, textBytes.length);
    return new NdefRecord(NdefRecord.TNF_WELL_KNOWN, NdefRecord.RTD_TEXT, new byte[0], data);
}

NdefMessage creerMessage(NdefRecord record)
{
    NdefRecord[] records = new NdefRecord[1];
    records[0] = record;
    NdefMessage message = new NdefMessage(records);
    return message;
}

Maintenant que nous pouvons créer nos messages à faire passer, occupons-nous de les envoyer. Nous allons pour cela faire appel à la méthode enableForegroundNdefPush(Context, NdefMessage) de la classe NfcAdapter.

protected void onPause()
{
    super.onPause();
    nfcAdapter.disableForegroundNdefPush(this);
}

protected void onResume()
{
    super.onResume();
    NdefRecord record = creerRecord("Exemple de message à envoyer");
    NdefMessage message = creerMessage(record);
    nfcAdapter.enableForegroundNdefPush(this, message);
}

Et voilà. Tant que votre Activity sera au premier plan, elle diffusera en boucle son message via le capteur NFC. Dès lors que vous changerez d'Activity, la diffusion du message s'arrêtera.

Maintenant que l'on peut envoyer et recevoir des données par NFC, il peut être intéressant de simuler la réception d'un Tag, que ce soit à des fins de débogage (il n'est pas toujours possible d'avoir sous la main deux terminaux équipés), ou parce que cela présente un avantage quelconque pour votre application.

Lors de la réception d'un Tag, on a vu que l'on récupérait les informations à partir de l'Intent. Et bien pour simuler la réception d'un Tag, nous allons tout simplement créer un Intent qui contiendra notre « faux » Tag et l'envoyer au système, qui se chargera de le renvoyer à la bonne application. Pour cela nous allons réutiliser les deux fonctions précédentes, « creerRecord » et « creerMessage » afin de créer le message qui sera contenu dans le Tag faussement détecté.

final Intent intent = new Intent(NfcAdapter.ACTION_TAG_DISCOVERED);
NdefMessage[] messages = new NdefMessage[1];
messages[0] = creerMessage(creerRecord("Simulation d'une réception de Tag"));
intent.putExtra(NfcAdapter.EXTRA_NDEF_MESSAGES, messages);
startActivity(intent);

C'est fini. Oui c'est exactement comme appeler une Activity classique. La seule différence réside dans le passage de NfcAdapter.ACTION_TAG_DISCOVERED à l'Intent au lieu de passer la classe de votre projet.

Je voudrais remercier Claude Leloup pour sa relecture attentive.