URL: https://linuxfr.org/news/communiquer-avec-d-bus-en-java-avec-jnidbus
Title: Communiquer avec D-Bus en Java avec JNIDBus
Authors: pulkomandy
 SeekDaSky, Davy Defaud, Ysabeau 🧶, claudex, Nÿco et BAud
Date: 2019年09月16日T14:07:53+02:00
License: CC By-SA
Tags: dbus, java et jnidbus
Score: 30
Avec mes collègues chez [Viveris](http://viveris.fr), on s’est dit qu’on aimerait bien faire plus de logiciel libre. On a donc monté un « groupe _opensource_ » dont le but est d’identifier les projets pour lesquels on peut publier tout ou une partie du code sous licence libre, et aussi de contribuer aux outils et bibliothèques qu’on utilise le plus.
Il y a quelques mois je vous présentais [QTestFramework](https://linuxfr.org/users/pulkomandy/journaux/un-harnais-de-test-pour-qt), depuis on a également pu contribuer au [dissecteur 0MQ pour Wireshark](https://github.com/whitequark/zmtp-wireshark) et [un outil pour le _boundary scan_ JTAG](https://github.com/viveris/jtag-boundary-scanner).
On vient de publier il y a quelques jours une bibliothèque Java pour communiquer en D-Bus.
----
[Projets opensource chez Viveris](https://opensource.viveris.fr)
[JNIDBus sur GitHub](https://github.com/viveris/jnidbus)
[D-Bus sur Wikipédia](https://fr.wikipedia.org/wiki/D-Bus)
----
Contexte
========
D-Bus
----
D-Bus est un système de communication inter-processus utilisé sous GNU/Linux. Le projet a été lancé par des développeurs de Red Hat au sein de Freedesktop. Il a été intégré dans GNOME 2 et KDE 4, et aujourd’hui il est utilisé par de très nombreux composants d’un système GNU/Linux : systemd, NetworkManager et PulseAudio, par exemple. Il y a même une implémentation dans le noyau Linux lui‐même.
JNI
----
JNI (_Java Native Interface_) est une API qui permet d’interfacer du code tournant dans une machine virtuelle Java avec du code natif. Cela nécessite d’écrire (en C ou C++) des _wrappers_ qui vont manipuler la pile de la JVM pour récupérer les arguments et pousser les valeurs de retour, et éventuellement accéder aux objets Java manipulés. Les méthodes ainsi implémentées peuvent ensuite être appelées depuis le code Java de façon transparente.
Solutions existantes et leurs limitations
-----------------------------------------
Freedesktop propose [DBus-Java](https://www.freedesktop.org/wiki/Software/DBusBindings/), mais il n’y a pas eu de version publiée depuis 2009. La dernière version a besoin de Java 7 pour fonctionner. De plus, cette bibliothèque implémente le protocole D-Bus en Java, ce qui risque de poser des problèmes d’interopérabilité avec l’implémentation en C.
 
Il existe bien [une version mise à jour](https://github.com/hypfvieh/dbus-java) de la bibliothèque qui corrige au moins le premier problème, cependant l’API n’utilise pas les nouvelles fonctionnalités de Java et c’est bien dommage.
JNIDBus
=======
Historique
----------
Dans le cadre d’une migration d’un de nos logiciels depuis Java 7, nous avons découvert que DBus-Java ne prenait pas en charge les versions plus récentes. Nous aurions pu nous contenter d’une mise à jour de cette implémentation, mais il y avait beaucoup de code à reprendre dedans et de toute façon, l’API ne nous convenait pas.
 
En effet, dbus-java représente les messages D-Bus par des « tuples » génériques, ce qui est assez peu pratique à utiliser et rend le code illisible. De plus, les API sont bloquantes et cela nous contraignait à utiliser une réserve (_pool_) de fils d’exécution qui complexifiait encore le logiciel.
 
L’ensemble des ces défauts et l’absence d’alternative viable nous ont poussé à développer notre propre alternative, en essayant de répondre a toutes les problématiques.
Afin de ne pas réimplémenter le protocole D-Bus nous voulions utiliser la bibliothèque `libdbus-1`. L’écosystème Java possède deux manières d’appeler du code natif : JNI et JNA, ce dernier étant écarté pour des raisons de performances et de complexité des bibliothèques de liaison (_bindings_) à écrire.
 
Enfin, la dernière contrainte était de réduire le code natif au strict minimum, afin de limiter la complexité de ce dernier qui est très difficile à tester unitairement.
Utilisation
-----------
La base de JNIDBus est la sérialisation d’objet Java. La signature du message est décrite dans une annotation.
 
*Exemple pour un message contenant une chaîne de caractères et un entier :*
 
```java
@DBusType(
 /* Pour plus d’info sur le format de la signature, référez vous
 * à la documentation D-Bus
 */
 signature = "si",
 /* Donne le nom des propriétés contenant les données du message,
 * dans notre cas la chaîne de caractères est contenue dans la
 * propriété nommée « string » et l’entier dans le champs « integer »
 */
 fields = {"string","integer"}
)
public class StringMessage extends Message {
 /* Les champs seront accédés au travers de ses setters et
 * getters qui devront respecter la convention "setXxx"/"getXxx"
 */
 private String string;
 private int integer
 public String getString() { ... }
 public void setString(String string) { ... }
 public int getInteger() { ... }
 public void setInteger(int string) { ... }
}
```
L’appel de méthodes distantes est transparent grâce a l’utilisation de `proxy` Java, il suffit de décrire l’interface de l’objet et de donner le nom de son bus pour pouvoir l’appeler. Toute méthode distante retourne un `PendingCall` auquel on doit attacher un _listener_ pour être notifié de l’arrivée du résultat.
 
JNIDBus permet également d’exposer des méthodes distante par le biais de `handlers`. Un _handler_ est simplement une classe annotée décrivant et implémentant les méthodes distantes, les signatures sont inférées grâce aux types d’entrées et de sorties. Les _handlers_ seront exécutés dans la boucle d’évènements, il est donc primordial d’éviter tout appel bloquant ou toute tâche lourde. Afin de tout de même pouvoir effectuer ces tâches lourdes, les _handlers_ gèrent un type de retour asynchrone (`Promise`).
*Exemple d’un* handler *pour un signal et un appel :*
 
```java
@Handler(
 /* pour plus d’information référez vous à la documentation D-Bus
 */
 path = "/some/object/path",
 interfaceName = "some.dbus.interface"
)
public class SomeHandler extends GenericHandler {
 @HandlerMethod(
 //le nom exposé a D-Bus peut être différent du nom de la méthode Java
 member = "someSignal",
 type = HandlerType.SIGNAL
 )
 //Ici notre signal n’a aucun paramètre, on utilise donc le singleton EmptyMessage
 public void someSignal(Message.EmptyMessage emptyMessage) { ... }
 @HandlerMethod(
 member = "stringSignal",
 type = HandlerType.METHOD
 )
 public SomeOutput someCall(SomeInput input) { ... }
}
```
*Comment enregistrer le handler auprès de D-Bus :*
 
```java
//connection au bus
Dbus receiver = new Dbus(BusType.SESSION,"my.bus.name");
//instanciation
SomeHandler handler = new SomeHandler();
//ajout, JNIDBus lancera une exception si le handler n’est pas valide
this.receiver.addHandler(handler);
```
Le langage Kotlin est pris en charge par le biais d’un artefact Gradle supplémentaire définissant des extensions qui suspendent l’appel de fonction et offrant la possibilité d’avoir des `handlers` qui facilitent la mise en place de cette suspension :
 
```kotlin
//il faut enregistrer la classe qui se chargera d’invoquer les méthodes qui suspendent
KotlinMethodInvocator.registerKotlinInvocator()
@Handler(path = "...", interfaceName = "...")
class CallHandler : KotlinGenericHandler() {
 @HandlerMethod(member = "suspendingCall", type = MemberType.METHOD)
 suspend fun suspendingCall(emptyMessage: Message.EmptyMessage): SingleStringMessage {
 //coroutines are awesome
 delay(2000)
 return SingleStringMessage().apply { string = "test" }
 }
}
```
</div><div class="naked_ctrl">
<form action="/index.cgi/contrast" method="get" name="gate">
<p><a href="http://altstyle.alfasado.net">AltStyle</a> によって変換されたページ <a href="httpS://linuxfr.org/news/communiquer-avec-d-bus-en-java-avec-jnidbus.md">(-&gt;オリジナル)</a>
/ <label>アドレス: <input type="text" name="naked_post_url" value="httpS://linuxfr.org/news/communiquer-avec-d-bus-en-java-avec-jnidbus.md" size="22" /></label> <label>モード: <select name="naked_post_mode">
<option value="default">デフォルト</option>
<option value="speech">音声ブラウザ</option>
<option value="ruby">ルビ付き</option>
<option value="contrast" selected="selected">配色反転</option>
<option value="larger-text">文字拡大</option>
<option value="mobile">モバイル</option>
</select>
<input type="submit" value="表示" />
</p>
</form>
</div>