Click to reduce…

C'est avec plaisir que je vous annonce la sortie de la première version alpha de Salut à Toi 0.7. Cela permet d'une part de vous montrer l'état, les avancées et l'orientation du projet, mais aussi de faire un appel à la contribution. Je vais dans la suite de cet article vous présenter une partie des capacités de Salut à Toi, ainsi que vous expliquer briévement comme les utiliser.

Vous trouverez un lien vers un fichier .apk pour tester sur Android dans la section « Testez ! ».

Pour mémoire, Salut à Toi est un écosystème collaboratif, multi interfaces (web, bureau, appareils portatifs, terminal, ligne de commande), multi-plateformes, et multi-usages. Il permet de gérer vos communications, de vous organiser, de partager vos fichiers, etc. C'est aussi, et avant tout un projet engagé qui prend en compte l'impacte des nouvelles technologies sur nos vies, et qui cherche à stimuler le débat public.

Nous allons nous concentrer sur les interfaces Web, et bureau/appareils portatifs, car ce sont celles qui sont les plus susceptibles d'intéresser le plus grand nombre.

Interface web (appelée « Libervia »)

Libervia a entamé des changements très importants, avec l'apparition d'un cadriciel (« framework » en anglais) web.

L'idée, expliquée dans un billet de blog est de fournir les composants de base (comptes et authentification, permissions, commentaires, etc.) directement utilisables et décentralisés grâce à XMPP. On construit ainsi facilement des sites automatiquement décentralisés et fédérés.

Notez que tout est prévu pour la traduction dans différentes langues, mais que pour l'instant seul l'anglais est disponible. De l'aide serait grandement appréciée pour améliorer cela !

Voyons les fonctionnalités déjà disponibles :

Chat

capture d'une discussion avec le « chat » de Libervia

Probablement le plus évident, il y a une application de messagerie instantanée. Pour l'utiliser il faut cliquer sur « Chat », et vous connecter si ce n'est pas encore fait.

Vous arrivez alors dans un panneau indiquant les salons contenus dans vos marque-pages, il vous suffit de cliquer sur l'un d'eux, ou d'indiquer l'identifiant (jid) d'un nouveau salon. C'est pour le moment assez basique, vous pouvez toutefois entrer « /help » pour avoir accès à liste des commandes textuelles.

Blog

mon blog, qui tourne avec Libervia Une des fonctionnalités phares de SàT, et peu courante dans le monde XMPP (le seul client activement développé le permettant également étant Movim), est le blog (qui est donc décentralisé).

Un clique sur le menu vous amènera sur une page de « découverte » où vous pourrez voir vos contacts ayant un blog. Cliquez sur l'un d'eux pour le lire, ou indiquez un identifiant pour en lire un qui n'est pas dans vos contacts.

Forums

un forum décentralisé qui tourne sur XMPP

Fonctionnalité unique dans le monde XMPP, SàT propose un système de forums, qui permet en pratique d'organiser des discussions dans des catégories. Les forums étant en arrière plan la même chose que les blogs, il est possible d'utiliser un blog comme forum et vice versa.

La création de forums se fait par un ou une administrateur/ice en ligne de commande avec l'outil « jp » (voir ci-dessous).

Événements

la liste personnelle des événements

Autre fonctionnalité unique dans le milieu XMPP (et en décentralisé ?), SàT permet de créer des événements, et bien sûr d'y inviter du monde.

Comme pour les autres fonctionnalités, la page est prévue pour être simple à utiliser : vous avec un bouton « créer un événement », qui vous mène à un formulaire. Un nom, un lieu et une date plus tard (et éventuellement une photo pour le représenter), et votre événement est créé. Vous arrivez alors sur la page d'administration où vous pouvez indiquer les personnes à inviter.

Les événements sont pour le moment privés, uniquement vous et vos invités y ont accès, mais des événements publiques sont prévus.

un invité répond à la demande RSVP d'un événement

À noter qu'il est possible (mais pas encore depuis l'interface web) d'ajouter des champs arbitraires à vos événements, permettant par exemple de préciser ce que vos invités amènent à un pique-nique.

Partage de fichiers

le partage de fichier depuis le navigateur

Là on touche à une fonctionnalité utile au quotidien, et dans beaucoup de circonstances. Salut à toi permettait depuis longtemps de s'envoyer des fichiers, ou d'en déposer sur votre serveur, mais il s'agit ici de partager un ou des répertoires, ou de déposer des fichiers sur un serveur.

Tout ceci est expliqué dans un récent billet de blog, mais je vous donne tout de même 2 exemples pour bien comprendre :

  • vous êtes chez vous, vous venez de prendre une vidéo et des photos sur votre téléphone que vous voulez voir sur votre ordinateur. Vous avez installé Cagou, l'interface bureau/Android de SàT sur votre appareil et partagé votre répertoire photo. Depuis votre ordinateur de bureau, dans la partie « partage de fichiers » vous voyez votre appareil et pouvez télécharger directement la vidéo et les photos. La connexion se fera directement sur le réseau local d'appareil à appareil, vos fichiers ne transiteront pas par un serveur situé on ne sait où.

  • vous avez des fichiers que vous voulez accéder de n'importe où n'importe quand (des photos ou des documents de travail par exemple). Vous les mettez dans un répertoire virtuel sur votre composant de partage de fichier (une instance SàT également, voir plus bas), et vous y accédez aussi simplement que dans l'exemple précédent.

Notez que bien qu'avec Cagou la connexion se fait directement quand c'est possible, ça n'est pas encore le cas pour Libervia qui téléchargera d'abord le fichier sur le serveur avant de la fournir en HTTPS. La connexion directe nécessitera WebRTC qui est prévu pour la version 0.8.

Les permissions se gèrent très simplement : vous indiquez qui a le droit d'accéder à vos fichiers en quelques cliques.

Les fichiers passent pour le moment en clair (non chiffré), mais ceci ne devrait plus être le cas d'ici la version finale.

Albums photos

un album photo avec un commentaire

Basé sur la fonctionnalité précédente, un mode album photos permet de présenter un dossier qui ne contient que des photos avec une vue adaptée, et de le commenter.

Les permissions sont très utiles ici, permettant de ne laisser, par exemple, que votre famille visionner un album.

Il n'est pas encore possible d’accéder à un album depuis l'interface de Libervia, pour tester vous allez devoir changer l'URL à la main depuis le partage de fichiers (en remplaçant files/list par photos/album).

Tickets

les tickets de SàT, les premiers ont été importés de Bugzilla

Développé pour nos propres besoins, SàT permet désormais de gérer des tickets à la façon d'une forge logicielle. On est dans le classique ticket de suivi, rapport de bogue, tâche à faire, etc.

Les champs sont libres, il est ainsi très facile d'utiliser cette fonctionnalité pour tout type de listes : tâches à faire, mais aussi, par exemple, liste de courses.

Requêtes de fusion

un patch essentiel est en cours de revue

Dans la lignée des tickets, SàT gère également les « requêtes de fusion » (ou « merge requests » en anglais). Développé et utilisé en premier lieu pour le développement de SàT lui-même, ce système a l'avantage de ne pas être lié à un outil particulier (comme Git ou Mercurial). Il est actuellement utilisé avec Mercurial, mais il est possible de l'utiliser avec ce que l'on souhaite, et cela n'est pas réservé au développement de code logiciel.

Ces 2 dernières fonctionnalités font de SàT une forge décentralisée. Même si elle est encore basique, elle a l'avantage d'être simple d'utilisation, souple et facilement adaptable, et surtout il n'existe pas ou peu de forge décentralisées à l'heure actuelle (on peut sans doute compter Fossil, et peut être d'autres).

Encore une fois, l'arrivée de contributions permettrait d’accélérer les choses et d'en faire un outil très puissant.

Application

la partie dynamique, qui est en maintenance minimal et sera réécrite pour la 0.8

Pour conclure ce petit tour de Libervia, notons l'application qui vous amènera à une version entièrement dynamique, plus élaborée mais également plus difficile à utiliser, la version de base voulant être facile à prendre en main.

L'application web Libervia permet d'utiliser des widgets que vous pouvez déposer côte à côte, de faire du chiffrement de bout en bout (via OTR), ou de publier des billets de blog en mode simple ou WYSIWYG, avec la syntaxe qui vous convient (Markdown par exemple).

Il s'agit de l'application historique qui pour des raisons techniques n'est plus qu'en maintenance minimale et comporte un certain nombre de problèmes (comme le contact qui apparait 2 fois, visible dans la capture ci-dessus). Elle sera réécrite pour SàT 0.8, mais est laissée dans cette version en l'état pour ceux qui souhaitent toujours l'utiliser.

Cagou (bureau/Android)

Promise suite à notre campagne de financement, qui nous a permis de récolter un peu plus de 3000 €, Cagou est notre nouvelle interface de bureau et pour appareils Android. Elle se veut moderne, facile à utiliser, et puissante.

Son interface originale est inspirée de Blender, elle permet de diviser l'écran pour afficher plusieurs widgets en même temps. Cette interface a été pensée pour qu'on puisse l'utiliser même sans connaître cette capacité de division, tout en étant évidant à utiliser une fois celle-ci découverte.

Pour utiliser un widget, cliquez tout simplement sur l’icône en haut à gauche du widget en cours pour sélectionner un autre.

Pour le moment, 5 widgets sont disponibles : chat, liste de contacts, partage de fichiers, sélectionneur de widgets et paramètres.

Tout en haut, vous avez un menu (uniquement sur le bureau) et une zone de notification, ou les messages apparaissent quelques secondes (et sont visibles en entier en cliquant sur la tête de Cagou gauche). De l'autre côté, une autre tête de Cagou peut apparaître quand vous recevez des notifications nécessitant une action de l'utilisateur (nouveau contact par exemple, ou demande d'authentification, voir ci-dessous). Ainsi pas de popup qui vole le focus quand vous tapez un message ou autre.

Split

Originalité de Cagou, inspirée de Blender, il est possible de diviser l'écran à volonté en cliquant sur les zones avec 3 points (en haut et à gauche) puis en les faisant glisser. Si la barre apparaît en rouge, cela veut signifie que vous allez fermer la zone. Une image animée devrait rendre les choses plus claires :

démonstration des capacités de séparation des widgets (split) de Cagou

Vous pouvez ainsi vous organiser comme vous l'entendez, et surveiller plusieurs choses en même temps. À terme il devrait être possible de garder les dispositions pratiques pour les remettre en place facilement.

Chat

capture du mode « chat » de Cagou

Le chat devrait être relativement intuitif. La zone du haut indique le salon ou l'identifiant (JID) de la personne avec laquelle vous discutez. Il est possible d'entrer un autre identifiant manuellement pour changer de salon, par exemple entrez sat@chat.jabberfr.org pour venir sur le salon de Salut à Toi.

Toujours en haut, l’icône « cadenas » à droite (visible uniquement dans les conversations 1/1) vous permet de chiffrer de bout en bout la conversation, avec OTR uniquement pour l'instant (voir plus bas).

Si vous avez plusieurs conversations en cours, vous pouvez passer de l'une à l'autre en balayant l'écran avec votre doigt horizontalement (mouvement aussi appelé « swipe »). Seules les conversations non déjà visibles sur l'écran seront disponibles, et pour le moment elles sont dans un ordre alphabétique (il est fort probable que les conversations récentes soit disponibles en premier d'ici la version stable).

Enfin dans la zone du bas, outre la zone de saisie vous voyer un bouton + cerclé qui permet d'ouvrir le panneau d'envoi de médias. Sur bureau vous n'avez pour le moment que la possibilité de choisir un fichier, mais sur Android vous pouvez sélectionner/prendre une photo, une vidéo, sélectionner un fichier, ou encore enregistrer un message audio. Dans tous les cas, vous pouvez choisir si vous voulez téléverser le fichier sur votre serveur, ou l'envoyer directement à votre correspondant, sans passer par le serveur.

Transfert de fichiers

Le principe a déjà été expliqué pour Libervia, voici une animation montrant comment partager un répertoire sur Cagou :

partager un répertoire depuis Cagou

Comme vous le voyez, il suffit de faire un clique/appui long sur le répertoire ou fichier à partager, et de sélectionner les personnes qui y auront accès.

Si vous cliquez sur le bouton « share local files » dans la zone d'en-tête pour changer de mode et voir les appareils qui partagent. Vous verrez alors apparaître – comme sur Libervia – 3 zones : la première avec les éventuels composants de partage, la deuxième avec vos propres appareils (votre téléphone ou ordinateur de bureau par exemple), et enfin les appareils de vos contacts. Là encore, la zone de saisie permet de filtrer les appareils affichés.

voir les appareils qui peuvent partager des fichiers

Authentification sur un site externe

SàT est un projet qui pousse à l'exploitation des différentes possibilités de XMPP, et notamment l'authentification sur des sites externes. Le principe est de pouvoir vous authentifier sans créer de compte sur n'importe quel site en indiquant juste votre JID.

Démonstration en vidéo, grâce au site de démo mis en place par jnanar, l'écran sur la droite est un téléphone (capturé avec scrcpy):

s'authentifier très simplement avec XMPP

Vous pouvez très facilement intégrer cela dans votre propre site soit en utilisant le composant de Chteufleur (qui est d’ailleurs à l'origine de l'implémentation dans SàT, un grand merci à lui), soit en utilisant un serveur où c'est déjà en place (c'est pas exemple le cas sur jabberfr grâce aux GA – gentils admins – de ce site).

Notez bien qu'une fois ceci en place, dans votre site vous n'avez besoin d'effectuer qu'une seule requête HTTPS pour valider une authentification (et ça serait super qu'un lecteur fasse l'implémentation pour LinuxFr).

Contacts

Pas besoin de s'éterniser sur ce mode, mais il est bon de savoir qu'il permet d'ajouter un contact en cliquant sur le bouton idoine en haut. Un/une clique/touche long(ue) permet également de supprimer un contact.

Un clique simple va lancer le mode discussion avec la personne choisie.

Ligne de commande (JP)

Il y a beaucoup trop de choses nouvelles dans jp pour tout décrire ici.

Quelques informations utiles tout de même :

  • dans jp on met toujours les commandes puis les arguments (jp [commande] [sous-commande] --arg_1 --arg_2 --etc)
  • jp [commande] --help vous permet de savoir comment utiliser une commande
  • jp shell vous permet d'avoir une invite de commande REPL
  • il est possible d'avoir des commandes haut niveau et bas niveau. Par exemple pour le blog, vous pouvez avoir les billets d'un blog mis en forme en faisant jp blog get -s blogueur@quelquepart.ext -O fancy, ou le XML bas niveau avec jp pubsub get -s blogueur@quelquepart.ext -n urn:xmpp:microblog:0
  • beaucoup de commandes disposent d'un système de mise en forme avec --output (ou -O). ainsi jp blog get -s blogueur@quelquepart.ext -O json vous permet de retrouver les métadonnées d'un fil de blog en JSON
  • jp est capable de générer des sites statiques grâce à --output template
  • quand le générateur de site le supporte, vous pouvez directement utiliser l'URL d'un blog pour l'éditer. Par exemple, je peux éditer un de mes derniers billets de blog en faisant jp blog edit -u https://www.goffi.org/b/khii3yEKWDhmNYSDt5GGrY/vers-forge-decentralisee-basee-xmpphttps://www.goffi.org/b/khii3yEKWDhmNYSDt5GGrY/vers-forge-decentralisee-basee-xmpp est l'URL de la page générée en HTML. Je me retrouve alors avec mon éditeur de texte affichant le code de ma page d'un côté (dans la syntaxe de mon choix) et les métadonnées de l'autre. Notez que cela fonctionne avec les sites générés par Libervia, mais également avec Movim.

Petite démonstration du shell pour lire un blog :

lecture d'un blog depuis le shell (jp)

Testez !

Vous pouvez tester tout cela, les instructions d'installations sont disponibles (en anglais seulement, nous manquons de moyens pour traduire) sur le wiki en cliquant ici.

SàT (backend + jp (CLI) + Primitivus (TUI)) est disponible dans Debian experimental (merci à Robotux, Naha, Debacle et les autres empaqueteurs).

SàT et ses frontaux (jp, Primitivus, Cagou, Libervia) sont disponibles sur Arch Linux (merci à jnanar et Link Mauve)

Nous avons eu confirmation que SàT et Cagou fonctionnent sur Mac OS X (merci à xma), nous aimerions du monde pour tester également sur Windows, BSD*, ou autre.

Vous pouvez tester sur Android en cliquant sur ce lien depuis votre appareil (il faut avoir autorisé les installations depuis les sources externes).

Notez bien qu'il s'agit d'une version alpha, ce qui signifie :

  • que ça plante, le code n'est pas encore stable
  • que toutes les fonctionnalités ne sont pas finies, ou présentes
  • que ça n'est pas optimisé
  • que ça n'est pas poli (graphiquement, il ne va vous insulter si vous êtes gentil avec lui)

Ah, en parlant de fonctionnalité non encore présente, il y a de très fortes chances que le chiffrement de bout en bout avec OMEMO soit implémenté d'ici la version finale, grâce entre autres à la disponibilité d'un nouveau module Python (merci à Syndace, son auteur). Le chiffrement de bout en bout est déjà disponible depuis plusieurs années, mais via OTR uniquement jusqu'ici.

Participez !

Une dernière animation pour vous montrer la détection automatique de la langue, une fonctionnalité expérimentale :

détection de la langue, puis filtrage des messages

Arrêtons-nous là pour les fonctionnalités, mais nous n'avons pas fait le tour.

Comme vous le voyez, il y a de quoi s'amuser et il y en a pour tous les goûts dans ce projet. Et ça tombe bien, avec les grandes vacances, vous avez certainement du temps devant vous, idéal pour contribuer sur un projet unique et engagé (engagez-vous qu'il disait) !

Vous pouvez commencer, par exemple, avec ce tutoriel pour écrire un greffon qui fonctionnera avec tous les frontaux.

N'hésitez pas à passer sur le salon XMPP de SàT (sat@chat.jabberfr.org, aussi accessible sans compte via le web).

Si jamais vous n'avez pas le temps (les pique-niques à plage c'est bien aussi), un soutien sur Liberapay et/ou une adhésion à l'association nous aide.

Essayez de faire passer le mot autour de vous, le projet manque de visibilité et a besoin de vous. Si vous souhaitez héberger une instance, vous pouvez commencer à tester (dans une partie « expérimentale/non stable » de votre site), et à nous faire des retours. Nous cherchons aussi du monde pour nous aider à empaqueter partout où c'est possible.

Merci d'avance, et à bientôt !

Click to expand… Click to reduce…

Click to reduce…

Click to expand… Click to reduce…

Click to reduce…

Avec la récente annonce concernant le changement de propriétaire de la plus grosse forge centralisée connue, on a vu resurgir ici et là des questionnements sur la création d'un outil similaire mais décentralisé.

J'ai profité de l'occasion pour rappeler le travail effectué pour implémenter tickets et requêtes de fusion (« merge requests ») dans Salut à Toi (SàT), travail qui était passé relativement inaperçu quand j'ai écrit à ce sujet, il y a 6 mois.

Désormais je souhaite apporter quelques précisions sur le pourquoi de ces outils.

Tout d'abord pourquoi pas la grosse forge ? Après tout une importante partie des logiciels libres actuels l'utilise déjà !
D'une part parce que ce n'est pas libre, et nous nous sommes engagés dans notre contrat social à utiliser tant que possible des logiciels libres, y compris pour l'infrastructure. D'autre part parce que c'est centralisé, et là encore notre contrat social est clair à ce sujet, même si c'est moins essentiel pour l'infrastructure que pour SàT lui-même. Enfin parce que nous utilisons à l'heure actuelle Mercurial, et que la forge la plus connue est construite autour de Git.
Ne cachons pas toutefois que nous nous sommes déjà posés la question notamment en assemblée générale (cf. les comptes rendus), nous étions intéressés en particulier par la visibilité.

« C'est centralisé ? Mais « Git » est décentralisé ! » est une réflexion que l'on entend souvent et elle est vraie, Git (et Mercurial, et d'autres) est décentralisé. Mais une forge n'est pas le gestionnaire de version, c'est tous les outils autour : hébergement, tickets, gestion des modifications (merge/pull requests), commentaires, wikis, etc. Et ces outils là ne sont pas décentralisés à l'heure actuelle, et même s'ils sont souvent accessibles par des API spécifiques aux services, ils restent soumis aux lois de la centralisation, c'est-à-dire du service qui héberge (et des aléas techniques de ce service). Cela veut également dire que si le service ne veut pas d'un projet, il peut le refuser, l'effacer, le bloquer.

La centralisation, c'est aussi la facilité pour cataloguer et rechercher… pour les projets qui sont sur ce service. Rendant de facto toute tentative extérieure moins visible et donc augmentant ses difficultés. C'est une situation que nous connaissons bien avec Salut à Toi (nous sommes également absents des « réseaux sociaux » propriétaires et centralisés pour les mêmes raisons), et que nous jugeons inacceptable. Il va sans dire que se concentrer sur une plateforme ne fait qu'encourager et prolonger cet état de fait. Notons tout de même qu'il n'est pas question ici de dénigrer ceux qui ont fait des choix différents, ces réflexions étant liées à notre implication politique forte et les contraintes changent d'un cas à l'autre.

Pourquoi, alors, ne pas utiliser des projets libres existants, avancés et fonctionnels comme Gitlab ? D'une part parce que nous travaillons avec Mercurial et non Git, et d'autre part parce que nous serions là aussi dans la centralisation. Il y a une autre raison : c'est qu'il n'existe pas ou peu (Fossil peut être ?) de forges décentralisées, et nous avons déjà tout ce qu'il nous faut avec SàT et XMPP. Et puis il y a un certain plaisir à créer les outils qui nous manquent.

SàT se veut un écosystème complet, offrant la majeure partie si ce n'est tous les outils nécessaires pour s'organiser et communiquer. Mais il est aussi générique et réutilisable. C'est pourquoi le système de « merge requests » n'est pas lié à un outil particulier (Git ou Mercurial), il peut être utilisé avec d'autre logiciels, et n'est d'ailleurs par réservé au développement de code. C'est une autre brique qui sera utilisée là où ça sera utile.

Pour conclure, je rappelle que si vous voulez voir une alternative décentralisée, éthique et engagée pour construire nos logiciels, nous organiser et communiquer, on peut la rendre possible en coopérant et contribuant, que ce soit avec du code, de la conception graphique (design), des traductions de la documentation des tests, etc.
Nous avons récemment eu de l'aide pour l'empaquetage sur Arch (merci à jnanar et aux mainteneurs précédents), et il y a des efforts continus pour l'empaquetage sur Debian (merci à Robotux, Naha, Debacle et les autre empaqueteur XMPP sur Debian). Si vous pouvez participer, merci de regarder comment nous contacter sur le site officiel), ensemble on peut faire la différence.
Si vous manquez de temps, vous pouvez aussi nous soutenir sur Liberapay: https://liberapay.com/salut_a_toi. Merci d'avance !

Click to expand… Click to reduce…

Click to reduce…

Click to expand… Click to reduce…

Click to reduce…

La dernière grosse fonctionnalité avant la préparation de la version alpha, le partage de fichiers, et désormais disponible pour Salut à Toi.

SàT est capable d'envoyer ou recevoir des fichiers depuis des années, soit directement quand 2 personnes sont connectées en même temps, ou via un téléversement sur le serveur (via « HTTP upload »).

Il est maintenant possible de partager une hiérarchie de fichiers, ou en d'autres termes un ou plusieurs répertoires. Il y a 2 cas d'utilisation principaux : avec un composant, ou un autre client.

partager un répertoire avec Cagou

Partager un répertoire avec un client

La première façon d'utiliser le partage de fichiers est directement entre 2 appareils. Ceci peut être utilisé, par exemple, pour partager des photos prises sur votre téléphone avec votre ordinateur de bureau, ou pour rapidement donner accès à des documents de travail à vos collègues.
Pour gérer les permissions, vous n'avez qu'à donner les JIDs (identifiants XMPP) des personnes autorisées (ou à cliquer sur les contacts dans Cagou, l'interface graphique).

Le transfert utilise la technologie Jingle, qui va permettre de choisir la meilleure façon d'envoyer le fichier. Cela signifie que si vous êtes sur le même réseau local que l'autre appareil (ce qui est le cas dans le précédant exemple de partager des photos prises sur le téléphone avec votre ordinateur de bureau, quand vous êtes à la maison), la connexion reste en local, et le serveur ne verra que le « signal », c'est à dire les données nécessaires à l'établissement de la connexion.

Mais si vos appareils ne sont pas sur le même réseau local, la connexion est toujours faisable, et SàT essaiera d'utiliser une connexion directe quand c'est possible.

partage de fichiers avec un client

Ci-dessus vous pouvez voir avec quelle simplicité on peut partager un répertoire avec Cagou, l'interface bureau/Android de Salut à Toi.

Le partage de fichiers avec un composant

SàT peut maintenant gérer des composants (qui sont plus ou moins des greffons génériques pour les serveurs XMPP), et un premier permet à un utilisateur de téléverser, lister, ou retrouver des fichiers.

Ceci est vraiment pratique quand vous voulez garder des fichiers privés pour une utilisation ultérieure (et y accéder depuis n'importe quel appareil), ou pour partager un album photo, par exemple, avec votre famille. Cette fonctionnalité est sur la voie d'un service similaire à ce qu'on appelle de nos jours « stockage sur le cloud », sauf que vous pouvez garder le contrôle sur vos données.

partage de fichiers avec un composant

Comme vous pouvez le voir, c'est très similaire à ce qu'il se passe entre 2 clients.

De plus avec le nouveau système d'invitation de SàT, vous pouvez partager des fichiers même avec des personnes qui n'ont pas de compte.

Quelques notes

Le transfert de fichier n'est pas encore chiffré, mais c'est prévu rapidement avec OX (OpenPGP) ou OMEMO.
La fonctionnalité de base est là et fonctionne, mais il y a encore des améliorations prévues à plus ou moins long terme : des quotas pour les utilisateurs, la synchronisation de fichiers, le chiffrement de bout en bout, ou encore la recherche avancée.

Tester

Vous trouverez sur le wiki les instructions sur comment utiliser cette fonctionnalité (en anglais).

Bien sûr vous aurez besoin de la version de développement pour tester. N'hésitez pas à demander de l'aide sur le salon SàT : sat@chat.jabberfr.org (ou avec un butineur).

Un paquet est désormais disponible pour Cagou sur AUR pour les utilisateurs d'Arch Linux, un grand merci à jnanar pour ceci.

Besoin d'aide !

SàT est un très gros projet, avec de fortes racines éthiques. Il est unique sur plus d'un point, et nécessite beaucoup de travail. Vous pouvez aider à sa réussite soit en nous soutenant sur Liberapay soit en contribuant (jetez un œil au site officiel ou venez sur le salon pour plus d'infos).

Le prochain billet sera à propos de la sortie de la version alpha, restez en ligne ;)

Click to expand… Click to reduce…

Click to reduce…

Parmi les nombreuses nouveautés et évolutions de Salut à Toi pour la version 0.7 à venir, une a un particulièrement grand potentiel : Libervia (l'interface web) est devenu un cadriciel web (ou « framework web »).

« Mais il y en a déjà plein ! » vous entends-je dire… C'est vrai, mais celui-ci est décentralisé.

Construire sur du standard, avoir des outils pour créer décentralisé

Utiliser les comptes existants

Libervia s'appuie donc sur SàT et XMPP pour aider à construire voire reconstruire le web. Quel est l'intérêt ? Et bien déjà l'authentification, chose nécessaire sur la plupart des sites de nos jours, utilise le compte que vous avez déjà. Non je ne parle pas du compte sur le gros truc bleu ou l'oisillon piailleur, mais bien de votre compte XMPP, celui que vous utilisez avec SàT, Movim, Gajim, Conversations ou encore Pidgin, celui dont les données peuvent être chez vous dans votre salon, et avec lequel vous pouvez utiliser n’importe quel nom, celui avec lequel vos faits et gestes ne sont pas épiés.

Le ou la développeur/euse n'a donc pas besoin de gérer cela, et les utilisateurs n'ont pas à recréer un compte à chaque site ou à utiliser un compte centralisé (et ainsi dire aux aspirateurs à données du net où, quand et à quoi ils se connectent).

Autre avantage : on profite de l'existant ; si vous voulez intégrer d'autre moyens de vous authentifier (par exemple utiliser vos comptes GNU/Linux), vous n'avez qu'à activer ce qui va bien sur votre serveur (voir cette liste pour prosody, vous trouverez certainement une liste équivalente pour les autres serveurs.).

pubsub, la base de données décentralisée

XMPP n'est pas une technologie, mais un ensemble de technologies cohérentes, et pubsub est l'une d'elles. Pour mémoire, il s'agit d'enregistrer des données (ou « items ») dans des « nœuds » (qu'on peut voir comme des tables ou collections dans les bases de données), qui sont sur des services.

Un service pouvant être n'importe où sur le réseau, au même endroit que votre serveur web, à l'autre bout de la planète, sur l'intranet ou sur un .onion dans le réseau Tor. Bien sûr il est possible de garder des données localement si nécessaire, notamment pour le cache.

le cache parlons en justement, pubsub a une propriété très intéressante : on peut s'abonner à un nœud pour être prévenu des modifications sur celui ci (ajout/modification ou suppression de données). Ceci permet à Libervia d'avoir un système de cache automatique : une page peut être mise automatiquement en cache et celui-ci peut-être invalidé dès qu'une modification a lieu. Voilà encore de quoi simplifier la vie du développeur, et améliorer les performances côté utilisateur.

faciliter la vie

Libervia a été pensé pour faciliter la vie des développeurs.

changer l'apparence

Le système est entièrement basé sur un moteur de modèles (jinja2), qu'il est très facile d'étendre pour faire de nouveaux thèmes (du simple changement de CSS à la transformation de toute la structure des pages). Il suffit de créer un répertoire avec le nom du thème et de modifier ce que l'on souhaite, et uniquement ce que l'ont souhaite : les pages du thème par défaut vont être utilisées si nécessaire.

Intégration entre serveur et client

Un certain nombre d'outils sont présents pour faciliter l'intégration entre la partie cliente (dans le butineur) et la partie serveur (HTTP). Ainsi par exemple, il suffit de déclarer "dynamic = True" dans votre page Libervia (côté serveur), pour activer automatiquement un système de communication dynamique avec le navigateur (basé sur les websockets). Une méthode permet d'envoyer des données n'importe quand à la page, et une autre est appelée quand des données sont émises depuis le navigateur.

Ceci sera encore plus poussé dans la version 0.8, avec l'intégration prévue de transpileurs Python vers Javascript. Libervia utilise jusqu'ici Pyjamas, un projet qui n'est plus maintenu et qui se base sur un Python 2 obsolète. Pour éviter d'être bloqué sur une seule option, le choix sera laissé au développeur d'utiliser un transpileur Python vers Javascript (Brython et Transcrypt sont prévus), du Javascript simple (dit « vanilla »), ou s'il ou elle aime se faire du mal, un cadriciel Javascript à la mode.

Gérer les tâches communes

Un système de traduction est intégré nativement (utilisant Babel), ainsi que des filtres pour les dates, le rendu d'interfaces venant du backend, ou encore la création de formulaires.

Les modèles sont prévus pour êtres réutilisables, ainsi il est simple d'intégrer, par exemple, des commentaires dans une page.

Un écosystème en symbiose

Je m'arrête là pour les fonctionnalités, même si la liste n'est pas finie (il est par exemple possible de générer des sites statiques à la manière d'un Pelican ou d'un Hugo).

Ce nouvel outil a déjà été mis en pratique dans certaines des nouveautés de la version à venir, notamment avec le gestionnaire de tickets et de demande d'intégration de patch (« merge requests ») mentionnés précédemment.

La prochaine version de Salut à Toi est un aboutissement, c'est la première version prévue pour être utilisée en production, et constitue désormais tout un écosystème de communication, de création et de travail collaboratif, compatible avec le reste de la famille XMPP.

Si vous voulez vous tenir à jour vous pouvez consulter mon blog (qui est fait avec Libervia) ou nous rejoindre sur le salon sat@chat.jabberfr.org.

Si vous voulez nous soutenir, vous pouvez soit adhérer à l'association, soit nous aider sur Liberapay.

Click to expand… Click to reduce…

Click to reduce…

Radio Prague vient de mettre en ligne une émission d'environ 10 min sur la vie privée où j'ai été interviewé pour parler de Salut à Toi.

Je suis vraiment content de l'émission qui est claire, bien expliquée, et pas trop technique . la journaliste a très bien compris le projet (ce qui n'est pas évident, il faut bien le reconnaître), et a fait du beau travail.

Vous pouvez l'écouter et la lire ici : http://www.radio.cz/fr/rubrique/panorama/la-disparition-de-la-vie-privee-nest-pas-inevitable

À écouter et faire circuler si le thème et/ou le projet vous intéressent. Comme indiqué dans lémission nous avons beaucoup de mal à nous faire connaître, aussi ce genre de chose nous aide bien.

Il y a beaucoup de choses qui ont avancé pour la version 0.7 à venir qui sera la première version dite « grand public » (comprendre, installable sans trop de difficultés et utilisable au jour le jour). J'espère trouver le temps de faire des articles pour expliquer les nouveautés comme un cadriciel (framework) web asynchrone/basé sur XMPP, la gestion des évenements ou encore des tickets (donc en décentralisé et basé sur XMPP). Si tout va bien une bêta est à attendre pendant l'été ou à la rentrée, ça sera l'occasion de s'organiser pour faciliter les contributions et mises en production.

À bientôt…

Click to expand… Click to reduce…

Click to reduce…

Click to expand… Click to reduce…

Click to reduce…

Click to expand… Click to reduce…

Click to reduce…

Salut à Vous !

Cela fait maintenant un peu plus d'un an que la campagne de financement participatif s'est achevée avec succès et que nous nous sommes engagés à développer une interface bureau/Android de « Salut à Toi », outil de communication multi-interfaces et multi-usages basé sur XMPP.

Il est temps de faire un petit état des lieux du développement. Vous trouverez en bas de cet article un lien vers une première version (pré-alpha) POUR TEST UNIQUEMENT.

Le contexte

Pour la petite histoire, nous entendions faire une campagne plus importante à l'origine quand nous avons décidé de faire un financement participatif. Mais suite à des discussions avec l'équipe d'Arizuka (plate-forme que nous avons choisie), nous avons largement réduit la somme demandée, ce qui s'est avéré judicieux puisque nous avons réussi la campagne : nous avons récolté 3 326,00 € sur les 3000 € demandés, soit 3 159,70 € après les frais.

Évidemment, cette somme est insuffisante pour vivre, aussi nous avons repris une activité salariée (j'en ai d'ailleurs parlé ici) et dû réduire le rythme de développement : je suis le seul développeur actif à l'heure actuelle (avec quelques contributions, notamment les accusés de réception et la authentification HTTP par XMPP par Chteufleur).

Ajouté aux choses annexes (gestion de l'association, écriture d'articles, projets liés, etc), ceci explique le temps de développement.

C'est aussi cette situation qui explique que nous avons réduit notre participation aux événements du Libre, ainsi vous ne nous avez pas vu au Fosdem cette année.

La plupart des contreparties promises aux soutiens ont été fournies (mais pas toutes, certaines n'ayant pas encore été réclamées). La somme reçue n'a pas encore été utilisée, sauf pour les frais fixes (serveurs, plate-forme de paiement des cotisations, banque).

Si ceci vous intéresse, vous trouverez les détails dans le compte rendu de la dernière assemblée générale extraordinaire de notre association.

Cagou

Comme déjà annoncé, la nouvelle interface de bureau et pour appareils mobiles (Android pour le moment) de SàT s'appelle « Cagou », un clin d'œil à l'outil Kivy que nous utilisons, et à cet oiseau emblématique de la Nouvelle-Calédonie, oiseau qui ne vole pas et qui aboie.

Développement

Cette partie est technique, vous pouvez passer directement à la suivante si cela ne vous intéresse pas.

Après une petite phase de prise en main de l’écosystème de Kivy, la première étape a été d'intégrer « Quick Frontend » (frontal rapide) qui est une base que nous utilisons, comme son nom l'indique, pour développer rapidement un frontal et factoriser le code (gestion du cache, de la liste des contacts (« roster » en XMPP), des widgets, etc.), puis d'intégrer le « bridge » (pont) qui est le nom que utilisons pour l'IPC qui permet la communication entre le « backend » (démon qui gère le cœur de SàT) et les frontaux.

Cette phase s'est relativement bien passée, elle a été accompagnée d'une réflexion sur l'architecture et l'interface utilisateur.

Une fois ceci à peu près utilisable, le port sur Android a pu commencer.

Les choses ont été un peu plus compliquées. La communauté Kivy a créé plusieurs outils pour développer sur cette plate-forme, dont python-for-android (outils de compilation et empaquetage) et Buildozer (outil multi-plateformes qui facilite l'utilisation du premier). La prise en main de ces outils demande quelques efforts, surtout pour un projet déjà en place (c'est nettement plus simple quand on commence directement avec Kivy et le port Android).

Il y a 2 « chaînes » de développement pour Android, l'ancienne et la nouvelle. Après des premiers tests non concluants avec la nouvelle, elle a été temporairement mise de côté pour l'ancienne le temps de développer les bases du port.

Les dépendances en Python pur s'importent facilement, mais dès que ça se complique un peu, il faut faire des recettes (« recipes ») pour indiquer à python-for-android comment faire la compilation. Heureusement, la plupart de celles nécessaires pour SàT (en particulier Twisted) étaient déjà disponibles, il a toutefois fallu les mettre à jour.

Une fois ces questions de dépendances et de chaîne de compilation réglées, et après le plaisir de voir un premier .apk apparaître (mais non fonctionnel). 2 autres gros problèmes se sont posés : D-Bus qui est le « bridge » principal n'est pas utilisable sur Android, et comment faire fonctionner backend et frontal en même temps ?

Étant novice pour le développement sur Android, j'ai dû lire beaucoup de documentation (qui ne manque pas heureusement) et après un premier essai avec un nouveau bridge « embedded » permettant d'avoir backend et frontal dans le même processus, c'est finalement l'écriture d'un bridge « pb » pour perspective broker, IPC de Twisted, qui s'est révélé être la meilleure solution. L'IPC d'Android est aussi une piste à explorer à l'avenir.

Pour lancer le backend, Kivy fourni des outils permettant de le lancer comme service Android, ce qui permet de le garder en arrière plan et de pouvoir gérer les messages et autres activités quand l'interface n'est pas visible pour l'utilisateur (ce qui signifie sur Android que l'interface est gelée jusqu'à ce qu'elle soit de nouveau sélectionnée par l'utilisateur).

Cette section est déjà bien longue, aussi je vous passe les autres difficultés (comme l'absence de widget gérant le HTML), parlons maintenant de l'interface.

L'interface

Cagou est donc utilisable sur bureau (GNU/Linux, mais probablement d'autres plates-formes également) et sur Android.

La version actuelle est une pré-alpha, l'.apk plus bas est fourni uniquement pour se faire une idée. Elle est très boguée, ne vérifie pas encore les certificats sur serveur, les enregistrements SRV ne sont pas pris en compte sur Android, etc. Elle est fournie pour d'une part montrer l'avancement, et d'autre part profiter des retours suffisamment tôt dans le développement pour prendre une bonne direction.

concepts de base

L'interface de Cagou est inspirée de celle de l'excellent Blender. En particulier la sélection de widget et la possibilité de faire des divisions à volonté en faisant glisser les bords du widget. Les grosses barres actuelle devraient disparaître à terme pour un bouton plus discret, probablement là encore inspiré de Blender. L'idée est qu'un utilisateur novice puisse changer de widget intuitivement, et qu'un utilisateur avancé puisse utiliser cette fonctionnalité.

séparation de widdgets

La liste des contacts n'est pas l'élément principal de l'interface, elle peut être affichée si souhaité, mais n'est pas nécessaire à l'utilisation de Cagou.

Le menu en haut, pour le moment tout le temps visible, ne devrait être disponible que sur bureau, sur Android le bouton menu ou un bouton flottant vont probablement le remplacer d'ici la sortie stable.

Si vous avez des notifications, elles apparaissent pendant quelques secondes en haut, mais vous pouvez le lire en prenant votre temps en caressant la tête du cagou qui apparaît alors en haut à gauche.

une notification dans Cagou

Dans le cas d'événements nécessitant votre intervention (par exemple une autorisation d'accès via XMPP sur un site), un cagou apparaîtra sur la droite, et le dialogue n'apparaîtra qu'après l'avoir touché. L'idée est de ne jamais avoir de fenêtre modale (type « pop-up ») qui surgit et vole le focus alors que vous faites autre chose. Ces dernières n'apparaissent que suite à une action de l'utilisateur.

Dans le cas d'Android, il est possible que ces notifications soient remplacées par le système de notification natif, mais le choix n'est pas arrêté puisque l'historique des messages ne serait alors plus disponible.

Pour changer de mode (de widget), il suffit de cliquer sur le bouton en haut à gauche du widget actuel. Il n'y a actuellement que 4 widgets : le sélecteur qui affiche tous ceux disponibles, la configuration, la liste de contacts, et le chat. D'autres sont à venir, en particulier le blogage.

sélection du widget/mode

À l’intérieur d'un widget (uniquement pour la messagerie instantanée pour l'instant), il est possible de faire un mouvement de glisser horizontal pour passer d'une conversation ouverte à une autre.

exemple d'un glissé de widget dans Cagou

Pour le moment ça n'est pas évident à utiliser la première fois (il faut faire un mouvement vif), il y a des petits réglages à prévoir.

Comme pour le reste de SàT, Cagou est prévu dès l'origine pour fonctionner avec des greffons et être facilement extensible. Tous les widgets et système d'envoi de fichiers (voir plus bas) sont des greffons.

messagerie instantanée (chat)

Comme nous voulons une interface utilisable sur petits écrans, simple, mais qui ne sacrifie pas les fonctionnalités, il faut trouver un compromis entre les informations affichées/ables à l'écran et les éléments/boutons permettant des actions. Trop d’éléments compliquent l'interface et prennent de l'espace, mais trop peu rendent les actions difficiles d'accès.

La disposition choisie actuellement (qui peut évoluer) consiste en un en-tête avec une barre de saisie et un bouton (en plus du sélecteur de widgets), le corps avec les messages, et une barre de saisie avec un bouton également.

Pour discuter avec un ou des contact(s), entrez des lettres faisant partie de son nom (n'importe où dans le nom). Pour le moment uniquement les identifiants (« jid ») et les conversations déjà ouvertes sont cherchés, mais à terme la recherche se fera également dans les noms, surnoms et dans les marque-pages.

sélection d'un contact pour une discussion instantanée

Cagou détecte si vous voulez parler à une personne seule ou dans un salon de discussion, et s'adapte en conséquence.

Le chiffrement de bout en bout est de la partie, mais uniquement avec OTR (v2) à l'heure actuelle. Il est prévu d'intégrer OX (OpenPGP moderne) et OMEMO, mais il n'est pas certains que ça sera disponible pour la prochaine version (ça sera peut-être pour la 0.8). Pour l'activer, il suffit de cliquer sur le cadenas, ce dernier sera fermé si la conversation est chiffrée, et aura un point d'interrogation si votre correspondant n'est pas authentifié.

Passons directement à la barre de saisie. Vous trouverez sur la droite un bouton « + » qui sert pour le moment à ouvrir le dialogue d'envoi d'élément.

Ce dialogue comporte 2 boutons en haut, qui permettent de choisir si vous voulez téléverser votre fichier ou l'envoyer directement à un correspondant en pair à pair. Un texte en dessous indique en langage clair où votre fichier transitera, et si le chiffrement intervient (à l'heure actuelle tout est en clair pour les fichiers).

Le message texte est important pour que l'utilisateur comprenne bien où vont ses données, c'est une indication que l'on va sûrement placer à divers endroits stratégiques.

dialogue d'envoi de fichier sous Android

Les boutons en dessous sont les types d'envoi. Sur bureau il n'est actuellement possible que d'envoyer un fichier de votre arborescence, mais sur Android il est possible également d'envoyer une photo de votre galerie, d'en prendre une nouvelle ou de faire une vidéo, et d'enregistrer un message audio.

Voici à quoi ressemble l'enregistrement de messages :

enregistrement d'un message audio

et autour

En plus du travail sur Cagou lui-même, d'autres travaux ont été effectué.

Désormais indispensable avec l'utilisation sur appareils portables, la copie carbone a été implémentée. La gestion des archives sur le serveur est elle implémentée depuis longtemps pour le blogage, mais pas encore pour les messages, ça sera fait d'ici la sortie de la version stable.

La gestion des petits fichiers binaires (« BoB » pour « Bits of Binary ») est désormais disponible, son implémentation a notamment été motivée parce qu'ils sont utilisés par Movim.

Comme indiqué plus haut, les accusés de réception et l'authentification HTTP ont été implémentés par Chteufleur.

Depuis la 0.6.1 la gestion des messages a été améliorée, préparant notamment le terrain pour des fonctionnalités comme la correction du dernier message, prévue pour la version stable.

Plus récemment la gestion des composants (pour préparer les passerelles) et des blogs statiques sont également arrivés, mais nous en parlerons peut-être une autre fois.

soutien

C'est un appel que nous faisons souvent mais qui n'est pas toujours entendu, de l'aide serait grandement appréciée.

Ce peut être aussi simple que venir discuter avec nous (notre salon est à sat@chat.jabberfr.org, disponible en cliquant sur ce lien).

Si vous avez de quoi, une contribution financière serait bien sûr utile, nous avons récemment ouvert un compte sur Liberapay, suite a discussion résumée dans le compte rendu de l'A.G. lié plus haut. Notre objectif est de réussir dans un premier temps à travailler un jour par semaine sur SàT et de compenser la perte de salaire par des dons.

Vous pouvez aussi adhérer à notre association, toutes les infos sont par ici. Vous choisissez le montant de la cotisation (entre 0 et 100 €).

Et bien sûr des contributions, en particulier du développement, mais aussi des traductions, du graphisme, du thème CSS, de l'administration des serveurs. La plupart du développement est fait en Python, et c'est participer à un outil que vous utiliserez potentiellement tous les jours.

Parler de notre association et projet autour de vous est toujours utile.

Je crois que l'essentiel est dit pour cette fois, j’essaierai de tenir informé avec des billets moins longs les prochaines fois.

Ah, et le lien vers la pré-alpha actuelle (encore une fois: POUR TEST UNIQUEMENT): https://www.goffi.org/public/Cagou-0.1-debug.apk

Click to expand… Click to reduce…

Click to reduce…

Salut à vous,

Cagou commençant à prendre sérieusement forme, il est temps de faire un billet sur l'avancement.

Avant le début du développement de l'interface elle-même, des changements nécessaires ont été faits en particulier sur la gestion des messages. Outre la gestion des langues dont j'ai parlé dans des précédents billets, le plus important est que nous pouvons désormais changer l'état d'un message après réception, ou y faire référence. Ceci permet d'implémenter des fonctionnalités comme les accusés de réception, ce qui a été fait par une contribution de Chteufleur (merci :)). D'autres fonctionnalités qui attendaient comme la correction du dernier message vont bientôt pouvoir suivre.

Il était nécessaire de faire ce travail avant d'implémenter la messagerie instantanée sur Cagou, pour pouvoir partir sur de bonnes bases.

Ensuite il a fallu intégrer l'interface sous Kivy à SàT, et en particulier D-Bus et QuickFrontend, notre modèle pour faire des frontaux en Python.

Tout ceci s'est relativement bien passé, et voici une petite vidéo pour vous mettre en appétit :

Quelques explications maintenant.

Comme vous le voyez, l'interface peut-être divisée facilement. Cette idée est inspirée de l'excellente interface de Blender, et permettra de s'adapter facilement à un petit ou grand écran en choisissant le nombre de widgets et leur disposition.
Au lieu d'être un logiciel discret qu'on utilise uniquement quand on veut répondre à quelqu'un, Cagou est une interface qui s'utilise principalement en plein écran, avec une disposition adaptée à la situation et les outils importants directement visibles (si la taille de l'écran le permet).

Autre point important, la liste de contacts n'est pas l'élément central comme c'est souvent le cas dans les logiciels de messagerie. Vous pouvez y accéder en sélectionnant le widget, voire la mettre sur le côté pour reproduire le comportement traditionnel, mais elle n'est pas affichée par défaut et n'est pas indispensable.

sélection de widget

Tous les widgets sont des greffons, a terme il devrait être possible d'en télécharger, ou de changer complément le fonctionnement d'un widget de base. Comme effet de bord, et surtout grâce au travail de l'équipe derrière Kivy, Cagou sera une plate-forme qui permettra d'échanger facilement des scripts Python sur Android (reste à voir comment on va gérer les permissions).

En ce qui concerne les notifications, le fonctionnement va être différent sur bureau et sur les plates-formes qui ont déjà un système de notification (comme Android). Dans ce dernier cas, le système de la plate-forme va être utilisé.
Sur bureau, un en-tête spécifique est utilisé. 2 icônes de Cagou (merci à Muchoslava pour ses contributions) peuvent apparaître : une à gauche pour les notes (c.-à-.d les messages court qui ne s'affichent que quelques secondes), et une à droite pour les notifications plus importantes, nécessitant l'action de l'utilisateur.
Un clique sur l’icône de gauche permet d'afficher les 10 dernières notes, et un sur l’icône de droite affiche la notification importante suivante.

Ceci a été pensé pour éviter les popups, ces dernières ne sont affichées que suite à une action de l'utilisateur, et n’apparaissent pas d'elles même si un quelconque événement les déclenche.

exemple de notification

Les menus ont également été implémentés, ils apparaissent en haut sur bureau. Sur petits écrans (téléphones), ils ne seront sûrement visibles que suite à l'appui de la touche idoine.

Grâce au fonctionnement de Salut à Toi, ceux-ci permettent déjà de faire des actions de base comme ajouter ou modifier un contact et avancées comme piloter son serveur.

Enfin le lancement d'une conversation peut se faire de plusieurs manières. On peut en commencer une en cliquant sur un contact dans le widget « liste de contacts », ou en tapant son jid dans un widget « chat » (il devrait rapidement être possible de taper quelques lettres pour avoir les suggestions). Les conversations ne se ferment pas quand on change de widget, on peut accéder aux conversations en cours en faisant passer son doigt (ou sa souris pendant un clique) rapidement vers la droite ou la gauche, cf. la vidéo ci-dessous. Il sera bientôt possible de les fermer via un menu dédié.

Voilà l'état des lieux actuel. Il y a déjà eu beaucoup de travail, et l'interface commence à être vraiment utilisable. Côté bureau le plus gros est fait, il s'agit maintenant d'adapter l'interface aux fonctionnalités (afficher l'accusé de réception par exemple), et à faire de nouveaux widgets. Un gros morceau reste toutefois l'affichage du contenu HTML, vu que ça n'est pas géré de base par Kivy (mais il y a différentes solutions possibles).

En ce qui concerne Android, il va y avoir une partie qui risque d'être un peu difficile pour faire le port, mais je ne m'inquiète pas plus que ça.

J'envisage également de faire un port sur Ubuntu Touch, j'ai commandé à cette fin une tablette d'occasion qui devrait me permettre de l'installer (ce n'est pas une promesse, juste une éventualité).

Ah et bien sûr, Cagou va profiter des fonctionnalités de SàT, y compris le chiffrement de bout en bout (OTR pour le moment, mais OpenPGP est envisagé pour la 0.7, et peut-être OMEMO également).

Petite note pour les programmeurs : une fois la prise en main passée (qui n'est pas très difficile), j'apprécie beaucoup travailler avec Kivy, c'est souple, agréable à utiliser et ça fonctionne jusqu'ici très bien, félicitation aux équipes derrière.

Je conclus sur une bouteille à la mer : c'est un travail absolument énorme de travailler sur SàT, et à l'heure actuelle je suis pratiquement seul dessus, et en plus de mon emploi salarié. Le projet avance toujours à bon train, mais j'ai besoin d'aide. La base de code est importante, mais il n'est pas insurmontable de s'y mettre : Chteufleur mentionné plus haut a pu rapidement écrire des greffons et a fait les implémentations des XEP-0070 et XEP-0184.

Il est aussi possible de contribuer en dehors du code : empaquetage pour des distributions, tests, graphismes, traductions, installation de serveurs, etc. Contribuer à une bibliothèque utilisée par SàT (comme l'implémentation de XMPP dans Twisted ou Kivy) est également très utile.

Au passage, je rappelle à ceux qui ont participé à la campagne de financement, qu'ils peuvent nous contacter sur « contact chez salut-a-toi point org » pour réclamer leur contrepartie, ou la demander plus tard s'ils préfèrent.

À très bientôt pour la suite :)

Click to expand… Click to reduce…

Click to reduce…

Salut à tous,

la version 0.6.1 de Salut à Toi vient de sortir, et elle est conséquente malgré son numéro de version mineur. La prochaine version — qui est déjà bien entamée — sera la version « grand public » que nous annonçons depuis des années, autrement dit une version que nous voulons suffisamment stable pour être utilisée au quotidien, et suffisamment facile à installer pour être disponible pour un large public.

Vous pouvez toujours vous référer au journal des modifications (changelog) ou au dépôt pour avoir le détail, mais voici quelques unes des nouveautés et corrections principales :

  • plugin d'import extensible avec « importeurs » pour Dotclear et DokuWiki. Notez bien que grâce à l’utilisation des standards, ça peut vous être utile même si vous n’utilisez pas SàT pour afficher votre blog (c’est compatible avec Movim par exemple)
  • en plus de l'import Dotclear, la syntaxe wiki Dotclear est également disponible avec SàT désormais, elle vient s’ajouter à Markdown et XHTML.
  • inscription automatique à un flux PubSub pour les nouveaux comptes, ce qui évite d'arriver sur une page vide
  • MAM (XEP-0313) est implémentée pour PubSub, ce qui permet de remonter dans les articles et de faire des recherches de manière beaucoup plus souple et puissante. Notez que MAM n’est pas encore disponible pour la messagerie instantanée, ce sera le cas pour la 0.7
  • meilleure détection de la version du dépôt utilisée
  • jp (l’interface en ligne de commande) a désormais une option --output qui permet de spécifier le format de sortie (par exemple du JSON ce qui permet de facilement parser le résultat avec une autre commande). C’est encore peu utilisé mais la base est là.
  • jp : nouvelles commandes pour importer un blog (import), (ré-)éditer un nouveau/ancien billet (edit) ou voir l’aperçu mis à jour en temps réel (preview). Pour plus d’infos, référez-vous au billet d’explication qui montre comment publier sur votre blog avec Vim ou autre
  • jp : des nouvelles commandes également pour la gestion du roster, qui permettent de l’afficher (get), d’avoir des statistiques (stats) ou de le nettoyer (purge)
  • jp : la commande « message » a été déplacée vers « message send » par cohérence avec les autres commandes, et parce qu’un « message get » est à prévoir
  • jp : les codes de retour utilisent maintenant des constantes, afin qu’ils soient plus utiles
  • Primitivus (interface console) : détection d’un « coller » (une validation est nécessaire dans ce cas, ce qui évite l’envoi accidentel d’un mauvais message comme un mot de passe copié peu avant) et gestion du mode « bracketed paste »
  • Libervia (interface web) : une nouvelle option « allow_registration » permet de désactiver la création de nouveaux comptes, pratique si vous êtes seul sur votre instance, ou si vous créez les comptes par vos propres moyens
  • Libervia : affichage d’un message avec compteur en cas de perte de connexion avec le serveur
  • Libervia : utilisation d’une nouvelle favicon avec un compteur de notifications visible
  • Libervia : correction de la connexion avec un compte (jid) extérieur. Cette fonctionnalité très demandée nous avait causé de gros problèmes à la sortie de la 0.6.0, ils devraient être désormais réglés.
  • Libervia : il est maintenant possible de rediriger les pages ou d'intégrer un répertoire local dans Libervia. C’est ce qui permet d’afficher directement le blog au lieu de la page d’enregistrement sur www.goffi.org.
  • Libervia : gestion des chaînes TLS (Let's Encrypt, si tu nous lis…)
  • Libervia (blog): gestion des étiquettes (tags), y compris la recherche

Voilà pour un aperçu, et c’est loin de couvrir toutes les améliorations de la 0.6.1.

En lisant ceci vous aurez peut-être une petite idée de la quantité de travail nécessaire pour faire avancer un projet comme celui-ci, sachant que nous ne sommes que 2 (et que pour la 0.7 je suis pratiquement tout seul). Aussi si vous voulez participer à un projet éthique et qui refuse de céder aux sirènes des grosses entreprises privatristes, contactez-nous (contact at salut-a-toi point org) ! Rejoignez-nous sur notre salon MUC ! Venez nous aider, on en a grand besoin !

La version 0.6.1 n’est pas parfaite, elle a quelques problèmes (connus ou non), mais nous avons préféré sortir cette version qui malgré tout fonctionne, pour nous concentrer sur la 0.7, qui sera la première version « grand public », annoncée depuis des années.

La version 0.7 passera par une phase de bêta test, et devrait apporter en particulier :

  • un ré-usinage des messages qui permettra d’implémenter de nombreuses extensions bloquées jusqu’ici, comme la correction du dernier message, ou les archives côté serveur (MAM). Cette partie est déjà finie

  • Cagou, l'interface bureau/appareils portatifs que nous avons promis suite au succès de notre campagne de financement participatif. Le développement est bien avancé, bientôt un billet sur le sujet

  • des passerelles de messagerie et de blog. Cela fait longtemps qu'on parle d'en faire, les premières devraient voir le jour dès que Cagou est disponible

En dehors de ça, il est probable que nous implémentions de nouveaux systèmes de chiffrement de bout en bout, en plus d'OTR qui est déjà disponible. OpenPGP est visé en particulier, ainsi qu'OMEMO.

Les grosses fonctionnalités comme l’organisation d’événements ou les calendriers partagés sont plutôt envisagées pour la version suivante.

Ah, et la nouvelle version est disponible comme d’habitude sur le FTP, sur PyPi ou directement depuis le dépôt.

Click to expand… Click to reduce…

Click to reduce…

Cela fait plusieurs fois qu’on me demande comment contribuer à SàT, le projet étant conséquent il n’est pas facile d’accès. Aussi voici un article d’introduction pour l’écriture d’un greffon pour le backend.

Il est très utile d’avoir lu l'article d’introduction sur l’architecture de SàT avant. L’intérêt de faire un greffon backend est qu’il fonctionnera avec tous les frontaux, autrement dit sur le web, sur le bureau, sur appareils portables (bientôt) voire en ligne de commande ou autre.

Nous allons faire un classique « Salut à Toi le monde ! » bien connu des développeurs.

avant de commencer, quelques remarques en vrac

Quelques remarques et notions utiles à savoir, ne vous inquiétez pas si vous ne comprenez pas tout du premier coup :

  • SàT est actuellement en Python 2, le passage à Python 3 ayant été bloqué principalement par Twisted jusqu’ici. Mais les choses ont beaucoup avancé récemment, et Twisted fonctionne désormais partiellement avec Python 3, la partie XMPP est aussi en cours de portage, et le passage à Python 3 pourra être envisagé pour SàT 0.8 (après la version « grand public » donc).

  • le style de code suit à peu près les conventions de la PEP 8, mais pas entièrement. En particulier les noms de méthodes utilisent le CamelCase pour rester cohérent avec le code de Twisted, et la limite des 80 caractères n’est pas respectée (il n’est pas impossible que cela change dans le futur), vous aurez plus de détails sur le wiki (notez bien la partie sur les docstrings).

  • le backend de SàT est entièrement asynchrone, en utilisant Twisted. C’est probablement le plus difficile à appréhender pour un débutant, et vous pouvez commencer en regardant comment font les autres parties du code pour comprendre les grandes lignes. La chose la plus importante à retenir est qu’il ne faut jamais faire de code « bloquant », c’est-à-dire long à s’exécuter, car ça bloquera tout le backend. S’il est indispensable de bloquer pour une raison ou une autre (un module tiers à utiliser par exemple), vous devrez utiliser des processus séparés. La documentation sur le site mentionné est relativement fournie quand vous vous sentirez d’approfondir le domaine…

  • la hierarchie du code (src) est actuellement comme suit:

    • bridge gère la communication avec les frontaux, c’est l'IPC (actuellement D-Bus mais d’autres options sont possibles)
    • core contient comme son nom l’indique le cœur du backend (le « Service » SàT, le client XMPP, les constantes, les exceptions spécifiques à SàT, la gestion des logs et de la traduction)
    • memory gère tout ce qui est conservation des données que ce soit en mémoire vive ou sur disque (via Sqlite pour le moment, mais d’autres options sont possibles)
    • plugins contient… les greffons, c’est à eux que l’on va s’intéresser par la suite
    • stdui contient les interfaces XMLUI de base (nous reparlerons de XMLUI plus bas)
    • test est le répertoire où sont comme vous vous en doutez les tests unitaires ou autre.
    • tmp est une hiérarchie que nous avons dû créer pour mettre du code temporaire destiné à être intégré par des projets tiers que nous utilisons, en particulier Wokkel à l’heure actuelle
    • tools est la hiérarchie un peu « fourre-tout » pour les choses utiles, en particulier XMLUI et les triggers dont nous reparlerons plus tard. La sous-hiérarchie « common » contient les modules utilisés/ables à la fois par le backend et les frontaux.
    • twisted enfin est uniquement utilisé pour l’intégration à Twisted
    • on parle souvent de profil ( profile en anglais et dans le code) qui correspond à un compte XMPP. En mode mono-utilisateur (Primitivus ou Cagou par exemple), cela peut correspondre à plusieurs comptes d’un même utilisateur (par exemple j’ai un profil jabberfr et un autre libervia.org pour mes 2 comptes correspondant). En mode multi-utilisateur (avec Libervia par exemple), cela correspond à des comptes d’utilisateurs différents.
    • à la notion de « profile » s’ajoute celle de « profile_key ». C’est en fait en mot clef qui indique un profil à utiliser (vous les trouverez dans les constantes avec PROF_KEY_XXX). En particulier PROF_KEY_DEFAULT indique d’utiliser le profil par défaut, et PROF_KEY_NONE indique une valeur non renseignée qui provoquera une exception si elle est utilisée avec getClient (voir plus bas).
    • dans les classes, on utilise souvent un attribut « host » (self.host la plupart du temps), qui correspond à l’instance du service SàT, et qui permet d'accéder à beaucoup de choses (le « bridge », la partie « memory », etc).
    • dans les méthodes, vous verrez souvent les paramètres « client » ou « profile ». « profile » correspond au nom du profil dont on a parlé plus haut, et client à l’instance du client XMPP et donc à la session associée à ce profil. On passe du profil au client en faisant « host.getClient(profile) » et du client au profil en faisant « client.profile ». Avant « profile » était systématiquement utilisé et placé en dernier paramètre (avec une valeur par défaut de C.PROF_KEY_NONE qui indique une valeur non renseignée). Désormais il a été décidé de toujours utiliser client comme premier argument, et profile uniquement quand c’est nécessaire (à l’entrée ou la sortie du « bridge » par exemple), aussi le code passe petit à petit à la nouvelle convention, et vous pouvez voir les 2 cas.
    • en début de fichier, il est souvent utile de faire ces imports :
        python from sat.core.constants import Const as C
        from sat.core.i18n import _, D
        from sat.core.log import getLogger log = getLogger( **name** )
        from sat.core import exceptions

La première ligne permet d’accéder aux constantes, avec C pour que ça reste court et lisible. La seconde importe la fonction gettext « _ » qui traduit le texte dans la langue locale au moment de son utilisation, et « D_  » qui indique qu’un texte est à traduire, mais que la traduction aura lieu plus tard dynamiquement (utile pour un menu par exemple, qu’on peut traduire différemment selon les profils). Les 2 suivantes instancient un loggeur qu’on peut utiliser assez classiquement avec log.[niveau](message), par exemple log.debug(u"mon message de debug") Enfin la dernière ligne permet d’utiliser les exceptions spécifiques à SàT, vous pouvez lire le code du module idoine pour plus d’infos.

Avec tout ça on a l’essentiel pour s’attaquer au code.

création du fichier et déclaration du plugin

La première chose à faire est de créer un fichier python dans le répertoire plugins et dont le nom commence par "plugin_". De tels fichiers sont automatiquement importés par le backend au démarrage, et à terme il devrait être possible de les mettre ailleurs (par exemple dans un dossier personnel) et de les télécharger et installer automatiquement. Vous constaterez que les greffons existant sont nommés avec leur type puis leur nom, et que ceux qui implémentent des XEPs prennent le nom de la XEP (par exemple plugin_xep_0045.py ).

Nous allons maintenant déclarer le greffon, pour celà nous utilisons une variable (un dictionnaire) nommée PLUGIN_INFO et placée en début de fichier. Voici un exemple d’en-tête avec celui du greffon XEP-0045 (le salon de groupe MUC) :

    PLUGIN_INFO = {
    "name": "XEP-0045 Plugin",
    "import_name": "XEP-0045",
    "type": "XEP",
    "protocols": ["XEP-0045"],
    "dependencies": [],
    "recommendations": [C.TEXT_CMDS],
    "main": "XEP_0045",
    "handler": "yes",
    "description": _(u"""Implementation of Multi-User Chat""")
}

  

voici les informations données:

  • name  : nom « lisible par un humain » donné au greffon
  • import_name  : nom court utilisé pour référencer ce greffon par ailleurs (depuis d’autres greffons par exemple) pour accéder à ce greffon par la suite, vous pourrez utiliser host.plugins[ nom d'import ], ainsi ici vous pourrez faire host.plugins["XEP-0045"]
  • type  : une information sur ce que qui est implémenté ; est-ce une XEP (type "XEP"), ou expérimentation (type "EXP") ? L’information n’est pas encore utilisée, mais elle devrait permettre de filtrer les greffons à l’avenir, quand ils seront téléchargeables depuis un dépôt. Les types courants ont leur constante de la forme PLUG_TYPE_*
  • protocols  : une liste de protocoles implémenté le cas échéant. Les XEP sont toujours référencées sous la forme XEP-0xxx avec « XEP » en majuscules.
  • dependencies  : autres greffons indispensables pour faire fonctionner celui-ci. C'est une liste de noms correspondant au « import_name » voulus. Ces greffons seront importés avant celui en cours, et s’ils ne sont pas disponibles l'import échouera
  • recommendations  : greffons non indispensable pour faire fonctionner celui en cours, mais qui apportent des améliorations si présents. Fonctionne de la même manière que dependencies sauf que l'import n’échouera pas si ces greffons ne sont pas disponibles
  • main  : classe principale du greffon, c’est cette classe qui sera instanciée à l'import et qu’on référencera en faisant host.plugins[XXX]
  • handler  : s’il vaut "yes", indique que le greffon va réagir à des requêtes XML particulières, toute autre valeur indique le contraire. Nous reparlerons des handlers plus tard
  • description : texte décrivant ce que fait le greffon. Vous remarquerez la présence du _() qui est utilisé pour la traduction (gettext)

Pour notre greffon que nous allons mettre dans un fichier plugin_misc_salut_le_monde.py placé dans src/plugins, nous allons utiliser le code suivant :

    #!/usr/bin/env python2
# -*- coding: utf-8 -*-

from sat.core.constants import Const as C
from sat.core.i18n import _
from sat.core.log import getLogger
log = getLogger(__name__)

PLUGIN_INFO = {
    "name": u"Salut le monde",
    "import_name": "SALUT_MONDE",
    "type": C.PLUG_TYPE_MISC,
    "main": "Salut",
    "handler": "no",
    "description": _(u"""Plugin to learn basic concepts of SàT""")
}


class Salut(object):

    def __init__(self, host):
        log.info(_(u"Salut à Toi le monde !"))

  

C'est à peu près le greffon le plus simple que vous puissiez faire. En lançant SàT, vous devriez voir quelque chose similaire à ceci dans les logs :

    2016-07-05 19:15:31+0200 [-] [sat.core.sat_main] importing plugin: Salut le monde
2016-07-05 19:15:31+0200 [-] [sat.plugins.plugin_misc_salut_le_monde] Salut à Toi le monde !

  

XMLUI

Bon tout ça c’est bien gentil, mais il serait quand même sympa d’avoir notre message sur les frontaux.

Comme vous le savez, SàT est multi-frontaux, autrement dit un message peut être affiché sur Libervia (interface web), sur Primitivus (interface console), (bientôt) sur Cagou (interface bureau/appareils portatifs) ou encore dans Emacs avec l’interface « Sententia ». Tous ces frontaux affichent les informations différemment : qui avec du texte directement, qui en HTML, qui via un cadriciel graphique, etc. Il serait ennuyant de devoir refaire l’affichage de l’interface pour chaque frontal, aussi nous avons créé un mini langage XML qui permet de décrire une interface de manière générique : XMLUI. C’est un langage descriptif simple et qui reste volontairement de haut niveau pour que le frontal affiche l’information comme il l’entend. On décrit des choses comme des textes, des JID, ou des listes.

XMLUI contient 2 classes « mères » principales : un widget (texte ou mot de passe par exemple), et un « container » (conteneur) qui dispose les widgets d’une certaine façon (verticalement, 2 par 2, en liste, etc). Vous pouvez lire le code gérant cela dans tools.xml_tools.

La création d’une interface se veut assez simple, et xml_tools contient des méthodes pour aider. Par exemple, l’interface suivante utilisée dans l'UI standard pour le gestionnaire de profils (dans stdui.ui_profile_manager) permet de demander un mot de passe si nécessaire :

    form_ui = xml_tools.XMLUI("form", title=D_('Profile password for {}').format(profile), submit_id='')
form_ui.addPassword('profile_password', value='')
d = xml_tools.deferredUI(self.host, form_ui, chained=True)
d.addCallback(self._authenticateProfile, profile)
return {'xmlui': form_ui.toXml()}

  

Rien de bien compliqué. Quelques remarques sur ce code :

  • on utilise D_ pour le titre, car il peut être traduit différemment d’un profil à l’autre
  • une UI XML peut être soumise (c.-à-d. un résultat est envoyé par le frontal au backend, le mot de passe par exemple), et la méthode appelée dans le backend retourne un dictionnaire. Si celui-ci est vide, le dialogue est fini, s’il retourne une nouvelle interface avec la clef « xmlui », celle-ci sera affichée.
  • pour soumettre une interface on peut soit enregistrer une callback via host.registerCallback (l’identifiant retourné sera utilisé avec submit_id au moment de la création de l'UI), soit utiliser une XMLUI « déferrée » comme ici, ce qui permet d’utiliser le mécanisme de Deferred de Twisted, submit_id doit dans ce cas être une chaîne vide.

Pour notre greffon de test, nous n’avons pas besoin de quelque chose nécessitant une réponse, nous pouvons utiliser la méthode xml_tools.note qui facilite les choses.

Pour utiliser une XMLUI, il y a plusieurs méthodes : création d’une callback via un menu par exemple, ou envoi d’un signal aux frontaux pour leur indiquer qu’il faut afficher l’interface, c’est ce que nous allons faire ici avec la méthode host.actionNew  :

    host.actionNew({"xmlui": xml_tools.note(u"Salut à Toi le monde !").toXml()}, profile=profile)

  

Remarquez le toXml() nécessaire pour convertir l'UI XML en texte utilisable à travers le bridge.

Nous avons presque notre greffon qui affiche un message, mais il y a encore un problème à régler : le greffon est importé au chargement du backend, un moment où les frontaux ne sont pas encore actifs, aussi nous ne pouvons pas afficher le message dans l'__init__, il serait envoyé dans le vide.

La solution est simple : nous allons afficher le message quand le profil est connecté. Dans ce cas, la méthode profileConnected, si elle existe, est appelé pour chaque greffon, avec pour seul argument le nom de profil.

Notre code devient donc :

    #!/usr/bin/env python2
# -*- coding: utf-8 -*-

from sat.core.constants import Const as C
from sat.core.i18n import _
from sat.core.log import getLogger
log = getLogger(__name__)
from sat.tools import xml_tools

PLUGIN_INFO = {
    "name": u"Salut le monde",
    "import_name": "SALUT_MONDE",
    "type": C.PLUG_TYPE_MISC,
    "main": "Salut",
    "handler": "no",
    "description": _(u"""Plugin to learn basic concepts of SàT""")
}


class Salut(object):

    def __init__(self, host):
        self.host = host
        log.info(_(u"Salut à Toi le monde !"))

    def profileConnected(self, profile):
        msg = u"Salut à vous {} et le monde !".format(profile)
        self.host.actionNew({"xmlui": xml_tools.note(msg).toXml()}, profile=profile)

  

En lançant Primitivus, voici ce que l’on voit :

résultat avec Primitivus

…et avec Libervia :

résultat avec Libervia

Vous aurez un message équivalent sur les autres frontaux.

À savoir également

Nous n’irons pas plus loin pour ce premier guide afin de ne pas être trop indigeste, mais il peut être utile d’expliquer succinctement d’autre éléments :

  • il y a des paramètres que vous pouvez utiliser pour configurer votre greffon. Ils sont déclarés en XML, et il existe 2 types : « general » pour un paramètre global du backend (par exemple le port d’un serveur), et « individual » pour les paramètres qui changent avec les profils, ce qui est le cas le plus courant (par exemple le JID est un paramètre individuel).

  • il y a un mécanisme de menus qui permettent d’associer une action (souvent un XMLUI) à un menu. Il y a plusieurs types de menus (regardez les constantes C.MENU_*) : C.MENU_GLOBAL sera le menu principal, tandis que C.MENU_JID_CONTEXT sera utilisé en cliquant sur un jid (un contact par exemple).

  • si votre greffon gère une tâche longue quelconque (par exemple un transfert de fichier), il y a un mécanisme pour gérer les progressions, regardez les méthodes progress* pour avoir une idée de leur fonctionnement

  • autre notion importante : la limite de sécurité. Il s’agit d’un simple entier qui indique si une méthode peut être utilisée en environnement restreint ou pas. Pour un frontal utilisé par un simple utilisateur ça n’est a priori pas utilisé, mais un frontal multi-utilisateur comme Libervia, ça permet de limiter ce qui peut être changé (le port d’un serveur ne doit pas être changé tandis que la syntaxe favorite peut l’être par exemple). Vous trouverez des explications sur le wiki.

  • si votre greffon réagit au XML qui passe (ce qui est probablement — mais pas forcément — le cas si vous implémentez une XEP), il agit en « handler » et doit déclarer « "handler": "yes" » dans PLUGIN_INFO. Au moment de l'import, la méthode getHandler sera appelée et elle doit retourner l'instance à utiliser. Pour gérer « disco », votre classe doit implémenter wokkel.disco.IDisco et les méthodes getDiscoInfo et getDiscoItems, référez-vous au code des différents greffons pour bien comprendre.

  • enfin les triggers permettent de modifier le comportement de SàT (du cœur ou d’un plugin), ce sont des méthodes qui sont appelées à certains endroits (d’autres projets parlent parfois de « hook »). Ils peuvent être utilisés par exemple pour modifier un message (le greffon OTR les utilise pour chiffrer le contenu). Il ne faut les utiliser que si nécessaire, car ils compliquent un peu la lecture du code.

Et bien entendu, vous pouvez toujours venir chercher de l’aide sur le salon MUC de SàT : sat@chat.jabberfr.org.

À vos claviers ! Et n’oubliez pas de nous faire signe si vous vous lancez dans quelque chose :)

P.-S. : les morceaux de codes ne sont pas mis en couleurs à l’heure actuelle, j’envisage de faire un greffon pour intégrer pygments, mais pour le moment la priorité est le développement de Cagou.

Click to expand… Click to reduce…

Click to reduce…

Une des belles choses qu’Internet a apporté — ou tenté d’apporter parce que certains y mettent des barrières virtuelles [1] — est la relative abolition des frontières. Il est devenu facile de communiquer avec des gens de tous pays ou presque, de partager des œuvres, de s’informer, ou encore de travailler ensemble à des milliers de kilomètres de distance. Le moyen de communication le plus utilisé est sans aucun doute l’écrit.

Quand on écrit quelque chose et qu’on le diffuse sur Internet, que ce soit un article sur un blog, de la documentation pour un logiciel, une information à communiquer, ou tout autre document public, on souhaite souvent que sa diffusion soit la plus large possible. Or à notre époque si on veut être lu, il faut adopter la culture de l’internet, publier sur les sites/réseaux en vue de l’internet et utiliser la langue de l’internet.

— la langue de l’internet ? Quelle langue de l’internet ?

— l’anglais bien sûr ! si tu veux être lu, point de salut, c’est l’anglais ou l’indifférence

— mais ceux qui ne parlent pas anglais ?

— pas anglais ? Allons allons, un peu de sérieux, tout le monde parle anglais de nos jours !

Oserais-je avancer le contraire ? Après tout il y a une commodité certaine à utiliser une langue commune, voire n’ayons pas peur des mots, universelle. Pourquoi s’embêter à traduire les choses, à rédiger plusieurs fois, à prendre du temps quand tout doit aller tellement vite ?

Eh bien osons ! Non tout le monde ne parle pas anglais, et osons même plus : il y a énormément de gens qui ne le parlent pas, ou très mal. Oui bien sûr il y a ce couple d’une autre époque, trop vieux pour avoir appris, et cet autre là, plus jeune, mais issu d’un lieu et d’un temps où l’anglais n’était pas bien vu. Ah mais attendez ! Il y aussi ce jeune là, qui n’a jamais trop bougé de sa campagne, et cet autre là qui vient d’un pays où il est peu courant de le parler, celui-là qui vient pourtant d’une grande capitale d’Europe (ce n’est pas la langue de l’Europe ?), et cet autre encore…

Même pour ceux qui le parlent, pour ceux-là, tout n’est pas si simple. Oui bien sûr il y a les « natifs », ceux dont c’est la langue maternelle, et puis il y a ceux qui ont eu les moyens de voyager, la chance d’avoir une éducation ou qui sont simplement doués pour ça. Mais même de ceux-là, combien sont capables de s’exprimer avec autant d’aisance, avec autant de nuances que dans leur langue maternelle ?

Oh, et bien entendu je fais l’impasse sur la culture que la langue véhicule, sur l’influence exacerbée des auteurs anglophones, et sur l’isolation des autres.

Accepter la domination de quelques langues ce n’est pas seulement refuser l’accessibilité ; c’est tuer la diversité et avant tout formater notre façon de penser.

Parlons maintenant un peu plus technique

Quand on écrit un message dans un système de discussion, il est possible de l'« étiqueter » avec des informations (les métadonnées) et en particulier de préciser la langue dans lequel il est rédigé. Cette information est disponible naturellement avec le protocole XMPP, et il est même prévu d’envoyer un message en plusieurs langues simultanément.

Cette propriété est à mon sens essentielle et complètement sous-exploitée dans les logiciels actuels. Pourtant, elle peut être extrêmement utile : un salon de discussion peut être multilingue (les gens n’ayant que les messages dans une langue qu’ils comprennent), un système de conversation (contact d’association, support technique, demande quelconque) peut être dirigé directement vers une personne parlant la langue idoine, une traduction peut être demandée pour un message important, un programme électronique (ou « bot ») peut envoyer des messages dans plusieurs langues à la fois, les règles typographiques peuvent être adaptées, etc.

Ces informations sont désormais utilisées dans « Salut à Toi ». Un greffon expérimental permet même de détecter la langue utilisée automatiquement [2] si celle-ci n’est pas explicitement spécifiée ; ainsi dans un salon multilingue, il est possible de passer du français à l’anglais sans devoir le préciser manuellement à chaque fois.

Ci-dessous une petite animation de la détection d’un texte en plusieurs langues, puis de l’utilisation d’un filtre pour n’afficher que l’une d’entre elles.

filtrage par langue dans Primitivus

Ce n’est qu’un premier pas, il y a beaucoup de choses envisageables pour permettre aux gens de s’exprimer dans la langue qu’ils maîtrisent le mieux, et bien sûr en dehors de la messagerie instantanée également (pour le blog par exemple).

Ah, et puisque vous le demandez, non SàT n’utilisera pas de drapeaux pour les langues, ceux souvent utilisés à cette fin étant des symboles de pays et non de langues.


[1]grand « firewall » de Chine, vidéo ou autre visible uniquement depuis certains pays, blocage de sites, etc

[2]greffon basé sur langid.py, les résultats sont corrects mais pas parfaits, il y a toutefois des améliorations envisageables

Click to expand… Click to reduce…