Soulesidibe2017-10-29T15:01:41+00:00http://soulesidibe.github.ioSouleymane SidibeLes conférences Android2017-02-08T00:00:00+00:00http://soulesidibe.github.io/2017/02/08/Les-conf-android<p>Être un développeur android, ce n’est pas juste s’enfermer et écrire du code. Il faut aussi faire de la veille. Ca nous permet d’être au courant des avancées et de pouvoir les intégrer dans les prochaines versions de nos produits si besoin est.
Cela est encore plus vrai dans le context du developpement d’application android où nous avons pléthore de versions android avec des différences dans chaque itération. Un exemple tout bête, à la sortie de la version 5.0, android introduisait les permissions avec tout un nouveau workflow à revoir pour les mettre en place dans une app. Sans être au courant de cette evolution, on expose nos utilisateurs à des bugs. Donc à une mauvaise expèrience dans l’utilisation de votre produit. On peut donner des centaines de bonnes raisons de faire de la veille technologique. Ce n’est pas le but de cette article.
J’aimerai plus parler d’une des facons de faire de la veille. Les conférences tech.</p>
<h4 id="cest-quoi-une-conf-tech">C’est quoi une conf tech</h4>
<p>Une conference tech c’est déjà une conférence mais orientée tech. lol. Évident non?
Le plus souvent, on y trouve des talks autour d’une technologie ou d’un ensemble technologies poussées par une entreprise.
Mais je suis au Senegal comment je fais pour m’y rendre?!
Malheuresement, le gratin des conférences à voir impérativement, si on se dit developpeur android, sont localisées en Europe ou aux USA.
Par contre, la chance que nous avons c’est que la grande majorité de ces conf sont disponibles gratuitement sur internet. Ca change tout! Même pas besoin d’y être physiquement. Bon je vous concède que y etre c’est encore mieux. On rencontre des dévelopeurs venus de partout. Ce contact est très enrichissant.</p>
<h4 id="google-io">Google IO</h4>
<p>C’est la grande messe des développeurs android. C’est la où se font les grandes annonces sur les avancés de la plateforme. On nous expose ce sur quoi ils ont bosse pendant une annèe. C’est une conf qui ne parle pas que de android mais avec un monde qui est devenu, au cours des 10 derniers années (thanks Apple), full mobile on s’imagine que la platforme android est au centre de tout. Toutes les présentations des derniers google IO sont disponibles sur Youtube! C’est pas top ca? Quelques liens sur Google IO 2016:</p>
<ul>
<li><a href="https://www.youtube.com/watch?v=862r3XS2YB0">La keynote</a> [~2h]</li>
<li><a href="https://goo.gl/Uv3jls">Les talks sur android</a> [65 videos]</li>
<li><a href="https://goo.gl/7uNtFx">Toutes les vidéos</a> [183 videos]</li>
</ul>
<p>La prochaine Google IO devrait se tenir en Mai 2017. Stay tuned!</p>
<h4 id="droidcon">Droidcon</h4>
<p>Les droidcons sont des conférences axées que sur android et de tout ce qui tourne autour.
On retrouve la Droidcon un peu partout en Europe et aux USA. Les développeurs les plus connus y présentent les bonnes pratiques de développement sur le mobile, les technologies qu’ils utilisent dans leurs apps.</p>
<ul>
<li><a href="https://goo.gl/UaPt1W">Droidcon NYC 2016</a></li>
<li><a href="https://goo.gl/cPWR7c">Droidcon SF 2016</a></li>
<li><a href="https://goo.gl/hDcD1I">Droidcon Berlin 2016</a></li>
<li><a href="http://uk.droidcon.com/#skillscasts">Droidcon London 2016</a></li>
<li><a href="http://droidcon.fr/speakers/">Droicon Paris 2015</a></li>
</ul>
<p>La liste n’est pas exhaustive. Il y a énormement de talks sur android qu’on peut trouver sur le net. Même à des confs non spécialisées mobile(Devoxx).<br />
Donc je vais m’arrêter la. Mais je vous laisse avec la liste des confèrences à venir en 2017 => <a href="http://androidweekly.net/conferences">conf 2017</a> :)</p>
Docker, Les bases (2e partie)2016-10-19T00:00:00+00:00http://soulesidibe.github.io/2016/10/19/Docker-les-bases-partie-2<p><a href="http://soulesidibe.com/2016/09/26/Docker-les-bases/">Lors de la première partie</a>, on a fait une présentation de docker. On a introduit quelques notions de base indispensables pour avancer sur le sujet.<br />
Cette partie sera un peu plus pratique :)</p>
<h2 id="installation">Installation</h2>
<p>Les équipes de docker ont fait un travail énorme pour faciliter la vie aux utilisateurs. Je me rappelle encore quand il fallait passer par virtualbox pour utiliser docker sur mac ou windows…<br />
Docker est disponible sur <a href="https://docs.docker.com/engine/installation/linux/ubuntulinux/">linux</a>, <a href="https://docs.docker.com/engine/installation/mac/">mac</a> et <a href="https://docs.docker.com/engine/installation/windows/">windows</a>. Pour le cas des distributions linux, la manip n’est pas forcement la même. Vous aurez la marche à suivre pour toutes les distros supportées sur <a href="https://docs.docker.com/engine/installation/linux/ubuntulinux/">le site</a>.</p>
<h4 id="docker-for-mac">Docker for mac</h4>
<p>Pour ce post, je vais parler de l’installation sous mac. Sorry pour les autres.<br />
Déjà, il faut récupérer <a href="https://docs.docker.com/docker-for-mac/">le fichier dmg</a>. On a la version stable et la version beta dispo. Pour le reste, je n’ai rien à vous expliquer. Un user mac sait quoi faire d’un fichier .dmg.<br />
Après l’installation, l’app sera disponible au niveau du launchpad:<br />
<img src="/assets/docker_launchpad.png" alt="docker" /><br />
Comme je vous l’expliquais, cette install de docker vous donne accès au daemon qui sera visible au niveau du menu bar de mac:
<img src="/assets/docker_up_and_running.png" alt="docker menu bar" /><br />
On a aussi accès à la commande <code class="highlighter-rouge">docker</code> depuis le terminal.</p>
<p><img src="/assets/docker_version_cmd.png" alt="docker_cmd" /></p>
<h2 id="lancer-son-premier-container">Lancer son premier container</h2>
<p>La facon la plus simple de lancer un container: <code class="highlighter-rouge">docker run hello-world</code>.
Alors décomposons un peu cette commande:</p>
<p><img src="/assets/hello_world_docker.png" alt="hello world docker" /></p>
<ul>
<li><code class="highlighter-rouge">docker</code> : c’est le client qui permet d’interagir avec docker</li>
<li><code class="highlighter-rouge">run</code> : c’est l’option qui permet de lancer un container. Nous verront les autres options de <code class="highlighter-rouge">run</code> à connaitre</li>
<li><code class="highlighter-rouge">hello-world</code> : C’est le nom de l’image qui sera utilisée pour lancer le container.</li>
</ul>
<p>C’est cool tout ca mais pour juste afficher un message sur le terminal, il y a plus simple que docker.
On va essayer de lancer un container beaucoup plus intéressant. Disons que j’ai besoin d’un serveur web(apache2) sur une machine en prod sous ubuntu 14.04. Et que j’aimerai tester la config sur ma machine avant de le faire en prod. J’ai plusieurs options. Soit j’installe une solution de virtualisation comme virtualbox, soit j’utilise docker.
D’abord j’ai besoin d’une image de Ubuntu 14.04. Ce qui me permet d’introduire l’option <code class="highlighter-rouge">search</code>:</p>
<p><img src="/assets/docker_search_ubuntu.png" alt="docker search" /></p>
<p>La on voit qu’il existe une image Ubuntu dispo sur hub.docker.com. Le registry officiel de docker. Notre serveur web doit tourner sur une version particulière de Ubuntu la LTS 14.04. La commande search ne permettant pas de rechercher par tag, nous allons devoir essayer de récupérer cette version 14.04 par la même vérifier son existance.</p>
<p><img src="/assets/docker_pull_ubuntu.png" alt="docker pull" /></p>
<p>L’option <code class="highlighter-rouge">pull</code> nous permet de récupérer une image depuis un registry. J’ai aussi spécifié la version de Ubuntu que je voulais via ce qu’on appelle les <strong>tags</strong>. C’est un peu l’equivalent des tags avec <strong>git</strong>. Ca nous permet de “snapshoter” les évolutions d’une image. En général, on a un numéro de version, un nom. On aurait pu mettre par exemple <code class="highlighter-rouge">docker pull ubuntu:trusty</code>. Trusty étant le nom de la version 14.04 de Ubuntu. C’est au créateur de l’image de choisir le tag qu’il veut attribuer à une imagine.<br />
Donc nous avons récupéré une image, on va vérifier au niveau de ma liste des images si elle est présente.</p>
<p><img src="/assets/docker_images.png" alt="Docker images" /></p>
<p>Good! J’ai réussi à récupérer une image docker sur un registry. Now je suis prêt pour lancer mon container.</p>
<p><img src="/assets/docker_run.png" alt="Docker images" /></p>
<p>La commande est simple. <code class="highlighter-rouge">docker run</code> pour dire que je veux lancer un container, <code class="highlighter-rouge">-ti</code> pour avoir un TTY et avoir accès au STDIN, <code class="highlighter-rouge">ubuntu:14.04</code> pour specifier l’image et le tag que je veux utiliser, <code class="highlighter-rouge">bash</code> pour lancer la commade bash au lancement du container. C’est le minimum dont on a besoin pour pouvoir installer notre serveur web apache2.<br />
Il y a énormement d’options sur <strong><a href="https://docs.docker.com/engine/reference/commandline/run/">docker run</a></strong>. On en reparlera au fur et à mesure.<br />
So on voit bien sur le screenshot qu’on est plus sur mon mac mais bien sur une machine ubuntu 14.04. On pourra donc installer notre serveur apache2 et faire nos tests!<br />
On aurait pu faire directement un <code class="highlighter-rouge">docker run</code> sans passer par un <code class="highlighter-rouge">docker pull</code>. Quand l’image n’existe pas sur la machine, elle est automatiquement récupérée si elle existe sur le registry.<br />
Nous savons comment démarrer un container. Nous pouvons installer notre serveur apache comme sur une vrai machine ubuntu. L’inconvénient de cette façon de faire est que à chaque lancement du container, il faudra installer à nouveau le serveur apache2. Docker nous donne donc la possibilité de creer des images qui auront l’état de base souhaité. Dans notre cas, un ubuntu 14.04 avec apache2 up and running.</p>
<p>##Créer sa propre image</p>
<p>Docker nous donne la possibilité de créer des images. Dans le cas de mon serveur WEB, au lieu de lancer à chaque fois un container Ubuntu et d’y installer notre serveur, on peut créer une image docker ayant les specs souhaitées.</p>
<h4 id="enregistrer-les-modifications-dun-container">Enregistrer les modifications d’un container</h4>
<p>On peut créer une nouvelle image à partir des modifications qui ont étè apportées sur un container déjà lancé. Via la command <code class="highlighter-rouge">commit</code>.
D’abord, il faut connaitre l’ID du container.</p>
<p><img src="/assets/docker_ps.png" alt="liste container" /></p>
<p>La commande <code class="highlighter-rouge">docker ps</code> nous permet de voir la liste des containers qui sont actuellement démarrés avec différentes informations dont l’ID qui permet d’identifier un container. On a tout ce qu’il faut pour créer une image avec un commit des modifications du container actuel.</p>
<p><img src="/assets/docker_commit.png" alt="creation container" /></p>
<p>La aussi la team docker a fait très simple. <code class="highlighter-rouge">docker commit b187af19c708 soulesidibe/apache2:0.1</code>. Ce qui signifie, je veux créer une nouvelle image à partir du container ayant l’ID <code class="highlighter-rouge">b187af19c708</code>. L’image s’appellera <code class="highlighter-rouge">soulesidibe/apache2</code> et donne lui le tag <code class="highlighter-rouge">0.1</code>. Je fais un <code class="highlighter-rouge">docker images</code> pour vérifier la création effective de la nouvelle image. <code class="highlighter-rouge">docker images</code> suivi du nom de la nouvelle image permet de filter en fonction du nom.<br />
Now on peut lancer directement notre container sans avoir à installer à chaque fois le serveur apache. Pas mal non?</p>
<p><img src="/assets/docker_run_new.png" alt="run new container" /></p>
<h4 id="dockerfile">Dockerfile</h4>
<p>Pour moi, c’est le meilleur moyen pour créer une nouvelle image parce que plus simple et surtout plus facile à partager dans une team par exemple.
Il faut d’abord créer un fichier et lui donner le nom <code class="highlighter-rouge">Dockerfile</code>. Par convention, on crée un dossier avec le nom de la futur image et on y met le Dockerfile.<br />
Voici le Dockerfile de notre serveur web apache2:</p>
<p><img src="/assets/apache2server_Dockerfile.png" alt="Dockerfile" /></p>
<p>Chaque ligne est une instruction expliquant comment créer mon image docker. Et surtout chaque instruction est une couche au niveau de l’image. Pour chaque instruction, nous avons un mot clé et des arguments. La liste compléte des instructions est dispo en <a href="https://docs.docker.com/engine/reference/builder/">ligne</a> mais nous allons voir un peu ce que fait ce fichier Dockerfile:</p>
<ul>
<li>
<p><code class="highlighter-rouge">FROM ubuntu:14.04</code>: FROM permet de spécifier l’image de base utilisée pour créer notre nouvelle image. Dans notre cas, on part sur un Ubuntu avec le tag 14.04. Ca permet vraiment d’aller vite dans ce quon fait. Je vous conseille de toujours partir d’une image officielle.</p>
</li>
<li>
<p><code class="highlighter-rouge">MAINTAINER Souleymane Sidibe<souleymane.sidibe01@gmail.com></code>: Cette ligne permet juste de donner le contact de l’auteur de cette image.</p>
</li>
<li>
<p><code class="highlighter-rouge">RUN apt-get update && apt-get -y install apache2</code>: RUN nous permet d’executer des commandes dans l’image. Ici, nous avons juste besoin d’installer le serveur apache mais on peut imaginer toute sorte de commandes. Sky is the limit.</p>
</li>
<li>
<p><code class="highlighter-rouge">ENTRYPOINT ["/usr/sbin/apache2ctl", "-D", "FOREGROUND"]</code>: ENTRYPOINT permet de rendre le container executable en lancant votre instruction dès son lancement. C’est ce que nous faisons avec notre serveur web apache2.</p>
</li>
<li>
<p><code class="highlighter-rouge">EXPOSE 80</code>: EXPOSE permet de dire à Docker que notre container écoute sur un port spécifique. Cela ne veut pas dire que le container est accessible depuis l’hôte. Pour ce faire, il faudra faire un mapping entre le port du container et un port sur la machine hôte avec l’option -p de la commande <code class="highlighter-rouge">docker run</code>.</p>
</li>
</ul>
<p>L’étape suivante est de construire l’image à l’aide de la commande <code class="highlighter-rouge">docker build</code>:</p>
<p><img src="/assets/build_image_docker.png" alt="build image" /></p>
<p>Comme on peut le voir, <code class="highlighter-rouge">docker build</code> c’est juste une succession de couches(instructions) rajoutées à l’image de base specifiée dans l’instruction FROM. Docker build a un fonctionnement assez intéressant. <code class="highlighter-rouge">Docker build</code> n’execute pas une instruction qui a déjà été execute si elle n’a pas changé ou si une instruction au dessus d’elle n’a pas changé. La couche correspondante étant dans son cache. Ce qui me permet de ne pas avoir besoin de internet pour faire une installation de apache2 sur mon ubuntu via la commande apt. Cool non :)<br />
Créer un Dockerfile est assez simple. Dépendant de ce que vous voulez faire. Avant de vous lancer dans la creation d’une image, vérifier si un equivalent n’existe pas déjà sur le <a href="hub.docker.com">hub</a>. Vous y trouverez surement une image qui vous fera gagner du temps.</p>
<p>Voila un peu pour cette partie! Nous avons installé docker sous mac. Puis nous avons lancé notre premier container et pour finir nous avons créer notre premiére image à partir d’un container et d’un dockerfile. C’est tout pour ce post. J’essaie de ne pas etre trop long.<br />
Lors de la partie 3, nous parlerons des volumes.</p>
Docker, Les bases (1er partie)2016-09-26T00:00:00+00:00http://soulesidibe.github.io/2016/09/26/Docker-les-bases<p>Je suis sur que vous en avez entendu parler(un collègue, une mailing list, un talk, un article) et peut-être même que vous avez essayer mais bon voila ca s’est pas trop bien passé donc vous avez give up. Je suis la pour vous ramener dans le wave de la dockermania! Et vous montrer la puissance et la simplicité du truc surtout pour nous les développeurs mais aussi pour les ops!</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code> Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker’s methodoligies for shipping, testing, and deploying code quickly, you can significantly reduce the delay between writing code and running it in production.
</code></pre></div></div>
<p>C’est la definition officielle disponible sur le site de docker. Je vais essayer de découper la définition et d’expliquer à ma manière:</p>
<ul>
<li><code class="highlighter-rouge">Docker is an open platform for developing, shipping, and running applications</code> : Avec docker nous, développeurs, ne pourrons plus avoir l’excuse “Ca marche sur ma machine”. Sorry guys… Docker nous permet de garder le même environnement en mode dev, staging et production. Votre application est encapsulée dans une boite appelée <code class="highlighter-rouge">container</code> qui sera la même sur votre machine, sur le serveur de test, de prod.</li>
<li><code class="highlighter-rouge">Docker enables you to separate your applications from your infrastructure so you can deliver software quickly</code>: avec docker la structure de votre infra n’est plus aussi critique. Vous avez juste à y avoir un composant qui est capable de lancer un container, docker. Nous reviendrons sur cela.</li>
<li><code class="highlighter-rouge">With Docker, you can manage your infrastructure in the same ways you manage your applications.</code>: docker étant “developer friendly”, vous avez la possibilité de manipuler votre infra comme une application. Ceci parce que votre infra devient juste un ensemble de container à gérer. La notion de serveur devient abstraite. Nous verront que manipuler un container est d’une simplicité bluffante</li>
<li><code class="highlighter-rouge">By taking advantage of Docker’s methodoligies for shipping, testing, and deploying code quickly, you can significantly reduce the delay between writing code and running it in production.</code>: Déployer une application en production dans certain cas(please automate!) n’est pas une tâche facile. Démarrer, arrêter, configurer un container en dev ou en production est une tâche relativement simple et en plus docker peut facilement être intégré dans le workflow de votre CI/CD.</li>
</ul>
<p>Avec docker, le fameux <code class="highlighter-rouge">Write once, run anywhere</code> prend tout son sens. Toute votre architecture sera contenue dans 1 ou plusieurs containers(en fonction que vous soyez en mode monolithique ou micro-services) et la machine hôte n’aura qu’à avoir docker installé et that’s it! La gestion des containers, la communication entre containers tout est géré avec docker.</p>
<h2 id="terminologies">Terminologies</h2>
<p><img src="/assets/architecture_docker.png" alt="Docker Architecture" /></p>
<h4 id="docker-daemon">Docker Daemon</h4>
<p>C’est le process qui permet de manipuler les containers. C’est un daemon, donc il tourne en background sur la machine hôte. À lui tout seul, il sert à rien. Pour l’utiliser il faut un client qui utilise l’api qu’il expose.</p>
<h4 id="docker-client">Docker client</h4>
<p>C’est le client par défaut qui permet d’interagir avec le Daemon docker. Il est accessible via la commande <code class="highlighter-rouge">docker</code> disponible après installation sur votre machine linux, mac ou windows. Il faut savoir que par défaut quand on installe docker, on a le daemon et le client. Mais à partir du client on peut manipuler un daemon distant aussi. On a aussi la possibilité d’utiliser directement l’API si le client ne nous suffit pas.</p>
<h4 id="docker-images">Docker images</h4>
<p>Une image docker est juste une description de ce que doit être le container. On peut dire que c’est un template. Par exemple une image peut contenir un systeme d’exploitation Ubuntu avec Java 8 et une appli java installés. Pour construire une image docker, on crée un fichier <code class="highlighter-rouge">Dockerfile</code> du même nom qui est un plain text et qui permet de décrire le contenu de notre image. On a aussi la possibilité de récupérer une image prête à l’usage. Les produits qu’on utilise pour le dev ont souvent une image officielle déjà prête.</p>
<h4 id="docker-containers">Docker containers</h4>
<p>Un container est juste une instance executable d’une image docker. C’est ce container la qui sera executer pour faire tourner votre app, votre base de données. Vous pouvez le lancer, le supprimer, l’arrêter avec le client docker ou via l’API du daemon. La particularité d’un container docker est qu’il est isolé du monde extérieur par défaut. Sauf si nous lui donnons accès.<br />
Exemple, j’ai une app grails qui expose une API sur le port 9000. On a la possibilité de la rendre accessible sur un port spécifique de la machine hôte. Autre détail, toute modification faite dans le container est perdue après arrêt ou suppression du container. D’où des fonctions de persistence sur la machine hôte du container.</p>
<h4 id="docker-registries">Docker registries</h4>
<p>Une docker registry est une librairie d’images docker. Cette librairie peut être sur la même machine ou en remote. Par défaut, docker dispose d’un registry. hub.docker.com. Quand on fait un <code class="highlighter-rouge">docker pull mysql</code>, on recupere l’image de mysql depuis le registry de docker sur notre machine. Et on peut donc lancer un container et avoir une base de données mysql up and running en quelques minutes. Un registry peut aussi être privé pour un usage en entreprise par exemple. On ne veut pas forcément rendre publique nos apps!</p>
<h4 id="docker-services">Docker services</h4>
<p>Les dockers services vont permettre de créer un swarm. Docker swarm vient faciliter la gestion de containers distribués dans plusieurs Daemon docker situés sur plusieurs machines. Vous avez un swarm manager qui vous permet de gérer globalement votre infra! Vous aurez acces à tout ce qui se fait de mieux en terme de clustering, load balancing, sécurité, etc.</p>
<p>Avec ces quelques notions, on a une petite idée de ce qu’est docker et de ce qu’on doit pouvoir faire avec. C’est un outil super puissant qui peut changer la facon dont on travaille au quotidien mais aussi la facon dont on manage nos applis en production.
Pour ne pas etre long, on va s’arreter la pour cette partie. Lors de <a href="http://soulesidibe.com/2016/10/19/Docker-les-bases-partie-2/">la 2e partie</a> on mettra les mains dans le cambouis!</p>
Ma liste d’outils de dev2016-08-30T00:00:00+00:00http://soulesidibe.github.io/2016/08/30/Mes-outils<p>Au quotidien je travaille principalement sur du mobile et du backend. Et pour mener à bien les projets, j’ai une panoplie d’outils que j’utilise au quotidien. Donc l’idée est de partager ces outils avec vous.
Avant de commencer, j’utilise un Macbook Pro retina mid-2012 avec 16 Go de Ram, Intel Core i7 2.6ghz, SSD 500Go. Donc évidement je suis sous OS X El Captain.
Je ne présenterai que des applications mac(yes mac is best). La majorité d’entre elles ont un équivalent Windows et/ou Linux.</p>
<p>###IDE</p>
<p><strong><a href="http://developer.android.com/tools/studio/index.html">Android Studio</a></strong>: L’IDE préconisé par Google est excellent pour le developpement (j’ai connu eclipse + plugin ADT donc je sais de quoi je parle). Il est basé sur IntellIJ IDEA de la boite JetBrains.</p>
<p><strong><a href="https://www.jetbrains.com/idea/">IntellIJ IDEA</a></strong>: C’est le second IDE le plus populaire après Eclipse. Il est assez complet comme tous les autres IDEs d’ailleurs. Pourquoi celui-ci? On a énormément de docs sur leur site et sur Youtube. Le plugin scala est bien intégré ce qui permet de pouvoir developer une app <strong><a href="http://playframework.com/">Play!</a></strong> sans trop se prendre la tête. Côté Java pur, il a un outil de refractoring et de generation de code super puissant.</p>
<p>###Versionning</p>
<p><strong><a href="https://git-scm.com/">GIT</a></strong> : git init. C’est la commande que je tape tout juste après la creation d’un nouveau projet. Yup je versionne systématiquement mon code source avec git aui est un système de versionning très <a href="https://twitter.com/soulesidibe/status/630097264560709632">puissant</a> que vous devriez essayer si ce n’est pas deja fait.</p>
<p><strong><a href="https://www.atlassian.com/software/sourcetree/overview">SourceTree</a></strong> est un outil de chez Atlasssian qui propose un client Git et Mercurial très complet. Il a une interface assez simple qui permet de faire des recherches assez poussées dans l’historique, et évidement de lancer toutes les actions que permet Git. Cependant, j’ai plus le réflexe d’utiliser la ligne de commande pour des taches simples comme le commit, checkout, etc. Sourcetree me sert plus à avoir une meilleur visualisation de l’historiaque du repo.</p>
<p>###Mes éditeurs de text</p>
<p><strong><a href="https://www.sublimetext.com/">Sublime Text</a></strong> est pour moi le meilleur éditeur de text du moment. Les fonctionnalités que j’utilise le plus sont la recherche de text dans un fichier ou un dossier et le fait de ne pas avoir a enregister un fichier même après fermeture de l’éditeur. Il est aussi extrêmement personnalisable avec un system de plugin.<br />
<strong><a href="http://stackoverflow.com/questions/21012203/how-can-i-install-macvim-on-os-x">Vim</a></strong> est l’un des premiers outils que je cherche à installer sur mon poste ou sur un serveur. Quand on prend le temps de l’étudier, on se rend compte qu’il est tout aussi puissant.</p>
<p>Atom de chez Github semble prometteur mais je n’ai pas eu le temps de l’utiliser.</p>
<p>###Terminal</p>
<p><strong><a href="https://www.iterm2.com/">Iterm</a></strong> sans aucun doute le meilleur terminal sous mac OS. L’une des features que j’aime bien c’est le fait de pouvoir diviser l’ecran en un nombre illimité de terminal. L’outil permet aussi une personnalisation assez poussée.
Mention spéciale: Terminator(Linux).</p>
<p>###Productivity</p>
<p><strong><a href="https://evernote.com/">Evernote</a></strong> est une app de prise de note qui permet aussi de faire de la collecte d’informations depuis une page web, un pdf, une video youtube, etc. Je l’utilise depuis quelques années et je vous le conseillle vivement.</p>
<p><strong><a href="https://www.macupdate.com/app/mac/52683/amphetamine">Amphetamine</a></strong> est un petit programme qui empêche votre mac d’aller en veille. Le plus connu est caffeine. Mais celui ci offre plus de fonctionnalite comme le durée de la non mise en veille.</p>
<p><strong><a href="https://lastpass.com/">lastpass</a></strong> est un gestionnaire de mot de passe. Il permet aussi de générer des mots de passe robustes et vous aides à les utiliser avec son outil auto form filler dispo sur tous les navigateurs et aussi sur mobile. J’y garde les mots de passe de mes comptes persos mais aussi mais accès à certains serveurs ou base de données. Il permet aussi de partager des mot de passe entre utilisateurs lastpass.</p>
<p>###Autres</p>
<p><strong><a href="https://tunnelblick.net/">TunnelBlick</a></strong> est un client VPN gratuit et open source. Si dans votre structure vous avez besoin de vpn pour avoir acces a vos serveur distant TunnelBlick fera l’affaire.</p>
<p><strong><a href="https://filezilla-project.org/">filezilla</a></strong> est un client(ou serveur) FTP, SFTP avec une interface graphique assez simple où avec un drag n drop on peut envoyer ou récupérer des fichiers distants.</p>
<p><strong><a href="https://www.docker.com/">docker</a></strong> est une platforme open source pour les développeurs et les sysadmins permettant de simplifier le build, le deploiement et la mise en production d’application sur son laptop, sur un datacenter ou sur le cloud. Docker me permet de ne plus avoir à installer certains outils directement sur mon mac. Si j’ai besoin d’une base Mysql je lance un container Mysql. That’s it! Tout est transparent pour l’os. J’ai juste à avoir docker sur ma machine et il sait comment faire tourner un container peu importe son contenu. Dans mon exemple c’est un serveur mysql mais ca peut être n’importe quoi! Un serveur apache2, tomcat, java 9, etc. Je reviendrai sur Docker.</p>
<p><strong><a href="https://kitematic.com/">kitematic</a></strong> est une interface graphique au dessus de docker pour ceux qui n’aiment pas trop la ligne de commande. Donc avec quelques clics, on arrive à récupérer une image docker et lancer un container assez facilement.</p>
<p><strong><a href="https://www.virtualbox.org">virtualbox</a></strong> est un outil de virtualisation gratuit et multiplatforme. Avec docker, j’ai de moins en moins le besoin d’avoir une machine virtuelle.</p>
<p><strong><a href="https://github.com/mortenjust/androidtool-mac">androidTool</a></strong> permet de prendre des videos ou des screenshots de son telephone android. Il permet aussi d’installer un apk directement sur un device.</p>
<p><strong><a href="http://www.deezer.com/">Deezer</a></strong> j’aime écouter de la musique pour me concentrer sur ce que je fais et ne pas entendre ce qui se passe autour de moi. Deezer est une assez bonne application offrant des millions de titres avec son abonnement mensuel de 3500FCFA. Si vous avez un abonnement deezer je vous propose cette <strong><a href="http://www.deezer.com/playlist/1036831501?utm_source=deezer&utm_content=playlist-1036831501&utm_term=311696685_1471868343&utm_medium=web">playlist</a></strong> à écouter pendant que vous êtes focus sur une tâche importante :)</p>
<p>Voila un peu quelques apps que j’utilise très souvent. La liste n’est pas exhaustive mais j’espere que certaines d’entre elles vous serviront et vous permettront d’être plus productif.<br />
Peace!</p>
Maitriser gradle. Les premiers pas.2015-11-15T00:00:00+00:00http://soulesidibe.github.io/2015/11/15/maitriser-gradle-permiers-pas<p>Compiler un programme Java(un HelloWorld) n’est pas compliqué. On peut le faire à la main avec la commande javac. Maintenant, que faire dans un projet avec les contraintes suivantes:</p>
<ul>
<li>le projet a besoin d’autres ressources pour marcher à part le code source. Par exemple des fichiers images, json, xml, etc.</li>
<li>le projet doit lancer un jeu de tester JUnit avant chaque génération du Jar du projet</li>
<li>le projet a une multitude de dépendances pour fonctionnener(ex: guava, junit4, jodatime) et télécharger les fichiers jar depuis leurs sites respectifs n’est pas une solution vu qu’il faut une intervention humaine</li>
<li>Le projet doit générer une documentation</li>
<li>Le fichier jar généré doit être déposé sur un repository</li>
</ul>
<p>On peut bien créer notre fichier <strong>shell</strong> pour gérer tout cela mais ce fichier devra aussi être maintenu autant que le code source du projet.
Quand est-il d’un projet android? Le processus de build est très complexe surtout quand on commence à s’ammuser avec les variantes.</p>
<p><img src="/assets/build_android.png" alt="android build" /></p>
<p>Donc on voit que le build d’une app android ne peut pas se faire à la main ou avec un script shell. Nous avons besoin d’un systeme beaucoup plus robuste. Il s’agit de <strong>**Gradle**</strong>.</p>
<p>##Gradle un outil de build (build tool)
Gradle est un outil de build récent. Avant lui on avait le populair maven qui est bien connu dans la communaute java et qui se base sur un fichier pom ou est decrit comment on veut que notre projet soit construit et ou on déclare aussi nos dépendances.
Gradle comme la plus part des outils de build nous garantit trois points essentiels:</p>
<ul>
<li>Portability: Un outil de build doit pouvoir faire son job indifféremment de l’environnement de build.</li>
<li>Automation: une simple commande doit pouvoir lancer tout le process de build et rendre invisible toute la complexité.</li>
<li>Repeatability: le resultat du build doit etre le même no matter who runs it.</li>
</ul>
<p>Il est devenu indispensable d’avoir ce genre d’outil pour simplifier le travail des developpeurs android. On doit pouvoir se concentrer sur l’essentiel. Ecrire du code. Du bon code. Et ne pas trop se casser la tête sur comment les versions free et paid de mon app ont étè générées. Google en ayant choisit gradle et intellij nous aide dans cela.</p>
<h2 id="installer-gradle">Installer gradle</h2>
<p>Il n’est pas necessaire d’installer soit même gradle. Gradle lui meme s’occupe de sa propre installation sur la machine. Bizarre non?<br />
En fait dans un projet gradle nous avons ce qu’on appelle le wrapper. Le wrapper est consitué d’un script shell que l’on va utiliser pour lancer les commandes de gradle et un dossier contenant un fichier jar tres léger et un fichier properties:</p>
<p><img src="/assets/gradle_wrapper.png" alt="Gradle Wrapper" /></p>
<p><code class="highlighter-rouge">build.gradle</code> c’est le fichier de build gradle, on pourra y définir nos tasks, configurer notre projet. <code class="highlighter-rouge">gradlew</code> et <code class="highlighter-rouge">gradlew.bat</code> respectivement pour linux/mac et windows permettent de lancer les commandes gradle. Si la version de gradle specifier dans le fichier <code class="highlighter-rouge">gradle-wrapper.properties</code> n’est pas présente sur la machine, elle sera installée.
De ce fait un build sera a priori le même sur toutes les machines, et surtout sur le serveur d’intégration continue.<br />
On peut cependant vouloir installer manuellement une version spécifique de gradle sur notre machine. Et pour lancer une commande gradle, au lieu de faire un <code class="highlighter-rouge">./gradlew CMD</code>, on fera un <code class="highlighter-rouge">gradle CMD</code>.</p>
<h3 id="installer-gradle-sous-mac">Installer gradle sous mac</h3>
<p>Déjà il faut s’assurer d’avoir java installé. Lancer <code class="highlighter-rouge">java -version</code> pour vérifier.<br />
Ensuite il y a plusieurs façons d’installer gradle:</p>
<ul>
<li>brew: <code class="highlighter-rouge">brew install gradle</code> est la facon la plus simple si vous êtes un utilisateur de <code class="highlighter-rouge">brew</code></li>
<li>Manuellement: il faudra télécharger le zip depuis le <a href="https://gradle.org/downloads/">site</a>, le désarchiver puis ajouter le chemin dans le PATH.</li>
</ul>
<h3 id="installer-gradle-sous-windows">Installer gradle sous windows</h3>
<p>Idem que la deuxieme méthode utilisée sous mac.</p>
<p>Pour veririfier que tout va bien: <code class="highlighter-rouge">gradle --version</code></p>
<p><img src="/assets/gradle-version.png" alt="Gradle version" /></p>
<h2 id="le-fichier-buildgradle">Le fichier build.gradle</h2>
<p>Voici un exemple de fichier <code class="highlighter-rouge">build.gradle</code> provenant d’un projet android:</p>
<p>«««< HEAD
``` gradle
=======</p>
<blockquote>
<blockquote>
<blockquote>
<blockquote>
<blockquote>
<blockquote>
<blockquote>
<p>d323f4db034efb5a688aa9a1ff68d3638077fee9</p>
</blockquote>
</blockquote>
</blockquote>
</blockquote>
</blockquote>
</blockquote>
</blockquote>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>apply plugin: 'com.android.application'
android {
compileSdkVersion 23
buildToolsVersion "23.0.1"
defaultConfig {
minSdkVersion 16
targetSdkVersion 23
}
}
task hello {
doLast {
println "Hello!"
}
}
</code></pre></div></div>
<p>Il a un format similaire à celui du <code class="highlighter-rouge">json</code>. En fait, cela est du au language groovy qui permet d’écrire du code qui est facile à lire et à comprendre.<br />
Mais surtout à cause de ce qu’on appelle la DSL (Domain Specific Language) qui est un langage au dessus de Groovy qui en fonction du plugin qui est appliqué nous donne accès à un ensemble de fonctionnalités qui nous permet de décrire notre build. Ici avec le plugin <code class="highlighter-rouge">com.android.application</code> on a accès au mots cle <code class="highlighter-rouge">android</code>, <code class="highlighter-rouge">task</code>. Pour un autre plugin on n’aura pas acccès aux mêmes fonctionnalités.
Cette DSL n’est pas figée. Elle est extensible par le billet de plugin. Le fichier de build doit rester declaratif et ne doit pas être encombré de logique de code. Donc pour masquer cela, on peut créer un plugin avec notre propre DSL. C’est le cas avec le plugin Android.<br />
C’est ce qui fait que Gradle est polyglote. Il peut builder n’importe quelle projet peu importe le langage utilisé dans le code source. il suffit d’appliquer le bon plugin ou de le créer s’il n’existe pas.</p>
<h2 id="les-tasks-ou-taches">Les Tasks (ou taches)</h2>
<p>Une tâche est un des elements de base de gradle. Elle permet d’executer des actions. Une action peut etre de lancer la commande <code class="highlighter-rouge">javac</code> pour compiler le source code java, de copier un fichier, d’écrire un simple “Hello World”. A ce niveau c’est votre code groovy qui est executé.<br />
Une tâche peut aussi dépendre d’une autre tâche. On peut donc se brancher a n’importe quelle etape du cycle de build.</p>
<p>####Creer une tache</p>
<p>Gradle nous offre différente façon de créer une tache dans notre fichier build.gralde:</p>
<ul>
<li><code class="highlighter-rouge">task("myTask") ou project.task("myTask")</code> est la façon la plus simple de le faire. Pour verifier, il faut lancer <code class="highlighter-rouge">gradle tasks</code> ou <code class="highlighter-rouge">./gradlew tasks</code></li>
<li>Grace à Groovy on peut aussi faire ` task “myTask”` vu que les parenthèses ne sont pas obligatoires quand on a qu’un seul paramètre</li>
<li>Encore mieux Gradle comprend aussi <code class="highlighter-rouge">task myTask</code>. Ce qui n’est pas du code groovy valide vu que <code class="highlighter-rouge">myTask</code> n’a pas étè déclaré. Ceci est du a ce qu’ils appellent <a href="http://groovy-lang.org/metaprogramming.html#_compile_time_metaprogramming">AST Transformations</a> qui permet à la compilation de générer du code ce qui permet de reduire le code inutile et de rendre encore plus comprehensible le fichier de build.</li>
<li>
<p>la facon la plus répandue de créer une tache est la suivance :</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code> task myTask {
//Donnons une description a notre tache
description "My first task"
//Un group
group "Custom Tasks"
//une action a faire en premier
doFirst {
//groovy code...
}
//une action a la fin
doLast {
//groovy code...
}
}
</code></pre></div> </div>
<p>Pour une tache simple, on peut utiliser une syntaxe reduit <code class="highlighter-rouge">task myTask << { println "Hello"}</code>. Et le closure sera executer en dernier comme un <code class="highlighter-rouge">doLast</code></p>
</li>
</ul>
<p>Pour executer une tache on utilise la commande <code class="highlighter-rouge">gradle</code> suivit du nom de la tache<br />
<img src="/assets/gradle_exe_task.png" alt="execute task" /></p>
<h4 id="dependances-et-ordre-dexecution-des-taches">Dependances et ordre d’execution des taches</h4>
<p>Gradle nous donne la possibilité de configurer les dépendances des tâches que nous créons. Entre elles ou par rapport aux tâches disponibles. La commande <code class="highlighter-rouge">dependsOn</code> nous permet de déclarer une ou plusieurs dépendances pour une tâche:</p>
<p>task putOnSocks {
doLast {
println “Putting on Socks.”
}
}</p>
<p>task putOnShoes {
dependsOn “putOnSocks”
doLast {
println “Putting on Shoes.”
}
}</p>
<p>Ici <code class="highlighter-rouge">putOnShoes</code>, pour s’executer, va dépendre de <code class="highlighter-rouge">putOnSocks</code>. Autrement dit <code class="highlighter-rouge">putOnSocks</code> sera s’executera en premier. Quand une tâche dépend de plusieurs autres taches, on passe a dependsOn une liste: <code class="highlighter-rouge">dependsOn = ["taskA", "taskB", "taskC"]</code>.</p>
<p>Dès lors qu’une tâche peut dépendre de plusieurs autres tâches, l’ordre d’execution de ces tâches peut devenir important. Gradle nous permet de gérer l’ordre grace aux commandes suivantes:</p>
<ul>
<li><strong>mustRunAfter</strong> force le fait que la tache doit être executée après la tache. <code class="highlighter-rouge">taskB.mustRunAfter(taskA)</code> obligera d’executer la tache <code class="highlighter-rouge">taskB</code> apres <code class="highlighter-rouge">taskA</code></li>
<li><strong>shouldRunAfter</strong> est similaire mais moins strict que mustRunAfter du fait que la régle n’est pas respectée dans certains cas</li>
<li><strong>finalizedBy</strong> n’est pas une régle d’ordre d’execution mais il nous permet par exemple(<code class="highlighter-rouge">taskX.finalizedBy taskY</code>) de toujours executer <code class="highlighter-rouge">taskY</code> peu importe le résultat de <code class="highlighter-rouge">taskX</code>.</li>
</ul>
<p>Voila pour la deuxième partie de la série portant sur gradle. Il y a énormement de choses a voir et nous ne pourrons pas tout couvrir ici. Mais avec ces deux articles nous avons de quoi debuter :). Le meilleur moyen d’aller en profondeur est de suivre le cours <strong><a href="https://www.udacity.com/course/viewer#!/c-ud867/">Gradle for Android and Java</a></strong> sur <strong>Udacity</strong> et de tout le temps se reférer à la <a href="https://docs.gradle.org/current/userguide/userguide.html">documentation officielle</a> pour comprendre les concepts de base. Petit bonus, la DSL du <a href="http://google.github.io/android-gradle-dsl/current/">plugin android</a> :).</p>
Maitriser gradle. Groovy, les bases2015-09-27T00:00:00+00:00http://soulesidibe.github.io/2015/09/27/maitriser-gradle-Groovy-les-bases<p><a href="https://gradle.org/">Gradle</a> est un outil de build créer par la sociéte Gradle Inc. L’idée est d’avoir une manière simple et puissante de décrire la construction de nos apps.<br />
Pourquoi en parler. La raison est tres simple. Depuis quelques années maintenant Google a fait le choix de Gradle pour construire les apps android. Si vous utilisez android studio, vous faites du gradle peut-être sans le savoir vu qu’il est possible de faire le minimum sans éditer le fichier de <code class="highlighter-rouge">build.gradle</code> directement comme ajouter une dépendence, ajouter un builType, etc.
Gradle a étè conçu avec le language Groovy qui est un language de la JVM. Très puissant et super sympa à utiliser quand on vient du monde verbeux de Java.
Le but de cette série d’articles sera à la fin de pouvoir manipuler notre build en fonction des besoins de notre app. Comme, par exemple, copier les différents fichier apks générés dans un serveur distant. Mais avant cela il faut d’abord un prérequis. Groovy!</p>
<p>##Groovy, trop cool!</p>
<p>Groovy est un language de programmation très séduisant et on sent le souci de vouloir créer un language simple et puissant pour les développeurs Java tout en les gardant dans cette écosystème Java/JVM qui est la force de Java. Ce qui permet de rentrer dans le monde groovy en douceur. La <strong>class generator</strong> est l’outil qui va prendre le code source Groovy, le parser et générer du bytecode qui est compatible avec le bytcode Java. D’ou la possibilité de pouvoir utiliser du code Java dans du Groovy et du groovy dans du Java. Un excellent point pour les secptiques.<br />
Ci-dessous quelques éléments sympas de groovy:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>boolean isFirsGroovy = true;
//some stuff...
if(isFirsGroovy) {
System.out.println("Hello World!");
} else {
System.out.println("Welcome back!");
}
</code></pre></div></div>
<p>Ceci est un code qui ressemble grandement à ce que l’on connait sur Java. Mais c’est aussi du code groovy :). Rendons le plus simple:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>def isFirstGroovy = true
//some stuff...
if(isFirsGroovy) {
println "Hello World!"
} else {
println "Welcome back!"
}
</code></pre></div></div>
<p>Comme on peut le remarquer, les point-virgules pour délimiter une instruction ne sont pas obligatoires. Sauf si on souhaite avoir plusieurs instructions sur une même ligne.<br />
Les parentheses ne sont pas obligatoire aussi pour une methode ayant au moins un paramétre. Ce qui élimine le code inutile et met en évidence l’essentiel.
Groovy importe par défaut certains packages pour nous. il s’agit de:</p>
<ul>
<li>java.io.*</li>
<li>java.lang.*</li>
<li>java.math.BigDecimal</li>
<li>java.math.BigInteger</li>
<li>java.net.*</li>
<li>java.util.*</li>
<li>groovy.lang.*</li>
<li>groovy.util.*</li>
</ul>
<p>Encore plus cool ce sont les <strong>propreties</strong>. Dans grovvy quand une classe expose par exemple des methodes <code class="highlighter-rouge">getNom()</code> et <code class="highlighter-rouge">setNom()</code>, cela veut dire que <code class="highlighter-rouge">nom</code> est une property de la classe. Ce qui est sympa c’est qu’on a pas besoin de creer les accesseurs nous même. Groovy s’occupe de cela:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>class Book{
String title
String author
}
def book = new Bookk()
book.setTitle('Groovy in action')
assert book.getTitle() == 'Groovy in action'
book.title = 'Gradle in action'
assert book.title == Gradle in action Comme on le voit tout devient simple, le code lisible. `book.title = ''` fait appel au setter et non à une instanciation directe. pour le vérifier on va créer notre setter:
class Book{
String title
String author
def setTitle(def aTitle){
println 'Setting the title'
title = aTitle
}
}
def book = new Bookk()
book.title = 'Groovy in action'
//output: 'Setting the title'
</code></pre></div></div>
<p>On utilise bien le setter :). Ce type de code est beaucoup utilisé dans du code groovy pour encore une fois plus de lisibilité.</p>
<p>Groovy étant un <code class="highlighter-rouge">language dynamique</code>, on n’a pas besoin de spécifier le type d’une variable. On met à la place le mot cle <strong>def</strong>. Et encore mieux une meme variable peux changer de type!</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>def book = new Book()
book.title = 'Groovy in action'
book = true
book = 1
println book // output => 1 Ce code marchera sans souci! c'est magique non. Maintenant quand la variable est typée, on ne peut pas changer de type. On retrouve ici le typage fort de Java qui peut être utile dans certain cas.
Book book = new Book()
book.title = 'Groovy in action'
book = true
</code></pre></div></div>
<p>Ce code ne marchera pas. On aura une <code class="highlighter-rouge">GroovyCastException</code>.</p>
<p>Les listes et les maps. Ici aussi groovy simplifie beaucoup les choses et offres énormement de possibilités pour manipuler les listes et les maps</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>//creer une liste
def list = [1,2,3,4]
//changer la valeur
list[0] = 9
//ajouter la valeur 20 a la liste
list.add 20
//Pas de ArrayOutOfbound :)
println list[6] // retourne null
//Donc rajouter une valeur a une position inexistente est possible
list[8] = 12 Le plus cool ici c'est la possiblite de rajouter un élèment à une position qui est en dehors de la taille de la liste. Et on n'a pas besoin de spécifier le type de données contenu dans la liste comme on le ferait avec java (`ArrayList<String>`). Pour créer une liste vide:`def list = []`
// Une map vide
def map = [:]
def map1 = [nom: 'Sidibe', prenom: 'Souleymane', surnom: 'soulesidibe']
assert map1.nom == 'Sidibe'
//ajouter/modifier un nouveau couple cle valeur a la map
map1['city'] = 'Dakar'
</code></pre></div></div>
<p>Quand la clé existe déjà, c’est une moficiation sinon on ajoute le couple.
Les maps sont beaucoup utilisés dans gradle.</p>
<p>Les chaines de caracteres. Encore beaucoup de bonnes choses ici.
Déjà pour définir une chaine de caracteres, il y a deux possibilites. Les quotes simples <code class="highlighter-rouge">''</code> et les doubles quotes <code class="highlighter-rouge">""</code>. Il y a une grande difference entre les deux. La plus notable et la possiblité d’avoir des placeholders avec les <code class="highlighter-rouge">""</code>:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>def nom = 'souleymane sidibe'
println "Mon nom est $nom"
</code></pre></div></div>
<p>Encore mieux, on peut éxecuter du code simple à l’aide d’accolades <code class="highlighter-rouge">${}</code>:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>def nom = 'souleymane sidibe'
println "Mon nom inverse est ${nom.reverse()}"
</code></pre></div></div>
<p>Pas mal non? J’adore groovy!</p>
<p>Groovy supporte également les <strong>closures</strong>. La définition officielle:</p>
<blockquote>
<p>A closure in Groovy is an open, anonymous, block of code that can take arguments, return a value and be assigned to a variable. A closure may reference variables declared in its surrounding scope</p>
</blockquote>
<p>Un exemple de closure dans le GDK:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>def list = [1,2,3,4,5,6,7]
list.each({value ->
println "Valeur: $value"
}) Ceci est une façon simple de boucler une liste. Le bout de code `{value -> println "Valeur: $value"}` est un closure et est executé sur chaque élément de la liste grace à la méthode `each` qui prend en paramétre un closure. Les closures ont la frome `{ [closureParameters -> ] statements }`. les parametres sont optionnels. Quand on a qu'un seul parametre on peut ne pas le specifier et utiliser `it`. Le closure plus haut peut être remplaceé par `{println "Valeur: $it"}`. Comparé aux méthodes en groovy, les closures ont accés aux variables du scope parent:
def myMethod() {
def value = 3
def doubleValue = { value * 2 }
println doubleValue()
}
myMethod()
// output => 6
</code></pre></div></div>
<p>On peut aussi les passer en paramétre à une methode:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>//methode qui execute un closure
def myMethod(Closure closure){
closure()
}
//passage en param d'un closure
myMethod({ println "This is a closure"})
//Les parentheses ne sont pas obligatoires
myMethode { println "This is a closure" }
//Resemble beaucoup a ce qu'on voit dans le fichier build de //gradle
android {
applicationId "com.soulesidibe"
}
</code></pre></div></div>
<p>Quand on commence a les utiliser on ne peut plus s’en passer! Je n’ai pas tout dit mais il faut bien s’arrêter…</p>
<h2 id="conclusion">Conclusion</h2>
<p>Voila voila une petite intro à groovy. Ceci n’est pas un cours sur groovy. Pour mieux comprendre les concepts derrière, quelques liens pour commencer:</p>
<ul>
<li><a href="http://learnxinyminutes.com/docs/groovy/">Un excellent tuto pour commencer</a></li>
<li><a href="https://dl.dropboxusercontent.com/u/48451250/GroovyiA2_CH02.pdf">Un chapitre du livre <code class="highlighter-rouge">Groovy in action</code></a></li>
<li><a href="http://www.groovy-lang.org/documentation.html">La documentation officielle</a></li>
</ul>
<p>Il y a de quoi se documenter et connaitre le minimum requis pour bien comprendre les concepts de gradle.
Le prochain article portera sur les premiers pas avec gradle! See you :).</p>
Android 6.0 Marshmallow est la! (Part 2)2015-09-13T00:00:00+00:00http://soulesidibe.github.io/2015/09/13/android-Marshmallow-part-2<p>L’un des changements les plus importants de la release 6.0 est le nouveau mode de
fonctionnement des permissions. A partir de Android Marshmallow, lors de l’installation d’une nouvelle application sur le playstore, le user n’aura plus à autoriser une liste enorme de permissions. Les demandes d’autorisations se feront au runtime et au besoin. Exemple, l’application a besoin d’écrire sur la mémoire externe, il lui suffira de faire la demande à l’utilisateur via une AlertDialog gérée par le systeme et il pourra accepter ou pas la demande du développeur. Côte client, c’est très intéressant vu qu’on a la main sur qui a droit de faire quoi.<br />
Côte développeur, en fonction des categories des permissions qu’on a defini dans le Manifest, on aura plus ou moins du boulot pour rendre compatible nos applications. On verra ensemble les etapes permettant de rendre compatible nos apps sans trop de difficultés.</p>
<p>##Les permissions</p>
<p>Je ne vais pas revenir sur l’importance des permissions. Parcontre, il est important de connaitre les différents groupes de permissions. La raison est simple. Avec Android 6.0 quand on fait la demande d’une permission, le syteme nous donne acces au groupe ou pas. Ce qui permet au user de ne pas autoriser un par un une liste de permissions appartenant au même groupe.
Prenons le cas d’une application souhaitant gérer nos contacts. Pour récuperer la liste des contacts, elle a besoin de la permission de lecture des contacts donc elle demande l’accès a la permission <code class="highlighter-rouge">READ_CONTACTS</code>. A un certain moment, elle veut modifier un contact, elle a besoin pour cela de la permission d’écriture. Elle demande le droit d’accès à la permission <code class="highlighter-rouge">WRITE_CONTACTS</code> et comme elle avait déjà l’accès au groupe CONTACTS, elle a automatiquement le droit de modifier. Le user n’a pas à autoriser une seconde fois.
Ceci simplifie grandement les choses pour le user mais aussi pour le developpeur.</p>
<p>###<a href="http://developer.android.com/reference/android/Manifest.permission_group.html">Les groupes de permissions</a>
<img src="/assets/permission_groups.png" alt="permissions groups" /></p>
<p>##Comment ca marche</p>
<p>###En théorie</p>
<p>Tout d’abord, avec la multitude de versions d’android disponible sur le marché, nous développeurs devons penser à la retro compatibilité de nos apps(oui rien de bien nouveau…).
La déclaration des permissions utilisées dans le manifest ne change pas rien que pour éviter d’avoir des <code class="highlighter-rouge">SecurityException</code> pour les versions avant la 6.0.</p>
<p>A l’installation d’une application une liste limitée de permissionq est granted à l’application. Le développeur n’aura pas à faire la demande pour avoir l’accès.
Il s’agit des permissions dont le niveau protection est <code class="highlighter-rouge">PROTECTION_NORMAL</code> comme par exemple la permission internet. Evidemment, on a aussi les permissions <code class="highlighter-rouge">PROTECTION_DANGEROUS</code> qui sont accessibles qu’après autorisation du user au runtime. Comme récupèrer les contacts. Pour plus d’infos sur les niveaux de protection voir <a href="http://developer.android.com/guide/topics/manifest/permission-element.html">la doc offcicielle</a>. La liste des permissions et leur niveau de protection y est <a href="http://developer.android.com/reference/android/Manifest.permission.html">dispo!</a></p>
<p>Quand l’app a besoin d’effectuer une action qui requiert une autorisation, il fait la demande au systéme qui affiche ou pas une Dialog(en fonction qu’il est deja l’autorisation ou pas) à l’utilisateur qui peut autoriser ou pas la demande d’accès. Le systéme renvoie un callback à l’app pour lui notifier de la réponse du user. Ce nouveau modèle change le mode de fonctionnement de nos apps et voici quelques points à prendre en compte:</p>
<ul>
<li>
<p>Always check for permissions: Quand l’app a besoin d’une permission pour procéder à un traitement, il faut toujours verifier si on a la permission. Nous verrons comment le faire. Encore une fois les permissions de niveau <code class="highlighter-rouge">PROTECTION_NORMAL</code> n’ont pas besoin d’être vérifiées.</p>
</li>
<li>
<p>Handle Lack of Permissions Gracefully: Il est possible que l’utilisateur n’autorise pas l’accès à certaines fonctionnalités. Il faut garder à l’esprit ce fait. Ce qui est conseillé dans ce cas la est de désactiver la fonctionnalité qui depend de cette permissions et expliquer au user le pourquoi de la non disponibilite de la feature.</p>
</li>
<li>
<p>Permissions are Revocable: Le user peut à tout moment révoquer une permission à n’importe quelle app qu’il a installée. Et l’app n’est pas notifiée de cette révocation. D’ou l’importance de tout le temps vérfifier les droits d’accès.</p>
</li>
</ul>
<p>###En pratique
Voici un petit projet pour illustrer un peu le concept. C’est une app qui affiche dans le logcat le nom du user du device. Simple.
Pour lancer le projet, il faut deja mettre à jour le SDK pour récuperer android 6.0. Puis creer un AVD tournant sous Marshmallow.
Le projet est disponible sur <a href="https://github.com/soulesidibe/AndroidPermission">GitHub</a></p>
<p>Pour afficher le profile du user, on utilise le ContentProvider qui expose tout ce qui est en rapporte avec les contacts:</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"> <span class="c1">// Sets the columns to retrieve for the user profile</span>
<span class="n">String</span><span class="o">[]</span> <span class="n">mProjection</span> <span class="o">=</span> <span class="k">new</span> <span class="n">String</span><span class="o">[]{</span>
<span class="n">ContactsContract</span><span class="o">.</span><span class="na">Profile</span><span class="o">.</span><span class="na">DISPLAY_NAME_PRIMARY</span><span class="o">,</span>
<span class="o">};</span>
<span class="c1">// Retrieves the profile from the Contacts Provider</span>
<span class="n">mProfileCursor</span> <span class="o">=</span> <span class="n">getContentResolver</span><span class="o">().</span><span class="na">query</span><span class="o">(</span>
<span class="n">ContactsContract</span><span class="o">.</span><span class="na">Profile</span><span class="o">.</span><span class="na">CONTENT_URI</span><span class="o">,</span>
<span class="n">mProjection</span><span class="o">,</span>
<span class="kc">null</span><span class="o">,</span>
<span class="kc">null</span><span class="o">,</span>
<span class="kc">null</span><span class="o">);</span>
<span class="k">if</span> <span class="o">(</span><span class="n">mProfileCursor</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
<span class="k">return</span><span class="o">;</span>
<span class="o">}</span>
<span class="n">mProfileCursor</span><span class="o">.</span><span class="na">moveToFirst</span><span class="o">();</span>
<span class="k">while</span> <span class="o">(!</span><span class="n">mProfileCursor</span><span class="o">.</span><span class="na">isAfterLast</span><span class="o">())</span> <span class="o">{</span>
<span class="n">Log</span><span class="o">.</span><span class="na">d</span><span class="o">(</span><span class="s">"Permission Test"</span><span class="o">,</span> <span class="s">"Display Name >> "</span> <span class="o">+</span> <span class="n">mProfileCursor</span><span class="o">.</span><span class="na">getString</span><span class="o">(</span><span class="mi">0</span><span class="o">));</span>
<span class="n">mProfileCursor</span><span class="o">.</span><span class="na">moveToNext</span><span class="o">();</span>
<span class="o">}</span></code></pre></figure>
<p>Pas la peine de revenir sur cette partie. Ce n’est pas le but. Ce qui est important ici c’est qu’il faut avoir la permission <code class="highlighter-rouge">android.permission.READ_CONTACTS</code> pour pouvoir lire le profil du user. Donc pour ne pas avoir de SecurityException, il suffit de rajouter <code class="highlighter-rouge"><uses-permission android:name="android.permission.READ_CONTACTS" /></code> au niveau du manifest.
La tous les devices sous android API 22 et above marcheront. Maintenant ce n’est pas le cas pour l’API 23 vu que la permission <code class="highlighter-rouge">READ_CONTACTS</code> est considerée comme <code class="highlighter-rouge">PROTECTION_DANGEROUS</code>. L’app doit demander la permission au runtime avant de pouvoir proceder au traitement. Ca nous fait du code de ce type à avoir un peu partout dans notre code :</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="k">if</span> <span class="o">(</span><span class="n">Build</span><span class="o">.</span><span class="na">VERSION</span><span class="o">.</span><span class="na">SDK_INT</span> <span class="o"><=</span> <span class="n">Build</span><span class="o">.</span><span class="na">VERSION_CODES</span><span class="o">.</span><span class="na">LOLLIPOP_MR1</span><span class="o">)</span> <span class="o">{</span>
<span class="c1">//permission granted at install time </span>
<span class="o">}</span><span class="k">else</span><span class="o">{</span>
<span class="c1">//Check if permission granted</span>
<span class="o">}</span></code></pre></figure>
<p>Ce qui n’est pas top pour la codebase de notre projet. Mais avec la support library (<code class="highlighter-rouge">23.0.0</code>) on n’a pas a vérifier cela. On pourra directement vérifier si on a le droit de lire les contacts et la support library s’occupera de tester si on est sous android 6 ou pas.
Pour verifier une permission, le code sera le même à chaque fois que l’on desire checker une permission:</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="k">if</span><span class="o">(</span><span class="n">checkSelfPermission</span><span class="o">(</span><span class="n">Manifest</span><span class="o">.</span><span class="na">permission</span><span class="o">.</span><span class="na">READ_CONTACTS</span><span class="o">)</span>
<span class="o">!=</span> <span class="n">PackageManager</span><span class="o">.</span><span class="na">PERMISSION_GRANTED</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">shouldShowRequestPermissionRationale</span>
<span class="o">(</span><span class="n">Manifest</span><span class="o">.</span><span class="na">permission</span><span class="o">.</span><span class="na">READ_CONTACTS</span><span class="o">))</span> <span class="o">{</span>
<span class="c1">//Explain why read contact permission is required</span>
<span class="o">}</span>
<span class="n">requestPermissions</span><span class="o">(</span>
<span class="k">new</span> <span class="n">String</span><span class="o">[]{</span><span class="n">Manifest</span><span class="o">.</span><span class="na">permission</span><span class="o">.</span><span class="na">READ_CONTACTS</span><span class="o">},</span>
<span class="n">PERMISSION_REQUEST_CONTACTS</span>
<span class="o">);</span>
<span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
<span class="c1">//Permission read contact granted</span>
<span class="n">getProfile</span><span class="o">();</span>
<span class="o">}</span></code></pre></figure>
<p>Detaillons un peu ce code:
<code class="highlighter-rouge">checkSelfPermission(Manifest.permission.READ_CONTACTS)</code> permet de vérifier si on a la permission <code class="highlighter-rouge">READ_CONTACTS</code>. Si c’est le cas la méthode retourne un <code class="highlighter-rouge">PERMISSION_GRANTED</code>. On peut proceder à la lecture des informations du contact sinon un <code class="highlighter-rouge">PERMISSION_DENIED</code> nous oblige à faire une demande au syteme via le methode <code class="highlighter-rouge">requestPermissions(String[], int)</code>.
Le syteme affiche donc une AlertDialog au user lui demandant d’autoriser ou pas la demande:
<img src="/assets/permission_request.png" alt="Permission request" /></p>
<p>Le resulat de la demande sera traité dans le <code class="highlighter-rouge">onRequestPermissionsResult</code> :</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="k">if</span> <span class="o">(</span><span class="n">requestCode</span> <span class="o">==</span> <span class="n">PERMISSION_REQUEST_CONTACTS</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">grantResults</span><span class="o">[</span><span class="mi">0</span><span class="o">]</span> <span class="o">==</span> <span class="n">PackageManager</span><span class="o">.</span><span class="na">PERMISSION_GRANTED</span><span class="o">)</span> <span class="o">{</span>
<span class="c1">// Permission has been granted. </span>
<span class="n">getProfile</span><span class="o">();</span>
<span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
<span class="c1">// Permission request was denied.</span>
<span class="o">}</span>
<span class="o">}</span></code></pre></figure>
<p>La constante <code class="highlighter-rouge">PERMISSION_REQUEST_CONTACTS</code> est fournie dans la methode <code class="highlighter-rouge">requestPermissions</code> et permet d’identifer la demande.<br />
Il peut arriver que le user deny notre demande. En plus de désactiver la fonctionnalité dont dépend cette permission, il faut pouvoir expliquer au user le pourquoi de cette permission. La méthode <code class="highlighter-rouge">shouldShowRequestPermissionRationale()</code> nous indique le bon moment pour faire cela.<br />
Les methodes <code class="highlighter-rouge">requestPermissions()</code>, <code class="highlighter-rouge">onRequestPermissionsResult()</code>, <code class="highlighter-rouge">shouldShowRequestPermissionRationale()</code> ont été ajoutées à android 6.0 donc ne sont pas dispo pour 5.x et les autres. Mais encore ici, la support library nous gére cela. Il suffit d’utiliser <code class="highlighter-rouge">AppCompatActivity</code> ou <code class="highlighter-rouge">Fragment</code> de la support-v4 pour y avoir accès.</p>
<p>##Mettre à jour une application existente</p>
<p>Le cas traité plus haut concerne plus une nouvelle app. Dans le cas d’une application qui target android 5.x, cela peut être un peu moins simple à gérer. Mais en suivant les étapes suivantes, on peut le s’en sortir relativement bien.</p>
<p>Tout d’abord il faut identifier au niveau du manifest toutes les permissions déclarées. C’est aussi locasion de voir la pertinence de ces permissions pour l’app. Il est courant de déclarer une tonne de permissions dont on n’a pas le besoin.
Ci-dessous la liste des permissions de niveau normal et dangereux. Cela vous permettra d’ientifier assez vite quelles permissions devront être revues côté code pour prendre en compte android 6.0. Après, il suffira de dérouler ce qui a été expliqué plus haut et tout devrait bien se passer :).</p>
<p>####Liste des permissions de niveau <code class="highlighter-rouge">PROTECTION_NORMAL</code></p>
<p>Ces permissions peuvent être utilisées sans procéder à la demande au runtime. Elle seront granted automatiquement à l’installation de l’app:</p>
<ul>
<li><code class="highlighter-rouge">android.permission.ACCESS_LOCATION_EXTRA_COMMANDS</code></li>
<li><code class="highlighter-rouge">android.permission.ACCESS_NETWORK_STATE</code></li>
<li><code class="highlighter-rouge">android.permission.ACCESS_NOTIFICATION_POLICY</code></li>
<li><code class="highlighter-rouge">android.permission.ACCESS_WIFI_STATE</code></li>
<li><code class="highlighter-rouge">android.permission.ACCESS_WIMAX_STATE</code></li>
<li><code class="highlighter-rouge">android.permission.BLUETOOTH</code></li>
<li><code class="highlighter-rouge">android.permission.BLUETOOTH_ADMIN</code></li>
<li><code class="highlighter-rouge">android.permission.BROADCAST_STICKY</code></li>
<li><code class="highlighter-rouge">android.permission.CHANGE_NETWORK_STATE</code></li>
<li><code class="highlighter-rouge">android.permission.CHANGE_WIFI_MULTICAST_STATE</code></li>
<li><code class="highlighter-rouge">android.permission.CHANGE_WIFI_STATE</code></li>
<li><code class="highlighter-rouge">android.permission.CHANGE_WIMAX_STATE</code></li>
<li><code class="highlighter-rouge">android.permission.DISABLE_KEYGUARD</code></li>
<li><code class="highlighter-rouge">android.permission.EXPAND_STATUS_BAR</code></li>
<li><code class="highlighter-rouge">android.permission.FLASHLIGHT</code></li>
<li><code class="highlighter-rouge">android.permission.GET_PACKAGE_SIZE</code></li>
<li><code class="highlighter-rouge">android.permission.INTERNET</code></li>
<li><code class="highlighter-rouge">android.permission.KILL_BACKGROUND_PROCESSES</code></li>
<li><code class="highlighter-rouge">android.permission.MODIFY_AUDIO_SETTINGS</code></li>
<li><code class="highlighter-rouge">android.permission.NFC</code></li>
<li><code class="highlighter-rouge">android.permission.READ_SYNC_SETTINGS</code></li>
<li><code class="highlighter-rouge">android.permission.READ_SYNC_STATS</code></li>
<li><code class="highlighter-rouge">android.permission.RECEIVE_BOOT_COMPLETED</code></li>
<li><code class="highlighter-rouge">android.permission.REORDER_TASKS</code></li>
<li><code class="highlighter-rouge">android.permission.REQUEST_INSTALL_PACKAGES</code></li>
<li><code class="highlighter-rouge">android.permission.SET_TIME_ZONE</code></li>
<li><code class="highlighter-rouge">android.permission.SET_WALLPAPER</code></li>
<li><code class="highlighter-rouge">android.permission.SET_WALLPAPER_HINTS</code></li>
<li><code class="highlighter-rouge">android.permission.SUBSCRIBED_FEEDS_READ</code></li>
<li><code class="highlighter-rouge">android.permission.TRANSMIT_IR</code></li>
<li><code class="highlighter-rouge">android.permission.USE_FINGERPRINT</code></li>
<li><code class="highlighter-rouge">android.permission.VIBRATE</code></li>
<li><code class="highlighter-rouge">android.permission.WAKE_LOCK</code></li>
<li><code class="highlighter-rouge">android.permission.WRITE_SYNC_SETTINGS</code></li>
<li><code class="highlighter-rouge">com.android.alarm.permission.SET_ALARM</code></li>
<li><code class="highlighter-rouge">com.android.launcher.permission.INSTALL_SHORTCUT</code></li>
<li><code class="highlighter-rouge">com.android.launcher.permission.UNINSTALL_SHORTCUT</code></li>
</ul>
<p>####Liste des permissions de niveau <code class="highlighter-rouge">PROTECTION_DANGEROUS</code></p>
<p>La liste des permissions que vous devez obligatoirement vérifier au runtime quand votre app tourne sous android 6.0 et plus</p>
<p><img src="/assets/dangerous.png" alt="PROTECTION_DANGEROUS" /></p>
<p>###Bonus
Quelques liens et videos utils pour aller en profondeur et surtout mieux comprendre le concept:</p>
<ul>
<li><a href="http://developer.android.com/preview/features/runtime-permissions.html">Permisions</a> [article]</li>
<li><a href="https://plus.google.com/+AndroidDevelopers/posts/FqgHUevqHiK">Why runtime permissions shouldn’t scare you</a> [article]</li>
<li><a href="http://android-developers.blogspot.sn/2015/08/building-better-apps-with-runtime.html?linkId=16779377">Building better apps with Runtime Permissions</a> [article]</li>
<li><a href="https://github.com/googlesamples/android-RuntimePermissionsBasic">Android RuntimePermissionsBasic Sample</a> [github]</li>
<li><a href="https://github.com/soulesidibe/AndroidPermission">My Sample code</a> [github]</li>
<li><a href="https://www.youtube.com/watch?v=WGz-alwVh8A">Android, May I. Droidcon NYC</a> [video]</li>
<li><a href="https://www.youtube.com/watch?v=f17qe9vZ8RM">Google I/O 2015 - Android M Permissions</a> [video]</li>
</ul>
<p>C’est tout pour les permissions. C’est un sujet assez important à ne pas négliger si on souhaite que notre app supporte android 6.0. Il faut prendre le temps de comprendre les choses et de les tester.
Je suis ouvert à toutes questions, suggestions en commentaire ou sur twitter(@soulesidibe).</p>
Android 6.0 Marshmallow est la! (Part 1)2015-08-30T00:00:00+00:00http://soulesidibe.github.io/2015/08/30/android-Marshmallow-part-1<p><img src="/assets/marshmallow.jpg" alt="android 6.0" /></p>
<p>L’équipe Android a annoncé il y a quelques jours le nom de la prochaine version. On savait que le nom commencerait par <strong>M</strong>. Mais la c’est dit. Let me introduce you <strong>Marshmallow</strong>! Pour l’occasion on passe à <strong>android 6.0 API version 23</strong>. Donc vous savez ce que vous avec à faire dès maintenant:</p>
<figure class="highlight"><pre><code class="language-groovy" data-lang="groovy"><span class="n">android</span> <span class="o">{</span>
<span class="n">compileSdkVersion</span> <span class="mi">23</span>
<span class="o">...</span>
<span class="n">defaultConfig</span> <span class="o">{</span>
<span class="n">targetSdkVersion</span> <span class="mi">23</span>
<span class="o">...</span>
<span class="o">}</span>
<span class="o">...</span>
<span class="o">}</span></code></pre></figure>
<p>Il s’agit de la preview 3 du sdk. D’après ce qu’ils avaient dit lors de la dernière Google IO, la preview 3 est la version finale du SDK. Ce qui veut dire qu’on peut se baser sur les APIs fournies sans craindre de nouvelles modifications. La version finale sortira lors du Q3 de cette année 2015. Soon!!!</p>
<p>##Installer android 6.0</p>
<p>Pour les nexus owners désirant tester la nouvelle version sur un vrai device, les images sont disponibles pour les nexus 5, nexus 6, nexus 9 et nexus player au niveau du site <a href="http://developer.android.com/preview/download.html">officiel</a>.
Sinon, après mise à jour du SDK depuis android studio, il est possible de créer des AVDs tournant sous Marshmallow.</p>
<p>##Quoi de neuf?</p>
<p>Android Marshmallow n’apporte pas énormement de chose comme Android Lollipop(avec son material design et cie). D’ou mon incomprehesion du passage à une version 6.0 au lieu de 5.2 par exemple.</p>
<p>#####<a href="http://developer.android.com/preview/features/app-linking.html">App Links</a></p>
<p>App links est une nouvelle façon de gérer les liens web sur un smartphone tournant sous android 6.0 et plus. Ca va permettre de pouvoir ouvrir directement l’application au lieu de lancer le navigateur par defaut ou de proposer une liste d’applications pouvant gérer le lien.<br />
Donc une meilleur experience pour un utilisateur qui aura moins d’actions à faire pour accéder au contenu.
Comment le mettre en place?</p>
<p>App Links utilise les Intents pour gérer les requêtes d’ouverture d’URLs. Donc pour dire au système que tel URL doit être ouvert par mon app, on rajoute un intent-filer dans le manifest de votre app:</p>
<figure class="highlight"><pre><code class="language-xml" data-lang="xml"><span class="nt"><activity</span> <span class="err">...</span><span class="nt">></span>
<span class="nt"><intent-filter></span>
<span class="nt"><action</span> <span class="na">android:name=</span><span class="s">"android.intent.action.VIEW"</span> <span class="nt">/></span>
<span class="nt"><category</span> <span class="na">android:name=</span><span class="s">"android.intent.category.DEFAULT"</span> <span class="nt">/></span>
<span class="nt"><category</span> <span class="na">android:name=</span><span class="s">"android.intent.category.BROWSABLE"</span> <span class="nt">/></span>
<span class="nt"><data</span> <span class="na">android:scheme=</span><span class="s">"http"</span> <span class="nt">/></span>
<span class="nt"><data</span> <span class="na">android:scheme=</span><span class="s">"https"</span> <span class="nt">/></span>
<span class="nt"><data</span> <span class="na">android:host=</span><span class="s">"www.android.com"</span> <span class="nt">/></span>
<span class="nt"></intent-filter></span>
<span class="nt"></activity></span></code></pre></figure>
<p>Là, on lui dit que le lien <code class="highlighter-rouge">www.android.com</code>, en utilisant le protocole <code class="highlighter-rouge">http</code> ou <code class="highlighter-rouge">https</code> est lié à cette application.
Maintenant, s’il suffit de rajouter cela à notre manifest, n’importe qui pourra lier son app à un site qui ne lui appartient pas. Ils ont évidemment pensé à cela. Le domaine déclaré dans le manifest doit hoster un fichier json(<code class="highlighter-rouge">assetlinks.json</code>) ayant les informations permettant de vérifier l’app voulant être liée à ce domaine. Dans notre cas <code class="highlighter-rouge">www.android.com</code>.
Ce fichier json doit être localisé suivant un pattern défini:
<code class="highlighter-rouge">https://domain[:optional_port]/.well-known/assetlinks.json</code>.
Et voici sont contenu:</p>
<figure class="highlight"><pre><code class="language-json" data-lang="json"><span class="p">[{</span><span class="w">
</span><span class="s2">"relation"</span><span class="p">:</span><span class="w"> </span><span class="p">[</span><span class="s2">"delegate_permission/common.handle_all_urls"</span><span class="p">],</span><span class="w">
</span><span class="s2">"target"</span><span class="p">:</span><span class="w"> </span><span class="p">{</span><span class="w">
</span><span class="s2">"namespace"</span><span class="p">:</span><span class="w"> </span><span class="s2">"android_app"</span><span class="p">,</span><span class="w">
</span><span class="s2">"package_name"</span><span class="p">:</span><span class="w"> </span><span class="s2">"com.example"</span><span class="p">,</span><span class="w">
</span><span class="s2">"keytool -list -v -keystore my-release-key.keystore"</span><span class="p">:</span><span class="w">
</span><span class="p">[</span><span class="s2">"14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5"</span><span class="p">]</span><span class="w">
</span><span class="p">}</span><span class="w">
</span><span class="p">}]</span></code></pre></figure>
<p>Les informations les plus importantes de ce json sont le <code class="highlighter-rouge">package_name</code> qui est le package name de l’application, et le <code class="highlighter-rouge">sha256_cert_fingerprints</code> qui représente l’empreinte SHA256 de la clé de signature de l’app. Et pour l’obtenir: <code class="highlighter-rouge">keytool -list -v -keystore my-release-key.keystore</code>. A noter qu’il est possible d’avoir plusieurs clé ‘sha256_cert_fingerprints’ dans le même fichier json. Ce qui est utile quand on a plusieurs variantes de notre application.</p>
<p>C’est tout pour cette premiere partie. Je parlerai du nouveau <strong>systeme de permission</strong> lors de la partie 2.</p>
<p>Peace!</p>
I'm a podcast addict!2014-04-13T00:00:00+00:00http://soulesidibe.github.io/2014/04/13/Im-a-podcast-addict<p>Depuis que j’ai découvert ce concept(en fin 2012) je ne peux plus m’en passer!
C’est un outil génial qui me permet d’être informé sans founir d’effort. Juste écouter!</p>
<p>Alors pour ceux qui ne saurait pas c’est quoi, c’est tout juste un fichier, en général au format audio ou vidéo, diffusé par un tiers et surtout téléchargeable en s’abonnant à un flux rss.</p>
<p>Je ne suis pas la pour vous faire un cours sur le <a href="http://en.wikipedia.org/wiki/Podcast">podcasting</a> mais plutôt de partager mes podcasts préférés
en tant qu’amoureux de la tech!</p>
<p>##Les podcasts tech francais</p>
<p>La france regorge de trés grands podcasteurs dont certains que j’écoute toutes les semaines ou à chaque nouvel épisode.</p>
<p>####La famille <a href="http://nipcast.com">nipcast</a>
<em>Nipcast</em> est un ensemble de podcast couvrant pas mal de domaines. La plus part tres orientée tech.
Mes préférés:</p>
<ul>
<li><a href="http://nipcast.com/category/nipdev/">NipDev</a> est un podcast orienté dev. On y discute de sujets spécifiques de la programation(les tests, les API rest, etc). De temps en temps des specialistes de leur domaine sont invités pour partager, informer. J’ai bien aimé le <a href="http://nipcast.com/nipdev-15-tout-savoir-sur-amazon-web-services-avec-sebastien-stormacq/">nipdev</a> 15 avec <a href="https://twitter.com/sebsto">Sebastien Stormacq</a> qui est venu parler de l’univers des services d’amazon pour les développeurs, les startups, les entreprises.</li>
<li><a href="http://www.niptech.com/podcast/category/niptech/">Niptech</a> est le podcast pour être au courant de tout ce qui se passe dans le monde de la tech et des startups partout dans le monde particuliérement en Europe et aux USA (Sillicon Valley). Franchement pas besoin de s’abonner à des dizaines de sites d’informations et perdre du temps à les lire ou à les empiler sur <a href="getpocket.com">Pocket</a>. Toute l’information qui a marqué la semaine sera traitée par des podcasteurs avertis et la plus part travaillant dans le monde de la tech.</li>
</ul>
<p>D’autres podcast sont aussi de cette famille. Dont NipLife(qui parle de lifeHacking) que je suis beaucoup et de temps en temps NipSale(qui parle de la vente).</p>
<p>####<a href="http://frenchspin.com/category/le-rdv-tech/">Le rendez-vous Tech</a>
Le RVT est un plus orienté news tech par rapport à niptech. C’est un exellent podcast pour ne rater aucune information dans cette univers des produits qui font le buzz, de la Sillicon Valley. etc.
Il est édité par <a href="http://patrickbeja.com/">Patrick</a>. Un des plus célèbres podcasteurs de France. Il est aussi derrière <a href="">AppLoad</a> un autre podcast qui donne des conseilles d’apps à tester sous Android, IOS et de temps en temps windows phone.</p>
<p>####<a href="http://lescastcodeurs.com/">Les cast codeurs</a>
Si tu es développeur java, java ee, android ou tout simplement n’importe quel language de la JVM, tu es
servi! On y parle des news dans le monde java (LCC 99 sujet: sortie de java 8!) mais aussi comme dans nipdev, de temps en temps des stars du dev sont invites. Je me rappelle encore du <a href="http://lescastcodeurs.com/2009/08/26/les-cast-codeurs-podcast-episode-8-interview-de-romain-guy-sur-google-android/">LCC 8</a> ou on avait invité Romain Guy.L’un des développeurs les plus influants du monde android. Un podcast a écouter! Il date de 2009. C’est assez drole de voir que le systéme a beaucoup évolué et surtout trés vite!</p>
<p>##Les podcasts tech us
Les podcast us sont tout aussi nombreux, voir plus, que ceux francais. Il y en a pour tous les goûts.
Et surtout des podcasts specialisés.</p>
<p>####<a href="http://androidbackstage.blogspot.com/">Android Developers Backstage</a>
Le podcast pour les développeurs android et par les concepteurs d’android! On ne peut pas rêver de mieux.
La publication n’est pas constante mais on a des informations pointues venant de ceux mêmes qui les ont mises en place. J’ai bien aimé l’episode 4 sur les Google Play Services.</p>
<p>####<a href="http://www.androidpolice.com/tags/android-police-podcast/">Android Police Podcast</a>
Si vous êtes intéressés par android vous connaissez forcément le site <a href="http://www.androidpolice.com/">Android Police</a>. Ils ont un podcast et chaque semaine l’information autour d’android(les apps, les release d’android, les nouveaux devices, etc.) est traité pour notre plus grand bonheur :).</p>
<p>####<a href="http://twit.tv/show/this-week-in-tech/452">Twit</a> et <a href="http://twit.tv/show/this-week-in-google/244">Twig</a>
TWIT pour This Week In Tech et Twig (In Google). Je peux dire que c’est le meilleur podcast pour être
informé sur l’actu tech aux USA. On vous dit tout! Ce sont des épisodes qui peuvent aller jusqu’à 2h de temps. Je peux l’écouter sur plusieurs jours. J’aime bien la rubrique Google changeLog dans TWIG. On y parle des changements qui ont été apportés sur les services Google.</p>
<p>####Les autres
Il y a vraiment beaucoup de trés bon podcast us. mais bon on ne peut pas tout écouter aussi. Pas par manque de temps mais du fait que c’est la même information qui revient dans chacun des podcasts.
Je peux donc rajouter à cette liste <a href="http://www.theverge.com/video/the-vergecast">The VergeCast</a>, <a href="http://autocomplete.fm/">AutoComplete</a>, etc.</p>
<p>##Le PodCast Sénégalais!</p>
<p>Ce n’est pas une erreur. Nous aussi, on a notre podcast! Bon il n’est pas au niveau des autres mais je suis super content de cette initiative de <a href="https://plus.google.com/+LégerDjiba">Leger Djiba</a>. Il s’agit de <a href="http://www.mixcloud.com/gateway4africa/">Gateway4Africa</a>.<br />
On y parle de l’actu tech au Sénégal mais aussi en Afrique. On parle aussi des efforts que nous devont faire pour être la premiére nation en Afrique en terme de nouvelle technologie. Et on en a vraiment les capacités.
Bonne continuation!</p>
<p>##Les outils
Pour écouter ces podcasts, les télécharger, les rangers, planifier, supprimer les anciens épisodes, verrouiller des épisodes qu’on aimerait écouter encore, il nous faut bien des apps.
Côte mobile, pour moi les deux meilleures apps mobiles sont <a href="http://www.beyondpod.com/Android/">BeyondPod</a> et <a href="http://www.shiftyjelly.com/pocketcasts">PocketCast</a>. BeyondPod a une version free mais les versions payantes de ces deux apps offrent beaucoup plus de fonctionnalités.
Cote desktop, étant sous Ubuntu 13.10, je n’ai pas trouvé l’application qui me convient.</p>
<p>Je vous conseille vivement de vous mettre aux podcasts. C’est une façon assez efficace de s’informer, d’être au courant. Perso j’utilise de moins en moins feedly et ça me fait gagner beaucoup de temps!</p>
Nexus 5, Android kitkat et Android Studio 0.3.22013-11-01T00:00:00+00:00http://soulesidibe.github.io/2013/11/01/Nexus-5-Android-kitkat-et-Android-Studio-0-3-2<p>Hier on a eu droit à un bon paquet de nouveautés dans le monde merveilleux d’android.
Je vais essayer de revoir ce qui s’est passé :).</p>
<p>##Nexus 5</p>
<p><img src="/assets/lg-nexus-5-photo.png" alt="nexus5" /></p>
<p>Enfin!
Depuis un bon moment on nous parle de ce nouveau nexus sur les sites spécialisés. Il est là! Et il est beau!
La première chose qui frappe c’est la taille de la bête; un écran de 5 pouces(4.95” en réalité) full HD équipé
de la dernière version d’android(on en parle en bas).
Point important, il est 4G! Comme tous les smartphones récemment sortis. Pour plus de détails c’est ici ==> <a href="http://www.google.fr/nexus/5/">Page officielle</a>.
Ayant un <strong>#nexus4</strong>, quand je revois les spécifications techniques du <strong>#nexus5</strong>, je me dis que c’est juste
une mise à jour du matériel avec un meilleur capteur photo, la 4G et un sublime écran.
Perso avoir un smartphone de 5 pouces ne me tente pas vraiment même si je pense que c’est la taille maximal pour un tel.
Si vous êtes un nexus fan boy et que vous avez un nexus 4(et qu’il est en bonne état), vous pouvez vous passer du nexus 5.
Surtout que vous recevrez bientôt la mise à jour KitKat…</p>
<p>##Android KiKat 4.4</p>
<p><img src="/assets/android-kitkat.jpg" alt="kitkat" /></p>
<p>Celui la on la vraiment attendu et il n’a pas déçu! Cette version android est annoncée comme celle qui
va permettre de réduire encore plus la fragmentation du système Android. En effet, d’après les dires de
<a href="https://plus.google.com/+SundarPichai">Sundar Pichai</a>, Kitkat pourra tourner sur beaucoup plus de smartphones android et non que sur les derniers.
Il suffira d’un device avec au moins <strong>512Mo</strong> de Ram. Ce qui va permettre de reduire encore plus vite la
part de <a href="http://goo.gl/BvZRw">Gingerbread</a> pour le plus grand bonheur de nous les dév android mais aussi des possesseurs de tel
sous 2.3.x (rendez vous en mi 2014 pour déclarer la mort de Froyo, Gingerbread et HoneyComb :D ).</p>
<p>Côté apps, la plupart des apps de <strong>#google</strong> vont recevoir des maj. Les plus attendus sont:</p>
<ul>
<li>Hangout: Avec l’intégration des sms(l’ancienne app sms disparaît), le partage de position et d’autres nouvelles fonctionnalités. Si vous êtes pressés l’app est déjà dispo sur le net ==> <a href="http://goo.gl/uuKh2U">ICI</a></li>
<li>Google Home: La home reçoit aussi une maj (je vais devoir désactiver <a href="http://goo.gl/ApNyPM">aviate</a> :-( ) avec une nouvelle façon D’accéder à Google Now</li>
</ul>
<p>Et bien d’autres nouveautés que vous retrouverez assez facilement sur le net…</p>
<p>##Android Studio 0.3.2</p>
<p>L’IDE pour faire des applications android est passé hier après-midi à la version 0.3.2 avec des fonctionnalités super sympa!</p>
<p>####Screenrecording</p>
<p>Quand on publie une app sur le play store, il faut montrer des screenshots qui exposent les fonctionnalités
importantes de l’app. Encore mieux une vidéo de démo permet de voir comment l’app doit être utilisé.
Cette vidéo peut donner envie ou pas d’installer l’app. Faire des vidéos de qualité n’était pas chose simple
sur android. Mais ca c’était avant! le SDK android inclut un outil qui permet de faire des vidéos de démo à partir de notre tel et avec du MP4 comme ouput. C’est vraiment super!
NB: <em>Il faut etre sous <strong>kitkat</strong></em></p>
<p>####Java 7</p>
<p>Android supporte maintenant java 7! Un dév android c’est avant tout un dév java! et plus tu es bon en java plus tu l’es en dév android! Donc avec java 7 (je rentrerai pas dans les details) on peut par exemple faire un switch case avec des strings! Du multi catch:</p>
<p><img src="/assets/multicatch1.png" alt="Multi catch" /></p>
<p><img src="/assets/multicatch2.png" alt="Multi catch" /></p>
<p>####Gradle integration</p>
<p>Si vous l’utilisez déjà comme IDE principal(je ne me rappelle même plus la dernière fois que j’ai ouvert eclipse…),
vous vous êtes rendu compte de la lenteur quand on fait un build! Une petite astuce permet d’améliorer ca en
utilisant le mode daemon de gradle. Maintenant avec studio une simple case à cocher permet de gagner en temps lors de vos builds!</p>
<p><img src="/assets/faster-builds.png" alt="daemon gradle" /></p>
<p>Voila voila en gros ce qui c’est passé hier! J’ai juste survolé mais je reviendrais sur les nombreuses nouveautés de l’API 19!</p>
Gradle Please!2013-10-15T00:00:00+00:00http://soulesidibe.github.io/2013/10/15/gradle-please<p>Depuis son annonce au Google IO 2013, <strong>Android Studio</strong> est devenu mon IDE number 1!
Je l’utilise au quotidien et tous mes projets eclipse ont migré. J’explique dans <a href="http://localhost:4000/2013/08/11/de-eclipse-a-android-studio/">ce billet</a> comment faire la migration.
L’utilisation de gradle comment système de build rend un projet android beaucoup plus simple à maintenir surtout en ce qui concerne la gestion des dépendances.
Plus besoin d’importer des librairies à en plus finir! Un exemple d’ajout de dépendance:</p>
<figure class="highlight"><pre><code class="language-groovy" data-lang="groovy"><span class="n">dependencies</span> <span class="o">{</span>
<span class="n">compile</span> <span class="s1">'com.crashlytics.android:crashlytics:1.+'</span>
<span class="o">}</span></code></pre></figure>
<p>Donc comme on le voit pour utiliser crashlytics c’est speed. Gradle se chargera de récupérer les fichiers qu’il faut et de les mettre dans le build path.</p>
<p>Maintenant, la plus part des projets open source qu’on utilise dans nos projets n’offrent pas cette possibilité(non disponibilité du aar). Donc voici un peu ce qu’on peut faire:</p>
<ul>
<li>Demander au développeur de rendre son projet compatible avec gradle(sur github on peut facilement dialoguer avec le dév. En anglais),</li>
<li>Si on ne peut pas patienter, on peut toujours récupérer le projet</li>
</ul>
<p><code class="highlighter-rouge">git clone chemin/vers/project.git project</code>, ajouter en tant que module dans le projet puis rajouter
cette ligne dans build.gradle <code class="highlighter-rouge">compile project(':project')</code> et dans settings.gradle <code class="highlighter-rouge">include ':project'</code></p>
<p>Un site recense l’ensemble des projets open source qui ont été <strong>“gradlisé”</strong>. C’est <a href="http://gradleplease.appspot.com/">gradle please</a>! :D</p>
De eclipse à android Studio2013-08-11T00:00:00+00:00http://soulesidibe.github.io/2013/08/11/de-eclipse-a-android-studio<p>Comme vous le savez tous, lors du google IO 2013, il y a eu beaucoup de nouvelles concernant les développeurs android.
Je ne vais pas toutes les lister ici mais juste celle qui nous intéressent pour l’article du jour.
La team android nous a donc annoncé Android Studio! La nouvelle bête pour nos dévs en remplacement de l’IDE éclipse.</p>
<p>Vous me direz ouff enfin un IDE dédié au développement android! Yes ils se sont enfin décidé.
La seconde grosse annonce fut le remplacement du système de build ant par gradle.
<a href="http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Goals-of-the-new-Build-System"><strong>ICI</strong></a> les raisons pour lesquelles la team android l’a choisi.</p>
<p>Ok mais le souci est que tous nos projets actuels sont sous eclipse. Maintenant comment faire migrer ces projets
la vers SA et gradle? Google nous a fourni une démarche à suivre sur le site officiel. Pour un projet simple ca peut passer. Mais quand on a des projets librairies par ici ou des jars à en plus finir, ca devient un vrai casse-tête pour arriver à cette image:</p>
<p><img src="/assets/capture-du-2013-08-11-140412.png" alt="Android Studio" /></p>
<p>Mais bon on est la pour atteindre cette objectif :-).
Il nous faut, avant de commencer, un projet concret où on retrouvera quelques librairies(sous forme de project library
ou de jar). Pour vous faire gagner du temps en voici un petit projet héberger sur <a href="https://github.com/soulesidibe/KillApp">githtub</a>.</p>
<p>Donc, on y trouve un projet utilisant les librairies ActionBarSherlock, PullToRefresh et deux jars l’un le support-v4
et une petite lib permettant d’utiliser l’api de bitly. Il vous suffit maintenant de cloner le projet et de redemarrer votre eclipse en prenant pour workspace le dossier créé lors du clone et enfin commencer :-).</p>
<p>##Mettre à jour ADT</p>
<p>Pour faire la migration nous avons besoin d’un outil proposé par la dernière version du plugin ADT et permettant
de générer les fichiers utilisés par gradle pour construire notre projet.
D’où la nécessité de mettre à jour le plugin mais aussi votre sdk pour bénéficier des derniers “tools”.</p>
<p>##gradle.build, settings.gradle</p>
<p>Il est temps maintenant d’exporter notre projet! La procédure est très simple! File -> Export et on a cette fenêtre qui s’affiche:</p>
<p><img src="/assets/capture-du-2013-08-11-151318.png" alt="Eclipse adt" /></p>
<p>Donc on choisit “Generate gradle build files”:</p>
<p><img src="/assets/capture-du-2013-08-11-151541.png" alt="Eclipse adt" /></p>
<p>La il suffit de sélectionner le projet et non les dépendances du projet. Ici KillerApp.
Le reste c’est du suivant suivant… A ce stade, eclipse nous a généré tous les fichiers qu’il faut.
Quelques explications s’imposent.
Nous avons l’apparition de quelques fichiers à la racine de notre projet mais aussi dans les répertoires de chaque module. Oops! je ne vous ai pas dit! Avec AS ou IntellIJ, le workspace de Eclipse devient un projet, le projet de Eclipse devient un module. <a href="http://confluence.jetbrains.com/display/IntelliJIDEA/FAQ+on+Migrating+to+IntelliJ+IDEA">Plus de détails ici</a>. Que représentent ces fichiers?</p>
<p><img src="/assets/capture-du-2013-08-11-152554.png" alt="terminator" /></p>
<ul>
<li>gradle/: ce répertoire est une “installation locale” de l’outil gradle. on a donc pas besoin de l’installer sur notre pc. C’est la pratique qui est conseillé pour etre sure d’avoir tout le temps la bonne version de gradle pour builder nos projets</li>
<li>gradlew, gradlew.bat: c’est le script qui nous permet de lancer les builds sur notre projet en ligne de commande au lieu de passer par Android Studio. Par exemple, pour générer un apk on peut lancer la commande ./gradlew clean assemble</li>
<li>build.gradle et settings.gradle sont les deux fichiers où on passera le plus de temps pour configurer nos projets et leurs dépendances. Ce sont les fichiers de configurations.</li>
</ul>
<p>##Android Studio</p>
<p>On peut maintenant importer notre projet sur AS en choisissant le fichier build.gradle situé à la racine du projet.
Apres quelques temps(lecture des fichiers de conf, résolution des dépendances, etc), nous avons enfin AS qui se lance avec notre projet KillerApp ouvert! Et si on essayait de lancer l’app pour voir un peu?</p>
<p>Bon évidemment ça ne passe pas. Gradle nous signifie qu’il y a des erreurs un peu partout et quand on regarde de plus prêt, nos librairies en sont pour quelque chose…</p>
<p>Commençons par regarder le contenu des fichier build.gradle et settings.gradle de la racine.
settings.gradle:</p>
<figure class="highlight"><pre><code class="language-groovy" data-lang="groovy"><span class="n">include</span> <span class="s1">':pull_to_refresh'</span>
<span class="n">include</span> <span class="s1">':ABS'</span>
<span class="n">include</span> <span class="s1">':KillerApp'</span></code></pre></figure>
<p>Donc on comprends que c’est dans ce fichier qu’on déclare les modules à inclure dans le build.
Le build lui même est configuré dans le fichier du même nom, build.gradle:</p>
<figure class="highlight"><pre><code class="language-groovy" data-lang="groovy"><span class="n">buildscript</span> <span class="o">{</span>
<span class="n">repositories</span> <span class="o">{</span>
<span class="n">mavenCentral</span><span class="o">()</span>
<span class="o">}</span>
<span class="n">dependencies</span> <span class="o">{</span>
<span class="n">classpath</span> <span class="s1">'com.android.tools.build:gradle:0.5.+'</span>
<span class="o">}</span>
<span class="o">}</span></code></pre></figure>
<p>Il est assez simple comme fichier. La raison de cette simplicité est que la tendance est à avoir une convention de base dans la façon de construire un apk. Ce que l’on rajoute dans le fichier de configuration ce sont les informations qui font que le projet est spécifique. À savoir, les dépendances, l’emplacement de certains dossiers sources, etc.
Ici, une dépendance au plugin android pour gradle en version 0.5 au moins.</p>
<p>Autre détail, les fichiers build et settings de nos modules héritent des paramètres de deux de la racine. Donc on aura pas besoin de déclarer à nouveau une dépendance vers gradle 0.5. On comprend que c’est le lieux pour toutes configurations applicables à l’ensemble du projet. C’est le cas des paramétres comme le minSdk, le buildToolsVersion, etc. Ces informations sont souvent source de “fail” lors d’un build.</p>
<p>On a donc:</p>
<figure class="highlight"><pre><code class="language-groovy" data-lang="groovy"><span class="n">buildscript</span> <span class="o">{</span>
<span class="n">repositories</span> <span class="o">{</span>
<span class="n">mavenCentral</span><span class="o">()</span>
<span class="o">}</span>
<span class="n">dependencies</span> <span class="o">{</span>
<span class="n">classpath</span> <span class="s1">'com.android.tools.build:gradle:0.5.+'</span>
<span class="o">}</span>
<span class="n">ext</span><span class="o">.</span><span class="na">compileSdkVersion</span><span class="o">=</span><span class="mi">18</span>
<span class="n">ext</span><span class="o">.</span><span class="na">buildToolsVersion</span><span class="o">=</span><span class="s2">"18.0.0"</span>
<span class="n">ext</span><span class="o">.</span><span class="na">minSdkVersion</span><span class="o">=</span><span class="mi">8</span>
<span class="n">ext</span><span class="o">.</span><span class="na">targetSdkVersion</span><span class="o">=</span><span class="mi">18</span>
<span class="o">}</span></code></pre></figure>
<p>Passons aux dépendances du module ActionBarSherlock. Il a besoin de la librairie android support-v4. Il y a deux façons de procéder:</p>
<ul>
<li>soit on met le fichier jar dans le dossier libs et on rajoute ceci dans son build.gradle:</li>
</ul>
<figure class="highlight"><pre><code class="language-groovy" data-lang="groovy"> <span class="n">dependencies</span> <span class="o">{</span>
<span class="n">compile</span> <span class="nf">fileTree</span><span class="o">(</span><span class="nl">dir:</span> <span class="s1">'libs'</span><span class="o">,</span> <span class="nl">include:</span> <span class="s1">'*.jar'</span><span class="o">)</span>
<span class="o">}</span>
</code></pre></figure>
<ul>
<li>soit on utilise la pleine puissance de maven pour qu’il nous gére nos dépendances sans qu’on n’ait à se préoccuper des fichiers jars. Dans ce cas il suffira de rajouter ces quelques lignes:</li>
</ul>
<figure class="highlight"><pre><code class="language-groovy" data-lang="groovy"> <span class="n">repositories</span> <span class="o">{</span>
<span class="n">mavenLocal</span><span class="o">()</span>
<span class="o">}</span>
<span class="n">dependencies</span> <span class="o">{</span>
<span class="n">compile</span> <span class="s1">'com.android.support:support-v4:18.0.0'</span>
<span class="o">}</span>
</code></pre></figure>
<p>Ainsi, on peut se débarrasser du dossier libs. gradle se chargera d’aller chercher le bon fichier jar et de l’inclure au classpath de notre projet.</p>
<p>Pour en savoir un peu plus sur maven, je vous recommande de lire cette série d’articles.
Il ne faudra pas oublier de remplacer ceci:</p>
<figure class="highlight"><pre><code class="language-groovy" data-lang="groovy"><span class="n">compileSdkVersion</span> <span class="mi">14</span>
<span class="n">buildToolsVersion</span> <span class="s2">"18.0.1"</span></code></pre></figure>
<p>par:</p>
<figure class="highlight"><pre><code class="language-groovy" data-lang="groovy"><span class="n">compileSdkVersion</span> <span class="n">rootProject</span><span class="o">.</span><span class="na">compileSdkVersion</span>
<span class="n">buildToolsVersion</span> <span class="n">rootProject</span><span class="o">.</span><span class="na">buildToolsVersion</span></code></pre></figure>
<p>dans tous les modules du projet.
Pour rappel, on avait dit que certains paramètres devront être les mêmes pour tous les modules du projet par souci de cohérence.</p>
<p>Petite info que j’ai sauté, pour faire la diferrence entre une librairie et un module, il suffit d’appliquer le plugin qu’il faut. Donc pour ActionBarSherlock on aura
<code class="highlighter-rouge">apply plugin: ‘android-library’</code> et pour le module KillerApp <code class="highlighter-rouge">apply plugin: ‘android’</code> dans le fichier build.gradle. “android-library” génére un aar(Android Archive) alors que “android” génére un APK.</p>
<p>Le module PullToRefresh n’a besoin d’aucune dépendance spécifique donc on peut s’attaquer au module KillerApp. Voici ce qu’on rajoutera</p>
<figure class="highlight"><pre><code class="language-groovy" data-lang="groovy"><span class="n">repositories</span> <span class="o">{</span>
<span class="n">mavenLocal</span><span class="o">()</span>
<span class="o">}</span>
<span class="n">dependencies</span> <span class="o">{</span>
<span class="n">compile</span> <span class="s1">'com.android.support:support-v4:18.0.0'</span>
<span class="n">compile</span> <span class="nf">files</span><span class="o">(</span><span class="nl">dir:</span> <span class="s1">'libs'</span><span class="o">,</span> <span class="nl">include:</span> <span class="s1">'*.jar'</span><span class="o">)</span>
<span class="n">compile</span> <span class="nf">project</span><span class="o">(</span><span class="s1">':ABS'</span><span class="o">)</span>
<span class="n">compile</span> <span class="nf">project</span><span class="o">(</span><span class="s1">':pull_to_refresh'</span><span class="o">)</span>
<span class="o">}</span></code></pre></figure>
<p>On lui spécifie qu’il aura besoin du support-v4 et des librairies ABS et pull_to_refresh présentes à la racine.
On y est! Tout a été configuré, maintenant il suffit de faire un build pour voir que tout compile comme il faut!</p>
<p><img src="/assets/capture-du-2013-08-11-204553.png" alt="AS" /></p>
<p>Nous venons de voir qu’il n’est pas très compliqué de passer de Éclipse à Android Studio. Il suffit juste d’avoir des connaissances sur gradle, maven et de se familiariser un peu avec l’IDE.</p>
<p>Vu que l’article n’avait pas pour objectif de vous donner ces bases, je vous recommande fortement d’aller lire en entier cette <a href="http://blog.stylingandroid.com/archives/1872">série d’articles</a> sur gradle(7 en tout) et aussi de lire la <a href="http://tools.android.com/tech-docs/new-build-system/user-guide">documentation</a> fournie par google(pour une utilisation avancée).
Avec cela vous pourrez avoir un usage professionnel de ces outils assez puissants :D.</p>
Les librairies Android:ne pas réinventer la roue.2013-06-09T00:00:00+00:00http://soulesidibe.github.io/2013/06/09/Les-librairies-Android-ne-pas-réinventer-la-roue<p>Quand on développe pour une plateforme donnée, si on est novice ou pas assez informé,
on a tendance à perdre du temps à implémenter des fonctionnalités qui, avec un peu de recherche
sur la toile, nous aurait permis d’aller plus vite dans notre développement tout en ayant
du code propre et maintenable.
Le développement avec Android ne déroge pas à la règle. On trouvera une quantité inestimable
de ressources sur des sites, forums et blogs qui nous facilite ou disons nous permette d’aller
plus vite dans notre dév ou d’être plus focused sur le coeur même de l’application.</p>
<p>Comme on peut le comprendre en lisant le titre de l’article, il s’agira ici d’essayer d’énumérer des
librairies android qui nous font gagner en temps et en qualité pour notre application! Des librairies
qui améliorent l’expériences utilisateurs tout en suivant les bonnes pratiques de la team Android de Google.</p>
<p>##Pull To Refresh</p>
<p>Dans une application Android, il est presque impossible de ne pas trouver de liste d’éléments
(contacts, tweets, sms ou autres informations). Et en général les éléments de cette liste ne sont
pas statiques. D’où la nécessite de proposer un mécanisme de mise à jour des données assez simple et
intuitif: le PullToRefresh!</p>
<p><img src="/assets/header_graphic.png" alt="PullToRefresh" /></p>
<p>on le voit sur l’image, d’un simple tiret vers le bas de la liste puis d’un relachement, on a la possibilité
de mettre à jour les données! On peut imaginer appeler un service sur un autre thread pour récupérer les mises
à jours. Une belle librairie open source qui permet de mettre en place un système de rafraîchissement que l’on
retrouve dans presque toutes les apps connues.</p>
<p>##Action Bar Sherlock</p>
<p><img src="/assets/actionbar.png" alt="ActionBarSherlock" /></p>
<p>La prise en compte des tablettes à partir des version 3.0 d’Android est venu avec son lot de nouveautés dont
la action bar qui a rendu obseléte le bouton menu de nos anciens smartphones.
Le problème qui se pose c’est que pour utiliser cette bar d’action dans nos apps on est obligé d’avoir
comme minSdk l’api 11 dans notre manifest android! Ce qu’on ne peut pas faire pour cause une bonne partie
des devices sur android est en dessous de l’api 11!
La solution à cela est d’utiliser la librairie ActionBarSherlock qui va nous permettre d’avoir notre bar d’action
quelle que soit la version d’android (au minimum api 7). Et ainsi offrir la même expérience utilisateur sans tenir
compte de la version d’android de l’utilisateur.</p>
<p>##Holo Everywhere</p>
<p>En suivant l’actualité autour de la sortie de la version 4 d’android, on n’a pas pu échapé au mot “Holo”.
C’est quoi Holo?
C’est tout simplement le nom donnée au thème qui est apparu avec ICS et surtout il a permis de rendre Android
beaucoup plus beau si on le compare un peu à IOS. Bon revenons au développeur qui veux faire une app qui le
rendra riche! Bah le truc qui coince ici c’est la même application n’a pas le même rendu quand on la lance
sur du Android 2.3.x ou sur du 4.2.x. Les composants ne sont pas les mêmes, la police de caractères change
et bien d’autres aspects visuels changent.
Vous l’avez compris, la librairie android Holo Everywhere, comme son nom l’indique va nous permettre d’avoir
le thème holo partout; les devices avec ICS inclus!</p>
<p>##Sliding Menu</p>
<p><img src="/assets/4png.png" alt="SlidingMenu" /></p>
<p>Si vous avez un android phone(normalement oui en tant que développeur android), vous avez du remarqué une
nouvelle tendance dans les interfaces. En effet, certaines fonctions de l’application ne sont plus présentent
sur la bar d’actions(qui sert le plus souvent pour partager du contenu sur les réseaux sociaux ou de menu
contextuel quand on fait un long press sur un élément d’une liste par exemple) mais sur un autre menu caché à
droite(et/ou à gauche) de l’écran et qui est rendu visible en faisant un “slid” des bordures de l’écran vers
l’écran lui même. ICI une app de démo. On retrouve cette façon de faire dans la plus part des apps stars du
playstore comme Google+, Evernote, The Verge, etc.
Une très belle libraire qui permet d’avoir accès à certaines fonctionnalités de nos apps de façon très simple.</p>
<p>##Et beaucoup d’autres!</p>
<p>La liste de librairies présentées est loin d’être exhaustive! Il y en a beaucoup d’autres à découvrir,
tester et pourquoi pas utiliser dans nos apps. Un petit tour vers ce site, TheUltimateAndroidLibrary,
nous permet de voir qu’il y a des dév qui ont déjà réglé certains soucis donc il ne faut pas se gêner!<br />
C’est le monde merveilleux d’android. Plein de librairies open source qui ne demandent qu’à être utilisées,
forkées et améliorées.</p>
<p>##Bonus</p>
<p>Pour pouvoir utiliser ces librairies il faut les télécharger et les inclure à nos projets(sauf si on utilise
le plugin maven). Chose pas tout le temps facile avec nos soucis de connexion internet en Afrique, ou Eclipse
(avec ca dernière version) qui bug. Au bout d’un moment, on risque d’abandonner.
J’ai la solution qui vous permettra d’avoir la config prête en un clin d’oeil :D
Android Kick Start est un site qui nous permet de générer un nouveau projet android et de sélectionner en même
temps des librairies qui seront incluses et configurées comme il le faut. Il suffira tout simple de télécharger
le projet et de l’importer dans votre ide! Simple non ;-).
N’ayez pas peur si on vous propose des noms de librairies que vous ne connaissez pas encore.
J’en parlerai prochainement…</p>
Les librairies Android:ne pas réinventer la roue.2013-06-09T00:00:00+00:00http://soulesidibe.github.io/2013/06/09/Les-librairies-Android-ne-pas-réinventer-la-roue<p>Quand on développe pour une plateforme donnée, si on est novice ou pas assez informé,
on a tendance à perdre du temps à implémenter des fonctionnalités qui, avec un peu de recherche
sur la toile, nous aurait permis d’aller plus vite dans notre développement tout en ayant
du code propre et maintenable.
Le développement avec Android ne déroge pas à la règle. On trouvera une quantité inestimable
de ressources sur des sites, forums et blogs qui nous facilite ou disons nous permette d’aller
plus vite dans notre dév ou d’être plus focused sur le coeur même de l’application.</p>
<p>Comme on peut le comprendre en lisant le titre de l’article, il s’agira ici d’essayer d’énumérer des
librairies android qui nous font gagner en temps et en qualité pour notre application! Des librairies
qui améliorent l’expériences utilisateurs tout en suivant les bonnes pratiques de la team Android de Google.</p>
<p>##Pull To Refresh</p>
<p>Dans une application Android, il est presque impossible de ne pas trouver de liste d’éléments
(contacts, tweets, sms ou autres informations). Et en général les éléments de cette liste ne sont
pas statiques. D’où la nécessite de proposer un mécanisme de mise à jour des données assez simple et
intuitif: le PullToRefresh!</p>
<p><img src="/assets/header_graphic.png" alt="PullToRefresh" /></p>
<p>on le voit sur l’image, d’un simple tiret vers le bas de la liste puis d’un relachement, on a la possibilité
de mettre à jour les données! On peut imaginer appeler un service sur un autre thread pour récupérer les mises
à jours. Une belle librairie open source qui permet de mettre en place un système de rafraîchissement que l’on
retrouve dans presque toutes les apps connues.</p>
<p>##Action Bar Sherlock</p>
<p><img src="/assets/actionbar.png" alt="ActionBarSherlock" /></p>
<p>La prise en compte des tablettes à partir des version 3.0 d’Android est venu avec son lot de nouveautés dont
la action bar qui a rendu obseléte le bouton menu de nos anciens smartphones.
Le problème qui se pose c’est que pour utiliser cette bar d’action dans nos apps on est obligé d’avoir
comme minSdk l’api 11 dans notre manifest android! Ce qu’on ne peut pas faire pour cause une bonne partie
des devices sur android est en dessous de l’api 11!
La solution à cela est d’utiliser la librairie ActionBarSherlock qui va nous permettre d’avoir notre bar d’action
quelle que soit la version d’android (au minimum api 7). Et ainsi offrir la même expérience utilisateur sans tenir
compte de la version d’android de l’utilisateur.</p>
<p>##Holo Everywhere</p>
<p>En suivant l’actualité autour de la sortie de la version 4 d’android, on n’a pas pu échapé au mot “Holo”.
C’est quoi Holo?
C’est tout simplement le nom donnée au thème qui est apparu avec ICS et surtout il a permis de rendre Android
beaucoup plus beau si on le compare un peu à IOS. Bon revenons au développeur qui veux faire une app qui le
rendra riche! Bah le truc qui coince ici c’est la même application n’a pas le même rendu quand on la lance
sur du Android 2.3.x ou sur du 4.2.x. Les composants ne sont pas les mêmes, la police de caractères change
et bien d’autres aspects visuels changent.
Vous l’avez compris, la librairie android Holo Everywhere, comme son nom l’indique va nous permettre d’avoir
le thème holo partout; les devices avec ICS inclus!</p>
<p>##Sliding Menu</p>
<p><img src="/assets/4png.png" alt="SlidingMenu" /></p>
<p>Si vous avez un android phone(normalement oui en tant que développeur android), vous avez du remarqué une
nouvelle tendance dans les interfaces. En effet, certaines fonctions de l’application ne sont plus présentent
sur la bar d’actions(qui sert le plus souvent pour partager du contenu sur les réseaux sociaux ou de menu
contextuel quand on fait un long press sur un élément d’une liste par exemple) mais sur un autre menu caché à
droite(et/ou à gauche) de l’écran et qui est rendu visible en faisant un “slid” des bordures de l’écran vers
l’écran lui même. ICI une app de démo. On retrouve cette façon de faire dans la plus part des apps stars du
playstore comme Google+, Evernote, The Verge, etc.
Une très belle libraire qui permet d’avoir accès à certaines fonctionnalités de nos apps de façon très simple.</p>
<p>##Et beaucoup d’autres!</p>
<p>La liste de librairies présentées est loin d’être exhaustive! Il y en a beaucoup d’autres à découvrir,
tester et pourquoi pas utiliser dans nos apps. Un petit tour vers ce site, TheUltimateAndroidLibrary,
nous permet de voir qu’il y a des dév qui ont déjà réglé certains soucis donc il ne faut pas se gêner!<br />
C’est le monde merveilleux d’android. Plein de librairies open source qui ne demandent qu’à être utilisées,
forkées et améliorées.</p>
<p>##Bonus</p>
<p>Pour pouvoir utiliser ces librairies il faut les télécharger et les inclure à nos projets(sauf si on utilise
le plugin maven). Chose pas tout le temps facile avec nos soucis de connexion internet en Afrique, ou Eclipse
(avec ca dernière version) qui bug. Au bout d’un moment, on risque d’abandonner.
J’ai la solution qui vous permettra d’avoir la config prête en un clin d’oeil :D
Android Kick Start est un site qui nous permet de générer un nouveau projet android et de sélectionner en même
temps des librairies qui seront incluses et configurées comme il le faut. Il suffira tout simple de télécharger
le projet et de l’importer dans votre ide! Simple non ;-).
N’ayez pas peur si on vous propose des noms de librairies que vous ne connaissez pas encore.
J’en parlerai prochainement…</p>
Git:La suite2012-12-16T00:00:00+00:00http://soulesidibe.github.io/2012/12/16/Git-La-suite<p>Dans un précédent article je vous parlais de git et d’une certaine façon de bien démarrer avec cette outil très puissant
et surtout incontournable en ce moment.Maintenant qu’on arrive à travailler avec git on peut essayer de voir un peu plus
ce qu’offre la bête.</p>
<p>##Merge, push, pull</p>
<p>Imaginons que vous avez créez une nouvelle branche “newFeature” histoire de tester une nouvelle fonction que vous
trouvez pertinente.
Vous codez, vous commitez. Tout marche! vous venez de mettre en place une fonctionnalité qui va vous valoir
une prime! Bah il ne reste plus qu’à faire un push!
Oops non mais attend je suis sur une autre branche; ai-je le droit de faire qu’en même le push?
Heuu oui et non.</p>
<ul>
<li>Non du fait que, au niveau du dépôt distant, il n’y a pas de banche “<em>newFeature</em>”. Donc si on fait un <code class="highlighter-rouge">git push origin master</code>
on aura comme message “Everything up-to-date”. Ce qui est normal si on comprend un peu comment marche les branches.
On demande à git de mettre à jour le dépôt distant identifié par “origin” avec nos modifications locales de la
branche master(<code class="highlighter-rouge">git push origin master</code>). Alors que nos modifications ont été faites sur la branche “newFeature”.
Pour y remédier: il faut informer la branche master qu’il s’est passé des trucs et qu’elle doit se mettre au parfum: on merge!
C’est très simple à faire:</li>
</ul>
<figure class="highlight"><pre><code class="language-bash" data-lang="bash">git co master
git merge newFeature</code></pre></figure>
<p>D’abord on se positionne sur la branche master (co= checkout, je ferai un article sur les raccourcis git et comment en rajouter)
puis on fait un merge en donnant en paramètre le nom de la branche que l’on doit merger (l’auto-complétion marche pour les branches).
Si on est seul à travailler sur ce dépôt local tout devrait bien se passer. Mais si ce n’est pas le cas et que un autre
développeur a modifié un des fichiers sur lesquels vous avez apporté des modifications, il peut y avoir des conflits!
Pour rappel, git ne gère pas les fichiers mais le contenu des fichiers. Donc en cas de conflit, git vous guidera à régler le conflit.</p>
<ul>
<li>Oui Dans le cas où newFeature est une branche de suivi.Une branche de suivi est une branche locale liée à une branche
située au niveau du serveur.</li>
</ul>
<p>Pour récupérer une branche distante:</p>
<figure class="highlight"><pre><code class="language-bash" data-lang="bash">git co <span class="nt">--track</span> origin/newFeature</code></pre></figure>
<p>La on aura une nouvelle branche newFeature et on sera en même temps connecter deçu.
Avant de pousser sur la branche distante il faut toujours récupérer les derniers changements au cas où il y en a;
puis faire son push:</p>
<figure class="highlight"><pre><code class="language-bash" data-lang="bash">git pull
git push</code></pre></figure>
<p>Lors du pull, il est possible que git vous sort votre éditeur par défaut(vim, gedit, ou autre). C’est dans le cas où la branche
de suivi et la branche distante diverge(en plus simple, ne sont plus identiques). Donc git fait un merge des deux.
Il est malin ce git!</p>
<p>Mais au fait comment on crée une nouvelle branche sur le dépôt distant?
Il suffit de pousser la branche!</p>
<figure class="highlight"><pre><code class="language-bash" data-lang="bash">git branch nouvelleBranche
git push origin nouvelleBranche</code></pre></figure>
<p>De même si on veut en supprimer une:</p>
<figure class="highlight"><pre><code class="language-bash" data-lang="bash">git push origin :nouvelleBranche</code></pre></figure>
<p>Le “:” suffit pour supprimer la branche distante! Mais elle sera toujours présente en local.</p>
<p>##Git Stash</p>
<p>Il arrive qu’on soit entrain de coder un truc dans une branche et que à un moment on ait besoin de changer de branche
pour corriger un bug ou un truc du genre. Vu que git n’aime pas quand on essaye de faire un checkout alors que la branche
actuelle a subit des modifications et que on ne veux pas commiter du code non fini, la solution ici est de dire à git de
garder les modifications dans un coin et qu’on reviendra continuer notre travail plus tard: <code class="highlighter-rouge">git stash</code>.</p>
<p>Si on fait un <code class="highlighter-rouge">git status</code>, on remarque que le répertoire de travail est propre! les modifications ont été mises à l’écart.
Et si à un moment on souhaite revenir sur notre sauvegarde: <code class="highlighter-rouge">git stash apply</code> ou <code class="highlighter-rouge">git stash pop</code>.</p>
<p>Et la on se rend compte que tout est revenu comme on l’avait laissé! C’est génial.
La différence entre git stash pop et git stash apply est que avec pop, le stash est appliqué et supprimé mais
avec apply il est juste appliqué; donc on peut toujours le retrouver et l’appliquer à nouveau.
Au passage pour supprimer un stash, <code class="highlighter-rouge">git stash drop [nomStash]</code>.
Pour éviter de faire un <code class="highlighter-rouge">git add</code> apres un git stash apply, rajoutez <code class="highlighter-rouge">–index</code> à la fin: <code class="highlighter-rouge">git stash apply --index</code>.</p>
<p>Il est possible qu’on est mis, de la même manière, en quarantaine d’autres modifications.
Pour voir la liste des stashs, il suffit de faire <code class="highlighter-rouge">git stash list</code>. Et git nous affiche des lignes de ce genre:
<code class="highlighter-rouge">stash@{0}: WIP on master: 25af4b3 autre commit</code></p>
<p>Et là, on a le nom du stash (<em>stash@{0}</em>), le nom de la branche(ici <em>master</em>) et des informations sur le commit qui
précède ce stash (<em>25af4b3</em> autre commit).
Avec le nom du stash, on peut appliquer un stash spécifique en faisant <code class="highlighter-rouge">git stash apply [nomStash]</code>.
Si on ne met pas de nom, le dernier stash sera utilisé.
Et un petit dernier, Si un stash devient important et que vous sentez que c’est plus qu’une petite modification,
vous pouvez la transformer en une branche!
<code class="highlighter-rouge">git stash branch nomBranche nomStash</code>
Et git vous connecte automatiquement à cette nouvelle branche!
Git stash est une commande très puissante avec laquelle on peut faire énormément de choses.
Je vous conseille d’aller lire le man (man git-stash ou git help stash) pour voir les autres possibilités.
D’ailleurs, je vous conseille d’aller consulter le man pour toutes les autres fonctionnalités de git. On y rencontre
des astuces qu’on ne voit pas souvent dans les tutos.</p>
<p>Vous le savez git est vraiment puissant. Il permet de ne plus perdre des heures à chercher des fichiers ou des dossiers.
Et ainsi se concentrer sur l’essentiel!
Mais git peut aussi être fun. J’entends par là, personnaliser les commandes, la coloration de git et bien d’autres
qui feront l’objet d’un article! :D</p>
Android:Consommer un web service2012-12-08T00:00:00+00:00http://soulesidibe.github.io/2012/12/08/Android-Consommer-un-web-service<p>Je vais vous parler de comment se fait la consommation de web services dans une application android.
Pourquoi android? Deux raisons me pousse à parler des services sous cette plateforme mobile:</p>
<ul>
<li>La presque totalité des jeunes étudiants fraîchement sortis de nos écoles d’informatique a eu à suivre un
programme sur le développement avec le langage java (le langage de choix des profs pour appliquer les
concepts de l’orienté objet). Et c’est se même langage qui est utilisé pour le développement sous android.</li>
<li>Parmi les plateformes mobiles à la mode, android offre une accessibilité “bon marché”: 12.OOOFCFA ($25)
pour avoir un compte développeur à vie, et les outils de développement sont accessible sur tous les systèmes
d’exploitation et gratuitement.</li>
</ul>
<p>Avant de rentrer dans le vif du sujet, il est bon se mettre dans un contexte où utiliser des web
services devient essentiel! Imaginons que vous avez développer une application (desktop, web ou autre)
qui a fait le buzz! Et tout vas pour le mieux :-). Mais à un moment donné, vous vous rendez compte que votre
application devrait pouvoir être utilisé pas que quand on est devant un PC. Et là vous commencez à penser à
une application mobile sur les différentes plateforme star à savoir Android, IOS et Windows phone.</p>
<p>Un autre problème se pose. Comment allez vous faire pour mettre toute la logique de votre killer app dans
un smartphone! déjà qu’il faudra une version par système d’exploitation, si on doit porter toute la logique
sur chaque langage de programmation(java, objective-C, C#), bonjour la galère!</p>
<p>Vous l’avez devenez! La solution c’est de garder la logique métier côté serveur et que chaque client
(mobile, web, desktop) fasse des appels quand il a besoin d’une ressource spécifique. Les web services REST
sont une très bonne alternative pour mettre en place ce genre de technique. Pas besoin d’une implémentation
par langage; tous les clients utiliseront le protocole http pour communiquer avec les serveurs. Ce qui simplifie
grandement les échanges entres les différentes entités.</p>
<p>(La gestion des exceptions et certaines initialisations de variable ont été volontairement omises.)</p>
<p>##Faire un appel</p>
<p>Pour faire un appel vu que REST est orienté web, on va utiliser les classes du package java.net. On crée un objet
de type URL qui va contenir l’adresse de la ressource ou tout simplement le lien du service:</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">URL</span> <span class="n">url</span> <span class="o">=</span> <span class="k">new</span> <span class="n">URL</span><span class="o">(</span><span class="s">"http://chemin/vers/service"</span><span class="o">);</span></code></pre></figure>
<p>On ouvre une connexion</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">URLConnection</span> <span class="n">connection</span> <span class="o">=</span> <span class="n">url</span><span class="o">.</span><span class="na">openConnection</span><span class="o">();</span>
<span class="n">HttpURLConnection</span> <span class="n">httpConnection</span> <span class="o">=</span> <span class="o">(</span><span class="n">HttpURLConnection</span><span class="o">)</span> <span class="n">connection</span><span class="o">;</span></code></pre></figure>
<p>Récupération du code de retour. Vu qu’on est en HTTP. Si tout c’est bien passé on doit recevoir le code 200 (ici HttpURLConnection.HTTP_OK) et enfin récupérer notre flux:</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="kt">int</span> <span class="n">responseCode</span> <span class="o">=</span> <span class="n">httpConnection</span><span class="o">.</span><span class="na">getResponseCode</span><span class="o">();</span>
<span class="k">if</span> <span class="o">(</span><span class="n">responseCode</span> <span class="o">==</span> <span class="n">HttpURLConnection</span><span class="o">.</span><span class="na">HTTP_OK</span><span class="o">)</span> <span class="o">{</span>
<span class="n">in</span> <span class="o">=</span> <span class="n">httpConnection</span><span class="o">.</span><span class="na">getInputStream</span><span class="o">();</span>
<span class="o">}</span></code></pre></figure>
<p>A ce stade nous avons un objet de type InputStream qui contient les informations que le serveur a renvoyé.</p>
<p>##Parser du xml avec XMLPullParser</p>
<p>Apres la récupération des données il faut bien les lires.
Pour cela il faudra utiliser un parseur en fonction de la techno utiliser pour envoyer les données côté serveur.
Dans le cas du xml, il existe un parseur natif intégrer à Android: XMLPullParser. C’est un parseur bas niveau;
c’est a dire qu’il faudra parcourir tout le document xml, tag par tag et faire des traitements en fonction du tag
rencontré. Voici un exemple de xml que l’on peut recevoir:</p>
<figure class="highlight"><pre><code class="language-xml" data-lang="xml"><span class="nt"><personnes></span>
<span class="nt"><personne</span> <span class="na">genre=</span><span class="s">"feminin"</span><span class="nt">></span>
<span class="nt"><nom></span>Diallo<span class="nt"></nom></span>
<span class="nt"><prenom></span>Binta<span class="nt"></prenom></span>
<span class="nt"><age></span>15<span class="nt"></age></span>
<span class="nt"></personne></span>
<span class="nt"><personne</span> <span class="na">genre=</span><span class="s">"masculin"</span><span class="nt">></span>
<span class="nt"><nom></span>Ndiaye<span class="nt"></nom></span>
<span class="nt"><prenom></span>Alioune<span class="nt"></prenom></span>
<span class="nt"><age></span>25<span class="nt"></age></span>
<span class="nt"></personne></span>
<span class="nt"></personnes></span></code></pre></figure>
<p>On aura besoin d’un objet String pour contenir la valeur d’un tag à chaque passage., un objet qui va nous
fournir un parseur qui aura les paramètres indiqués( ici le support des espaces de noms, voir doc de <strong>XmlPullParserFactory</strong>),
Et enfin générer notre parseur et lui spécifier l’objet InputStream avec lequel il devra travailler:</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">String</span> <span class="n">valeur</span> <span class="o">=</span> <span class="kc">null</span><span class="o">;</span>
<span class="n">XmlPullParserFactory</span> <span class="n">factory</span> <span class="o">=</span> <span class="n">XmlPullParserFactory</span><span class="o">.</span><span class="na">newInstance</span><span class="o">();</span>
<span class="n">factory</span><span class="o">.</span><span class="na">setNamespaceAware</span><span class="o">(</span><span class="kc">true</span><span class="o">);</span>
<span class="n">XmlPullParser</span> <span class="n">xpp</span> <span class="o">=</span> <span class="n">factory</span><span class="o">.</span><span class="na">newPullParser</span><span class="o">();</span>
<span class="n">xpp</span><span class="o">.</span><span class="na">setInput</span><span class="o">(</span><span class="n">in</span><span class="o">,</span> <span class="kc">null</span><span class="o">);</span></code></pre></figure>
<p>Voici un morceau de code tiré de la doc officiel qu’on peut utiliser pour extraire les informations du InputStream:</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">//Le type d'evenement pour savoir si on est au debut du xml et bien </span>
<span class="c1">//d'autres informations</span>
<span class="kt">int</span> <span class="n">eventType</span> <span class="o">=</span> <span class="n">xpp</span><span class="o">.</span><span class="na">getEventType</span><span class="o">();</span>
<span class="c1">//Tant qu'on n'est pas à la fin du document</span>
<span class="k">while</span> <span class="o">(</span><span class="n">eventType</span> <span class="o">!=</span> <span class="n">XmlPullParser</span><span class="o">.</span><span class="na">END_DOCUMENT</span><span class="o">)</span> <span class="o">{</span>
<span class="c1">//Si on est au debut d'un tag</span>
<span class="k">if</span><span class="o">(</span><span class="n">eventType</span> <span class="o">==</span> <span class="n">XmlPullParser</span><span class="o">.</span><span class="na">START_TAG</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">xpp</span><span class="o">.</span><span class="na">getName</span><span class="o">().</span><span class="na">equals</span><span class="o">(</span><span class="s">"personne"</span><span class="o">))</span> <span class="o">{</span>
<span class="n">genre</span> <span class="o">=</span> <span class="n">xpp</span><span class="o">.</span><span class="na">getAttributeValue</span><span class="o">(</span><span class="kc">null</span><span class="o">,</span> <span class="s">"genre"</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span> <span class="k">else</span> <span class="k">if</span><span class="o">(</span><span class="n">eventType</span> <span class="o">==</span> <span class="n">XmlPullParser</span><span class="o">.</span><span class="na">END_TAG</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">xpp</span><span class="o">.</span><span class="na">getName</span><span class="o">().</span><span class="na">equals</span><span class="o">(</span><span class="s">"nom"</span><span class="o">)){</span>
<span class="n">nom</span> <span class="o">=</span> <span class="n">valeur</span><span class="o">;</span>
<span class="n">valeur</span> <span class="o">=</span> <span class="kc">null</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span> <span class="k">else</span> <span class="k">if</span><span class="o">(</span><span class="n">eventType</span> <span class="o">==</span> <span class="n">XmlPullParser</span><span class="o">.</span><span class="na">TEXT</span><span class="o">)</span> <span class="o">{</span>
<span class="c1">//recuperation de la valeur pour le tag actuel</span>
<span class="n">valeur</span> <span class="o">=</span> <span class="n">xpp</span><span class="o">.</span><span class="na">getText</span><span class="o">();</span>
<span class="o">}</span>
<span class="n">eventType</span> <span class="o">=</span> <span class="n">xpp</span><span class="o">.</span><span class="na">next</span><span class="o">();</span>
<span class="o">}</span></code></pre></figure>
<p>Une petite astuce que vous avez surement remarqué, en début de tag on récupére les attributs du tag, en fin de
tag on récupère la valeur pour ce tag.
Un exemple concret sur ce parseur sur <a href="https://github.com/soulesidibe/xmlPullParserExemple">github</a>.</p>
<p>##Manipuler du json</p>
<p>Pour traiter du json reçu via un web service, Android embarque en natif un package constituer de classe
pour faire le job: <strong>org.json.</strong>* .Elles sont très simples d’utilisation. Voyons ce cas pratique de json:</p>
<figure class="highlight"><pre><code class="language-json" data-lang="json"><span class="p">{</span><span class="w">
</span><span class="s2">"personnes"</span><span class="p">:[</span><span class="w">
</span><span class="p">{</span><span class="w">
</span><span class="s2">"nom"</span><span class="p">:</span><span class="s2">"Fama"</span><span class="p">,</span><span class="w">
</span><span class="s2">"prenom"</span><span class="p">:</span><span class="s2">"Mbaye"</span><span class="p">,</span><span class="w">
</span><span class="s2">"age"</span><span class="p">:</span><span class="s2">"19"</span><span class="p">,</span><span class="w">
</span><span class="s2">"genre"</span><span class="p">:</span><span class="s2">"feminin"</span><span class="w">
</span><span class="p">},</span><span class="w">
</span><span class="p">{</span><span class="w">
</span><span class="s2">"nom"</span><span class="p">:</span><span class="s2">"Jack"</span><span class="p">,</span><span class="w">
</span><span class="s2">"prenom"</span><span class="p">:</span><span class="s2">"Anthoine"</span><span class="p">,</span><span class="w">
</span><span class="s2">"age"</span><span class="p">:</span><span class="s2">"30"</span><span class="p">,</span><span class="w">
</span><span class="s2">"genre"</span><span class="p">:</span><span class="s2">"masculin"</span><span class="w">
</span><span class="p">}</span><span class="w">
</span><span class="p">]</span><span class="w">
</span><span class="p">}</span></code></pre></figure>
<p>Le code pour récupérer les informations ci-dessus:</p>
<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">//Convertir le InputStream de départ en String</span>
<span class="n">BufferedReader</span> <span class="n">bufferedReader</span> <span class="o">=</span> <span class="k">new</span> <span class="n">BufferedReader</span><span class="o">(</span>
<span class="k">new</span> <span class="nf">InputStreamReader</span><span class="o">(</span><span class="n">in</span><span class="o">));</span>
<span class="n">StringBuilder</span> <span class="n">stringBuilder</span> <span class="o">=</span> <span class="k">new</span> <span class="n">StringBuilder</span><span class="o">();</span>
<span class="n">String</span> <span class="n">uneLigneLue</span> <span class="o">=</span> <span class="n">bufferedReader</span><span class="o">.</span><span class="na">readLine</span><span class="o">();</span>
<span class="k">while</span> <span class="o">(</span><span class="n">uneLigneLue</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
<span class="c1">//on ajoute la nouvelle ligne lue dans le StringBuilder</span>
<span class="n">stringBuilder</span><span class="o">.</span><span class="na">append</span><span class="o">(</span><span class="n">UneLigneLue</span> <span class="o">+</span> <span class="s">"\n"</span><span class="o">);</span>
<span class="c1">//lecture de la ligne suivante</span>
<span class="n">ligneLue</span> <span class="o">=</span> <span class="n">bufferedReader</span><span class="o">.</span><span class="na">readLine</span><span class="o">();</span>
<span class="o">}</span>
<span class="n">bufferedReader</span><span class="o">.</span><span class="na">close</span><span class="o">();</span>
<span class="c1">//notre Objet maguique</span>
<span class="n">JSONObject</span> <span class="n">object</span> <span class="o">=</span> <span class="k">new</span> <span class="n">JSONObject</span><span class="o">(</span><span class="n">stringBuilder</span><span class="o">.</span><span class="na">toString</span><span class="o">());</span>
<span class="n">JSONArray</span> <span class="n">array</span> <span class="o">=</span> <span class="n">object</span><span class="o">.</span><span class="na">getJSONArray</span><span class="o">(</span><span class="s">"personnes"</span><span class="o">);</span>
<span class="k">for</span><span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span> <span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">array</span><span class="o">.</span><span class="na">length</span><span class="o">()</span> <span class="o">;</span> <span class="n">i</span><span class="o">++){</span>
<span class="n">nom</span> <span class="o">=</span> <span class="n">array</span><span class="o">.</span><span class="na">getJSONObject</span><span class="o">(</span><span class="n">i</span><span class="o">).</span><span class="na">getString</span><span class="o">(</span><span class="s">"nom"</span><span class="o">);</span>
<span class="o">}</span></code></pre></figure>
<p>Un cas concret de manipulation du json sur <a href="https://github.com/soulesidibe/JsonParserExemple">github</a>.</p>
<p>Cette facon de faire est pratique pour des fichiers aussi simple que celui utilisé mais il est mieux dans
certains cas d’opter pour des librairies qui ajoutent un niveau d’abstraction dans un souci de simplifier
la manipulation du json. C’est le cas de la librairie <strong>GSON</strong> qui permet de faire le passage du JSON en <strong>POJO</strong>
et vice versa. Il y a aussi la librairie <strong>JACKSON</strong> tout aussi puissante.
Il faut juste choisir celle qui nous rend efficace.</p>
<p>##Oui mais pourquoi faire?</p>
<p>Apres avoir reçu les données du serveur, après avoir convertir le xml/json en objet java, en tant que
dévelopeur java, il n’y a pas vraiment de limite!
Dans le contexte d’un développement android, il y a plusieurs manières d’utiliser ces données:</p>
<ul>
<li>Mettre à jour une liste: exemple une vue qui affiche la timeline d’un compte twitter a besoin de récupérer
les informations des serveurs de twitter pour les exposer à l’utilisateur via une ListView ou une ListActivity;</li>
<li>Renseigner une base de données (sqlite) pour une utilisation de l’application en offline</li>
</ul>
<p>Les possibilités n’ont pas de limite. Ça dépendra de ce que l’application fait et de comment
le développeur veut le faire.</p>
Prise en main rapide de git2012-12-04T00:00:00+00:00http://soulesidibe.github.io/2012/12/04/Prise-en-main-rapide-git<p>Lorsqu’on développe une application, en entreprise comme en solo, il est conseillé ou même essentiel
d’avoir de bonnes pratiques. L’une d’elle est l’utilisation d’un gestionnaire de version pour avoir
une certaine traçabilité de nos changements. Donc ici, on parla plus particulièrement de git qui est très célèbre
dans le monde le l’open source avec des implémentations en ligne comme <strong>github</strong>, <strong>bitbucket</strong>.</p>
<p>##C’est quoi un gestionnaire de version</p>
<p>Ce n’est pas bien compliquer; c’est juste un logiciel qui va te permettre d’avoir l’historique de toutes
les modifications que tu as eu à apporter dans ton code ou tout simplement à un document. Et surtout de pouvoir
retourner sur une version antérieur d’un document sans grande difficulté.</p>
<p>Très sympa comme concept!
Imagines ton boss te dit: “Demain on doit présenter la version stable du produit à un nouveau client”.
Alors que entre temps, tu étais en pleine modification du code et donc qu’il sera presque impossible de revenir
à cette version stable vu que dés le départ tu n’as pas utiliser un système de versionning ou, comme
certains le font, tu n’as pas créer un dossier <strong>produitStableBackup</strong>!
Donc on voit clairement, que ce système peut nous éviter bien des soucis :-).
Il existe principalement deux modes de gestion de version:</p>
<ul>
<li>Le mode centralisé ou client-serveur: dans ce mode, le code source est sur un serveur.
Tous les développeurs interagissent avec ce serveur soit pour récupérer les dernières mise à jour,
soit pour apporter une nouvelle mise à jour. On comprendra qu’il est impératif d’être connecté au réseau local
ou à internet pour que cette interaction puisse se faire. Exemple:Subversion(svn), cvs pour Concurrent versions system.</li>
<li>Le mode décentralisé: ici on peut dire que tout le monde est client et serveur.
Et on a la possibilité d’interagir avec toute l’équipe sans passer par un point central. Tu peux donc
travailler en n’étant pas connecté et faire des mises à jour en local; puis rendre ces mises à jour disponible
dès qu’elles sont prêtes. Cependant même dans ce mode, il existera un point qui jouera uniquement le rôle de
serveur mais ne sera pas indispensable pour travailler. Exemple: git, mercurial, bazaar.</li>
</ul>
<p>Vous l’avez compris, il s’agira ici de parler de git!</p>
<p>##Get started here</p>
<p>Il faudrait déja installer la bête. Rien de plus simple: <code class="highlighter-rouge">sudo apt-get install git-core</code> ou
<code class="highlighter-rouge">sudo yum install git-core</code> et on peut enfin s’amuser ;-).</p>
<p>Bon avant de s’amuser il faut d’abord se présenter(c’est le minimum non?):</p>
<ul>
<li>Comment tu t’appelles? <code class="highlighter-rouge">git config –global user.name "Souleymane Sidibe"</code></li>
<li>Ton mail pour te joindre stp: <code class="highlighter-rouge">git config –global user.mail "souley@sidi.be"</code></li>
</ul>
<p>Il faut bien qu’on puisse savoir qui a fait tel modification ou comment le joindre.</p>
<p>Maintenant que tout est prêt, il nous manque une chose. Un dépôt git.
S’il existe déjà, il faut le récupérer; on parle de cloner un dépot. Et c’est assez facile à faire:
<code class="highlighter-rouge">git clone http://chemin/vers/depot/killerApp.git [LeNomDuDepotEnLocal]</code></p>
<p>Si on ne met pas le nom, git va créer un dossier “killerApp”.
Petite précision, en plus du protocole http, il est possible d’avoir accès à un dépôt git via le protocole ssh
(étant plus sécurisé), le protocole git ou avec un bête chemin du genre <code class="highlighter-rouge">/home/lead/projects/killerApp.git</code>.<br />
Si le dépôt n’existe pas en l’initialise.</p>
<figure class="highlight"><pre><code class="language-bash" data-lang="bash">
<span class="nb">cd</span> /chemin/vers/code/source
git init <span class="c">#pour initialiser un nouveau dépôt.</span>
git add fichier.java <span class="c">#pour dire à git de suivre le fichier fichier.java</span>
git add <span class="nb">.</span> <span class="c">#si on veut ajouter tous les fichiers du nouveau dépôt (même ceux des sous dossiers).</span></code></pre></figure>
<p>Il y a souvent des fichiers qui ne doivent pas être suivis. c’est le cas des fichiers .class, certains
fichiers de configuration. Pour ne pas que le système nous répéte après chaque <code class="highlighter-rouge">git st</code>(statut)
qu’il y a des fichiers non suivis, il faut juste ajouter un fichier .gitignore et y mettre les noms
des fichiers et dossiers correspondants. Gitignore comprend aussi les caractères spéciaux
comme *.class (tous les fichiers .class).</p>
<p><a href="https://github.com/github/gitignore">Ici</a> un ensemble de prototypes de fichier .gitignore en fonction du langage ou de l’IDE. À personnaliser of course.
Une commande que j’utilise beaucoup et qui permet de voir l’état du dépôt: <code class="highlighter-rouge">git status</code>.
Elle permet d’avoir une vision global et fourni des informations sur la branche actuelle, les fichiers qui on été modifiés,
les fichiers présents dans le dépôt et qui ne sont pas suivis. À propos des fichiers, on peut compter quatre statuts possibles:</p>
<ul>
<li><strong>untracked</strong> = >le fichier n’est pas suivi, faire un git add pour qu’il le soit</li>
<li><strong>unmodified</strong> => le fichier n’est pas modifié; git rm pour retourner à l’état untracked</li>
<li><strong>modified</strong> => le fichier a été modifié; il s’agit d’un fichier unmodified qui a été édité</li>
<li><strong>staged</strong> => le fichier est indexés, donc il fera parti du prochain commit et retournera à l’état unmodified.</li>
</ul>
<p>Un défaut/qualité de git, s’est le grand nombre de commandes et d’options disponibles. Mais on est aidé par
la complétion des commandes et aussi par la commande git help qui explique un peu ce qu’on peut faire et
<code class="highlighter-rouge">git help <option></code> pour avoir un man complet de la commande en question.</p>
<p>Apres avoir implémenter la fonction qui va te rendre riche, il faut la “committer”. En terme technique,
c’est le fait de faire passer les fichiers qui étaient “staged” en unmodified. En plus simple, c’est juste
le fait d’ajouter une entrée dans l’historique des modifications du dépôt. En général, il est accompagné
d’un commentaire pour expliquer ce qui a été ajouter, modifier, supprimer: <code class="highlighter-rouge">git commit -m "commentaires"</code>.
On peut aussi faire en une seule fois un git add et un git commit: <code class="highlighter-rouge">git commit -a -m "coms"</code>.</p>
<p>##L’utilisation des branches</p>
<p>Retournons voir le développeur qui voulait modifier son code tout en ayant une version stable utilisable à tout moment.
Il a le choix entre plusieurs possibilités:</p>
<ul>
<li>Créer un dossier avec des noms bizarres que lui seul peut comprendre (project_old_bon_2012_02_14_back): ici on prend l
e risque de se perdre dans sa forêt de dossiers ou de ne plus savoir lequel a ou n’a pas telle fonctionnalité</li>
<li>Créer un clone du projet avec un git clone /chemin/project.git: ça peut être une alternative sauf que pour un gros
projet, le disque dur peut crier!</li>
<li>Ou créer une branche! git branch new_feature: c’est la meilleur des manières si on veut tester de nouvelles
fonctionnalités tout en gardant une copie propre du projet.</li>
</ul>
<p>Il faut savoir que quand on initialise un projet(<code class="highlighter-rouge">git init</code>) ou qu’on clone un dépôt (<code class="highlighter-rouge">git clone</code>). on est par<br />
défaut sur la branche “master”.
<code class="highlighter-rouge">git branch</code> permet d’avoir la liste des branches locales
<code class="highlighter-rouge">git branch <nom_de_la_nouvelle_branche></code> pour créer une branche; en général je donne le nom de la feature
que je voudrai implémenter ou la correction d’un bug.
<code class="highlighter-rouge">git branche -d <nom_branche></code> supprime la branche.</p>
<p>Et bien d’autres options que tu peux explorer en faisant <code class="highlighter-rouge">git help branch</code>.</p>
<p>Oui mais bon c’est bien de créer des branches de les supprimer et tout mais comment on fait pour passer
d’une branche à l’autre?!
Et bin il suffit de faire git checkout <nom_branch> et on peut se permettre de faire un
`git rm .` (supprimer tout le contenu du dossier)
`git commit -m "tout supprimer!"` sans aucune crainte!
Sur la branch master c’est comme s’il ne s’était rien passé (`git checkout master` pour vérifier).
C’est cela la magie de git. Et il le fait avec une simplicité. On n’aura plus peur d’apporter de grosses
modifications à des projets critiques ;-).</nom_branch></p>
<p>A ce stade, tu dois pouvoir travailler avec git. Tu sais récupérer un dépôt ou en initialiser un, ajouter de
s fichiers, commiter, créer des branches, c’est le minimum à connaitre!
Dans un prochain article, on ira plus en profondeur dans l’utilisation de git.</p>