Cet article sera accompagné d'un autre qui traitera de la fonction yield(). Et ces deux articles précéderont une série d'autres à propos du célèbre framework Ruby : Ruby On Rails.

Qu'est-ce que la metaprogrammation ?

J'imagine que beaucoup d'entre-vous ont ouvert de grands yeux à la lecture de ce mot barbare : "la métaprogrammation". En fait, cela n'a rien de bien compliqué : La métaprogrammation consiste à écrire des programmes qui décrivent eux-mêmes des programmes. Autrement dit, ça permet (entre autres) de générer du code directement au runtime. Comme vous allez pouvoir le constater, c'est vraiment très puissant.

La définition de Wikipedia énumère les différentes façons de procéder :

• l'utilisation de générateur de code (ce que j'ai mentionné juste avant)
• la programmation avec des templates
• l'utilisation d'un protocole à méta-objets
• l'utilisation de macros.

A quoi peut bien servir la metaprogrammation ?

La métaprogrammation peut servir à grandement simplifier la lecture du code (notamment via le principe Don't Repeat Yourself) ou dans le cas de Rails à simplifier la vie du développeur.

Deux petits exemples pour la route !

Admettons que l'on fasse un programme qui gère une base de données client et qui manipule donc plein de chaînes de caractères (String) qui peuvent signifier plein de choses (un numéro de téléphone, une adresse email, un numéro client, etc.). Nous aimerions qu'un objet String dispose de méthodes telephone?, email?, no_client? ... et peut-être même d'autres plus tard ! Comment faire ? Vous vous doutez bien de la réponse : avec la métaprogrammation !

Voici le code : (je vous expliquerai juste après son fonctionnement, donc pas de panique )

  #!/usr/bin/env ruby

class String
        @@string_checks = {
        'phone?' => %r{^0[\d]{2}\/[\d]{3}\.[\d]{2}\.[\d]{2}$},
            'email?' => %r{^.+@.+\.[a-z]{2,4}$},
            'no_client?' => %r{^[A-Z]{2}[\d]{4}-[\d]{4}-[\d]{4}$}
        }
        def method_missing(method_id)
                kind_of_string = method_id.to_s
                if @@string_checks.has_key?(kind_of_string)
                        if self =~ @@string_checks[kind_of_string]
                                true
                        else
                                false
                        end
                else
                        raise NoMethodError,
                                "Undefined method #{method_id} for \"#{self}\":String"
                end
        end
end

def humanize(bool)
        bool ? "Yes !" : "No !"
end

begin
        # Valid
        tel = "022/123.45.67".phone?
        email = "foo@foo.com".email?
        no_client = "CH1234-4242-4242".no_client?

        puts "Is 022/123.45.67 a valid phone number ? #{humanize(tel)}"
        puts "Is foo@foo.com a valid email address ? #{humanize(email)}"
        puts "Is CH1234-4242-4242 a valid client number ? #{humanize(no_client)}"

        puts "#################################################"

        #Invalid
        tel = "0033/123.12.12.12".phone?
        email = "www.foo.com".email?
        no_client = "42".no_client?

        puts "Is 0033/123.12.12.12 a valid phone number ? #{humanize(tel)}"
        puts "Is www.foo.com a valid email address ? #{humanize(email)}"
        puts "Is 42 a valid client number ? #{humanize(no_client)}"
end

Alors qu'est-ce que j'ai fait ?

Vous noterez tout d'abord que je définis une classe String qui est en fait une classe prédéfinie. En effet, en Ruby il est tout à fait possible de rajouter des choses dans les classes prédéfinies.

Il faut ensuite faire attention à la méthode method_missing que j'ai ajouté à la classe String. Que fait cette méthode ? Et bien si vous appelez une méthode non définie d'un objet String, Ruby va jeter un oeil dans cette méthode pour voir si on y définit quand même la méthode.  Et c'est justement là-dessus que je joue en récupérant l'id de la méthode et cherchant l'expression régulière correspondante au nom de la méthode appelée.

Après, je lève simplement une exception NoMethodFound si la méthode appelée n'est pas correct.

Finalement, je fais une méthode humanize ... qui n'a rien de spéciale Elle ne fait que mettre en forme un booléan. Le reste n'est ensuite que des tests que vous pouvez vous amusez à lancer.

N'est-ce pas beau de pouvoir simplement appeler "foo@foo.com".email? pour vérifier s'il s'agit bien d'un email valide ?

Ainsi, il va gérer la méthode dynamiquement et directement au Runtime De plus, si on veut par la suite ajouter d'autres vérifications pour une String, il suffit d'ajouter ce dont on a besoin dans la hash table @@string_checks.

Il y a également d'autres façons d'utiliser la métaprogrammation. On peut générer des méthodes sous forme de chaînes de caractères et utiliser la méthode class_eval pour l'évaluer. Regardons ça avec un petit exemple.

On aimerait créer une méthode attr_accessor_with_backup qui déclarerait un attribut et ses accesseurs correspondant (getter et setter) et qui garderait un backup de la valeur précédente.

 #!/usr/bin/env ruby

class Class
        # Store a backup of the previous value in attr_name_backup
        def attr_accessor_with_backup(attr_name)
          # Make sure it's a String
          attr_name = attr_name.to_s
          # Create a getter for attr_name and attr_name_backup
          attr_reader attr_name
          attr_reader attr_name+"_backup"
          # Generate setter for attr_name
          class_eval %Q{
                  def #{attr_name}=(value)
                        # backup previous value
                        @#{attr_name}_backup = #{attr_name}
                        # set the new value
                        @#{attr_name} = value
                  end
          }
        end
end

class WeNeedBackup
        attr_accessor_with_backup :foo
end

begin
        spock = WeNeedBackup.new
        spock.foo = "42"
        puts "foo => #{spock.foo} and foo_backup => #{spock.foo_backup}"
        spock.foo = "24"
        puts "foo => #{spock.foo} and foo_backup => #{spock.foo_backup}"
        spock.foo = "128"
        puts "foo => #{spock.foo} and foo_backup => #{spock.foo_backup}"
end

Cette fois on ajoute une méthode attr_accessor_with_backup dans la classe Class (classe dont toutes les classes Ruby sont des sous-classes), qui, rappelons-le, fait exactement comme la méthode prédéfinie attr_accessor en plus de stocker un backup de la valeur précédente de l'attribut.

Dans cette méthode on va alors créer des getters pour le nom de l'attribut (attr_name)  et son backup (attr_name_backup) qui contiendra la valeur précédente de attr_name.

Ensuite, il va nous falloir définir dynamiquement un setter pour l'attribut. On va donc utiliser la méthode class_eval et lui donner en argument une chaîne de caractères contenant le code de notre setter. Cette méthode s'occupera de sauvegarder la valeur courante de l'attribut dans l'attribut _backup et de mettre à jour la valeur de l'attribut.

Finalement, notre méthode attr_accessor_with_backup va générer les méthodes nécessaires directement au runtime.  N'est-ce pas monstrueusement puissant ?

Conclusion

Vous l'aurez sans doute constaté, la métaprogrammation permet de faire des tas de choses bien pratiques et peut ainsi simplifier la vie du développeur.

Le framework Rails utilise la métaprogrammation pour simplifier l'écriture du code par le développeur. Par exemple, il génère des helpers pour gérer les chemins aux ressources. Par exemple, pour accéder au controller products, il suffira d'appeler products_path ou products_url si on veut un chemin absolu. Si on veut accéder à l'action new du controller products, il suffira d'appeler new_product_path ou new_product_url. Ne vous inquiétez pas, nous reviendrons dessus beaucoup plus en détail très prochainement lorsque nous aborderons Rails.

J'espère que ce billet vous aura été utile

L'astuce est inspirée de la documentation d'Archlinux : https://wiki.archlinux.org/index.php/Firefox_Tips_and_Tweaks#Viewing_PDF.2FPS_inside_Firefox

Les prérequis sont :

• Une distribution GNU/Linux
• Firefox. (pour les utilisateurs de chromium, voir le "edit 2" à la fin de l'article)
• Un lecteur PDF (par exemple Evince)

Allons-y !

Il faut tout d'abord installer le paquet mozplugger. Malheureusement, il ne se trouve pas dans les dépôts d'Archlinux. Vous devrez donc aller le chercher sur AUR. Si vous avez yaourt d'installé :

yaourt -S mozplugger

Sinon on y va façon geek

wget http://aur.archlinux.org/packages/mo/mozplugger/mozplugger.tar.gz

On décompresse le tout (nécessite l'utilitaire pour décompresser les tar gz, évidemment) :

tar xvzf mozplugger.tar.gz && cd mozplugger

On créé le package :

makepkg -s

Et on l'installe (le nom peut varier en fonction de la version, adaptez-le si ça ne fonctionne pas) :

sudo pacman -U mozplugger-1.14.3-1-x86_64.pkg.tar.xz

Maintenant que mozplugger est installé, il nous faut virer certains fichiers :

rm ~/.mozilla/firefox/*.default/pluginreg.dat

Editons maintenant le fichier de configuration de mozplugger (/etc/mozpluggerrc)avec notre éditeur de texte préféré (vim pour ma part ^^). Il ne faut pas oublier de le lancer en root pour avoir les droits de modification sur le fichier

Une fois le fichier ouvert, on commente la ligne (ligne 288 chez moi) suivante qui se trouve dans la partie PDF après la ligne GV() :

#repeat noisy fill exits: evince "$file"

Et on ajoute juste après :

repeat noisy swallow(evince) fill: evince "$file"

Note, vous pouvez remplacer evince par un autre lecteur PDF (comme Okular. Ca devrait normalement fonctionner.

Pour finir, on relance Firefox et le tour est joué. Il ne reste plus qu'à ouvrir un PDF pour voir si ça fonctionne bien.

J'espère que cette astuce vous aura été utile. En ce qui me concerne, je trouve vraiment pratique de pouvoir visualiser un PDF sans avoir à le télécharger (ça évite le chaos dans le dossier Downloads).

Edit 1 : Vous pouvez vous amusez à modifier le fichier de configuration de mozplugger pour gérer d'autres formats de fichiers (.doc/.docx, etc.). Pour la doc, c'est pas ici : http://mozplugger.mozdev.org/documentation.html

Edit 2 : Pour les utilisateurs de chromium, c'est par ici : https://aur.archlinux.org/packages.php?ID=46826  je n'ai pas testé, mais en principe ça devrait fonctionner de la même façon

Les lézards ont eu aussi le droit de jouer

Soit dit en passant, l'appli est sympa, mais on s'en lasse vite (je l'avais testée il y a quelques mois)

http://www.commentcamarche.net/news/5857618-richard-stallman-la-censure-sur-le-web-a-explose-en-france

http://links.gilliek.ch/

]]> http://blog.gilliek.ch/actualites/shaarli-me-voici/feed 8 http://blog.gilliek.ch/linux/personnaliser-unity-la-suite http://blog.gilliek.ch/linux/personnaliser-unity-la-suite#comments Sun, 18 Dec 2011 12:40:58 +0000 R3v4n http://blog.gilliek.ch/?p=429 Dans un article précédent, je vous avais donné quelques petits trucs pour personnaliser Unity sous Ubuntu 11.10. Je vous avais notamment mentionné Ubuntu Tweak comme étant un outil indispensable et qu'il fallait suivre sa sortie prochaine pour Ubuntu 11.10. Et bien on dirait qu'elle pointe le bout de son nez : La version finale d’Ubuntu Tweak 0.6 bientôt prête

J'ai aussi découvert un nouvel outil pour personnalisé certains paramètres d'Unity : MyUnity

Pour l'installer, ajoutez le dépôt de MyUnity :

sudo add-apt-repository ppa:myunity/ppa

Puis, mettez à jour la liste des paquets :

sudo apt-get update

Et finalement, installez le paquet myunity :

sudo apt-get install myunity

Il ne vous reste plus qu'à le lancer et à tester les différents paramètres

A part ça, comme je l'ai mentionné dans mon dernier article, j'ai migré mon ordinateur de bureau sur Pinguy OS Et pour l'instant tout ce passe bien. Et comme promis, un article est en préparation sur le sujet.

Cette article va donner suite à plusieurs autres dans le même genre (que j'espère prochainement pouvoir poster) : Configurer Awesome sous Archlinux, Compiz en standalone sur Archlinux, A la découverte de Pinguy OS et quelques autres articles sur des logiciels très utiles que j'ai découvert ces derniers temps et qui sont très prometteurs. Après cette interlude sur "la personnalisation", je vais revenir à des sujets un peu plus techniques sur la programmation (c'est promis ) notamment sur des patterns, méthodes de développement, C et le frameword Ruby On Rails. Voilà pour la petite parenthèse "Coming soon". Revenons à nos moutons.

Quand on débarque sur Unity, le premier réflexe et d'aller dans les "System Settings" (Paramètres système, pardonnez les traductions mais mon système est en anglais et j'ai la flemme d'installer le pack de langue français Mais vous allez vous en sortir, ne vous inquiétez pas ), enfin pour moi. Et la horreur (effroi et toussa) : il n'y a quasi rien o_O Et il y a des gros boutons partout (merde, on est pas aveugle ?!). Vous l'aurez compris, c'est par là que l'on va commencer.

Changer la taille des icones dans le dock

Pour cela, il va vous falloir installer Compiz Config Settings Manager. Passez par l'Ubuntu Software Center ou tapez la commande suivante dans un Terminal :

sudo apt-get install compizconfig-settings-manager

Appuyez sur <Super> ou cliquez sur l'icone du "Dash", puis saisissez : ccsm ou compiz et lancez le Compiz Config Settings Manager. Cherchez Ubuntu Unity Plugin et cliquez dessus :

Une fois dedans, allez dans l'onglet Experimental e modifiez le Launcher Icon Size (Taille des icones du lanceur, ou quelques choses comme ça) comme vous voulez (par exemple mettez la valeur 32) :

Compiz Settings Manager permet de régler plein d'autres choses. Je vous laisse découvrir les autres réglages Vous pouvez également ajouter plein d'effets sympa à votre bureau. Déchaînez-vous !

Passons maintenant à la suite. Si vous utilisiez les anciennes versions d'Ubuntu sans Unity, vous avez sans doute eu la même réaction que moi en essayant de faire un clique droit sur le panel pour ajouter des applets. Et bien, le panel d'Unity ne supporte pas les applets, mais les AppIndicator. Regardons alors comment personnaliser tout ça afin d'ajouter ses propres indicator.

Ajouter des indicators dans le panel

On va ajouter un indicator pour le CPU, la mémoire utilisée et la température du GPU. Pour cela il va falloir ajouter un dépôt :

sudo add-apt-repository ppa:alexeftimie/ppa

Mettez ensuite à jour la liste des pacquets :

sudo apt-get update

Et installez finalement le sysmonitor :

sudo apt-get install indicator-sysmonitor

Il vous faut maintenant l'exécuter : Lancez le dash depuis l'icone du dash ou avec la touche <Super> et tapez sysmonitor et cliquez sur le system monitor indicator. Le tour est joué ! Avec un clique droit dessus, vous pouvez modifier les préférences.

Maintenant que vous voyez le principe, je vous donne une liste des indicators (en anglais) que vous pouvez ajouter (le choix est large, vous avez de quoi faire ) :

http://askubuntu.com/questions/30334/list-of-application-indicators

Bien ! On commence à avoir un bureau assez cool, non ? Continuons avec un petit ajout sympa. on va rajouter une quick list à notre lanceur "Home folder" (le dossier avec la maison dedans^^) dans le dock qui va nous permettre d'accéder directement à nos dossiers principaux.

Quicklist pour le dock

Pour commencer, lancez un Terminal et tapez la commande suivante :

gksudo gedit /usr/share/applications/nautilus-home.desktop

Cela va ouvrir un fichier de configuration avec Gedit. Il vous suffit ensuite de remplacer son contenu par ce qui suit :

[Desktop Entry]

Name=Home Folder

Comment=Open your personal folder

Exec=nautilus

Icon=user-home

Terminal=false

StartupNotify=true

Type=Application

OnlyShowIn=GNOME;Unity;

Categories=GNOME;GTK;Core;

X-GNOME-Bugzilla-Bugzilla=GNOME

X-GNOME-Bugzilla-Product=nautilus

X-GNOME-Bugzilla-Component=general

X-GNOME-Bugzilla-Version=3.0.0

X-Ubuntu-Gettext-Domain=nautilus

X-Ayatana-Desktop-Shortcuts=Documents;Pictures;Music;Videos;Downloads

[Documents Shortcut Group]

Name=Documents

Exec=nautilus Documents

TargetEnvironment=Unity

[Pictures Shortcut Group]

Name=Pictures

Exec=nautilus Pictures

TargetEnvironment=Unity

[Music Shortcut Group]

Name=Music

Exec=nautilus Music

TargetEnvironment=Unity

[Videos Shortcut Group]

Name=Videos

Exec=nautilus Videos

TargetEnvironment=Unity

[Downloads Shortcut Group]

Name=Downloads

Exec=nautilus Downloads

TargetEnvironment=Unity

Sauvegardez et ça devrait être bon. Si vous faites un clique droit sur l'icone dans le dock, vous devriez obtenir ceci :

Ouf ! On souffle un peu. On va maintenant voir comment ajouter des widgets sur le bureau.

Des widgets avec Screenlets

L'idée est, dans un premier temps, d'ajouter des widgets sur notre bureau. Pour cela, nous allons utiliser screenlets. Commençons donc par l'installer :

sudo apt-get install screenlets

ou via l'Ubuntu Software Center pour ceux qui sont réticents à la ligne de commande

Une fois installé, lancez screenlets depuis le dash (<Super>). Vous devriez avoir ça :

Pour ajouter un widget sur le bureau, cliquez sur celui que vous voulez, puis cochez les cases Start/Stop et Auto start on login.

En faisant un clique droit sur le widget ainsi ajouté sur le bureau, vous pourrez le personnaliser comme bon vous semble.

Pour ceux qui connaissent un peu Mac OS, vous avez peut-être déjà vu comment ça fonctionne : on a une touche sur le clavier qui affiche tous les widgets. Une sorte de surcouche qui apparaît à la demande et qui contient les widgets. C'est aussi possible d'obtenir ce résultat avec compiz et screenlets.

Réouvrez le Compiz Config Settings Manager (ccsm) et activez le plugin Widget Layer. Modifiez éventuellement le raccourcis clavier si celui par défaut ne vous convient pas (moi j'utilise la touche F1, mais par défaut il s'agit de la touche F9).

Maintenant qu'on a notre Widget Layer, il nous faut ajouter des widgets sur celui ci. Pour cela ajoutez votre widget comme nous l'avons précédemment, puis faites un clique droit dessus. Allez dans WIndow et cliquez sur widget, comme ceci :

Votre widget apparaîtra donc sur votre Widget Layer si vous appuyez sur la touche F9 (ou autre si vous avez changé). Vous pouvez aussi jouer sur les autres paramètres pour que votre widget apparaisse au dessus ou au dessous des fenêtres. Et aussi cochez Sticky pour qu'il apparaisse sur tous les bureaux.

Voilà c'est terminé On va voir encore quelques trucs et astuces avant de conclure cet article.

Sushi

Non non, je ne vais pas vous apprendre à cuisiner des sushis Il s'agit en fait d'un plugin bien utile pour Nautilus, présent par défaut sur Ubuntu. Comment ça fonctionne ? Lorsque vous naviguez dans vos fichiers et dossiers depuis Nautilus, vous pouvez afficher un preview de certains fichiers en appuyant sur la touche <espace>

Ubuntu Tweak

Un outil indispensable pour tout utilisateur d'Ubuntu Il permet de "tweaker" Ubuntu Ajouter des scripts à Nautilus, ajouter des tas de dépôts, nettoyer les caches, modifier certains éléments graphiques (l'image de fond à l'écran de login, la disposition des boutons sur le cadre des fenêtres, et plein d'autres choses. Malheureusement, il n'est pas encore disponible pour Ubuntu 11.10. Mais je vous conseille de suivre sa sortie en version finale sur le site : http://ubuntu-tweak.com/

Les raccourcis clavier et la nomenclature sous Unity

Voici deux liens (en anglais) qui pourront vous aider à vous faire à Unity. Le premier donne les raccourcis clavier et le second la nomenclature utilisée :

http://askubuntu.com/questions/28086/what-are-unitys-keyboard-and-mouse-shortcuts

http://askubuntu.com/questions/10228/whats-the-right-terminology-for-unitys-ui-elements

Reference

L'article qui m'a fait découvrir l'astuce de la quicklist et les indicateurs dans le panel : http://www.tuxgarage.com/2011/04/tweak-unity-to-better-suit-your-needs.html

Cet article parle de certaines choses que je n'ai pas mentionnées ici, il pourrait être intéressant à lire (en anglais).

Conclusion

J'espère que j'ai été clair dans mes explications et que j'ai pu aider des personnes Si quelque chose vous pose problème ou que vous ne comprenez pas une des explications, n'hésitez pas à laisser des commentaires

Si quelqu'un utilise Ubuntu en français, je lui serai éternellement reconnaissant s'il pouvait me donner les traductions exactes utilisées en français

J'ai également pris les dispositions nécessaires pour que les anciens liens soient redirigés sur la nouvelle URL.

Si vous constatez un bug ou tout autre problème, merci de me le signaler via les commentaires (je n'ai pas encore mis en place le formulaire de contact).

Je bosse actuellement sur un logiciel de traitement d'image en Java ( coming soon ) ... et j'ai besoin de manipuler des JFileChooser (pour sélectionner des fichiers et des dossiers).  Avant de pester contre ce foutu Swing d'énoncer mon soucis, je vais dire deux mots sur Swing, pour ceux qui ne connaîtraient pas.

Swing est une bibliothèque graphique pour Java. Elle permet donc de créer des interfaces graphiques. Ce qui est pratique, c'est que ça fonctionne sur n'importe quel système d'exploitation, donc pas mal pour du développement multiplateforme. (petit troll : et c'est beaucoup plus confortable à utiliser que C et GTK ... bien que je préfère largement le C à Java).

Revenons à nos moutons. Qu'est-ce qui me fait actuellement ch*** avec JFileChooser ? Et bien la réponse est simple : son implémentation moisie ! C'est un composant très peu personnalisable. Par exemple, si on veut garder uniquement la fenêtre de navigation sans les boutons, le sélectionneur de type de fichiers et toussa, on s'amuse avec la méthode remove(getComponent(index)) à chercher quel est le bon composant à virer. Ou aussi ce qui est à l'origine de ce post : comment choisir le mode d'affichage par défaut (liste ou détails). Je m'attendais à devoir faire un simple setViewMode(JFileChooser.DETAILS), comme en Qt quoi ... mais non faut faire un hack dégueulasse pour arriver à ses fins ! (Rhaaaaaa)

Après quelques énervements, j'ai trouvé un topic sur un forum qui m'a bien aidé :

La solution consiste à utiliser SwingUtils, téléchargeable sur le site : http://tips4java.wordpress.com/2008/11/13/swing-utils/

Il suffit ensuite de mettre le code trouvé sur le topic mentionné précédemment :

JFileChooser fileChooser = new JFileChooser();
AbstractButton button = SwingUtils.getDescendantOfType(AbstractButton.class,
      fileChooser, "Icon", UIManager.getIcon("FileChooser.detailsViewIcon"));
button.doClick();

Et le tour est joué ! Mais je trouve ça vraiment dégueulasse personnellement ...

De manière plus générale, je trouve leur JFileChooser vraiment très pauvre. En plus de ne pas être très confortable à l'utilisation, il n'est pas personnalisable ... c'est vraiment dommage. Il va peut-être falloir que j'en code un moi-même quand j'en aurai le temps ... à suivre ...

Edit : Cette solution foire sur Mac OS (ça ne compile pas ...) . De plus, la façon avec laquelle j'ai encore modifié le JFileChooser (avec la méthode remove) fait foirer l'affichage sous Mac OS ...

Edit 2 : J'ai entamé (et déjà bien avancé) le codage de mon propre FileChooser et pour l'instant ça fonctionne bien

Si comme moi vous avez des serveurs sur lesquels vous voulez vous authentifier depuis votre smartphone Android, ce post est pour vous

Les prérequis pour cette astuce :

• Un serveur disposant d'un serveur SSH (au début, votre serveur SSH devra autoriser les connexions par mot de passe. Une fois la clé ajoutée, je vous conseille d'y désactiver)
• D'un téléphone sous Android (ou d'une tablette)

Voilà le problème : Comment s'authentifier sur son serveur via SSH avec une paire de clés privée/publique depuis Android ?

La solution est assez simple. C'est ce que nous allons voir ici :

1. Depuis l'Android Market, téléchargez l'application Connect Bot
2. Lancez l'application puis allez dans le menu > Gérer les clés publiques
3. De nouveau, allez dans le menu > Générer
4. Choisissez un pseudo pour identifier votre clé, le type et une passphrase, puis cliquez sur "Générer"
5. Pour renforcer l'aléatoire, bougez votre doigt de manière aléatoire sur la surface indiquée
6. Une fois la clé générée, laissez votre doigt appuyé dessus jusqu'à ce que le menu apparaisse.
7. Choisissez "Copier la clé publique"
8. Revenez en arrière et connectez-vous sur votre serveur.
9. Une fois connecté, il nous faut ajouter votre clé sur le serveur. Pour cela, saisiseez la commande suivante :

echo "votre_clé" >> .ssh/authorized_keys

Où votre_clé est votre clé publique que vous devez coller à l'aide de menu > coller

Ensuite, il ne vous reste plus qu'à vous connecter depuis Connect Bot en allant dans menu > Gérer les clés publique . Puis, cliquez sur votre clé et entrez la passphrase saisie à la génération de la clé. Une fois cela fait, il ne vous reste plus qu'à vous connecter normalement sur votre serveur

J'ai testé cette astuce depuis un Samsung Galaxy SII sous Android 2.3.3, mais en principe ça devrait fonctionner avec n'importe quelle version d'Android pour autant qu'elle dispose de la dernière version de l'application Connect Bot.

Merci quand même à ceux qui testeraient cette astuce de mettre un commentaire avec le modèle du téléphone et la version d'Android utilisée et si tout fonctionne

Il y a aussi des clients SFTP (pour le transfert des fichiers) tels que AndFTP et FtpCafé qui devraient gérer l'authentification par clé, mais je n'ai pas encore testé. Cela fera sans doute l'objet d'un futur post.