Le moins qu'on puisse en dire, c'est qu'Android Studio n'est pas du genre léger. Sans doute, cet
IDE est très complet, et il faut être reconnaissant à Google de le mettre gratuitement à disposition des développeurs, mais il requiert beaucoup de ressources pour
fonctionner, et peut en conséquence se révèler très lent à l'usage.
Un canon pour tuer les mouches ? Ce serait bien dans l'air du temps. Comme l'explique avec beaucoup d('im)pertinence Bryan Lundunke dans programmers_are_evil(), "Everyone writing code is writing code that is getting exponentially larger and slower".
Partant, on peut se demander si Android Studio, c'est le bon choix pour commencer à développer des apps pour Android.
La question se pose d'autant plus que l'IDE masque nombre d'opérations dont la connaissance paraît essentielle pour que le développeur puisse comprendre ce qu'il est en train de faire. De manière un peu réductrice, mais qui n'est donc pas si éloignée de la réalité, l'IDE n'est qu'une IHM qui appelle des outils en ligne de commande pour faire tout ce qui dépasse l'édition de code. Se donner la peine de regarder sous le capot, c'est non seulement se ménager l'opportunité de pouvoir se débrouiller en cas de panne, mais aussi celle de gagner beaucoup de temps pour réaliser certains opérations.
Reste à savoir comment procéder, car pour la jouer roots, force est de constater que Google ne simplifie pas la tâche... Explications pour qui souhaiterait se lancer aujourd'hui même dans le développement d'apps pour Android.
Il s'agit ici de développer une app de base qui se contente d'afficher le classique "Hello world!" sur l'écran d'un téléphone. Les grandes étapes sont :
- configurer le téléphone ;
- développer l'app ;
- installer le SDK ;
- produire un APK ;
- installer l'app.
On supposera que vous avez installé correctement le Java Development Kit (JDK) dans une version 8 ou postérieure. Pour rappel, il peut être téléchargé ici.
Précisons que cet article est très largement inspiré de l'excellent article publié ici par Authmane Terki l'année dernière. L'ambition n'est que de compléter son propos en détaillant tout ce qu'il est indispensable de mettre en place pour déployer l'app et analyser les problèmes qui peuvent survenir lors de ce déploiement.
Configurer le téléphone
La première étape est de configurer un téléphone. Ici, nous utiliserons un bon vieux Moto G dont le système est à jour à la date de cet article, c'est-à-dire qu'il s'agit de la version 5.1 d'Android, dite Lollipop.
Celui qui découvre Android apprendra ici qu'il en existe de multiples versions, et que Lollipop n'est pas la plus récente. Toutefois, à l'heure actuelle, ce choix qui ne tenait qu'à la disponibilité d'un téléphone de rechange - ne jamais développer sur son téléphone personnel ! - reste pertinent. En effet, d'après les données fournies ici, une app pour Lollipop peut fonctionner sur 85% des terminaux à base d'Android.
Pour mettre à jour le système, il suffit de se rendre dans les paramètres du Moto G, d'accéder à About phone dans l'app Settings, et de cliquer sur System updates tout en haut - oui, le système utilisé dans cet article est en anglais. En l'espèce, la manoeuvre a été effectuée avec succès après une réinitialisation complète du Moto G qui s'était alors retrouvé dans sa configuration d'usine à base de Kitkat.
Une fois le système mis à jour, les options pour développeur doivent être activées. Pour cela, toujours dans la même page, il faut taper sept fois sur Build version :
En se rendant dans Settings, il est possible de constater l'apparition de Developper options :
Il ne reste plus qu'à autoriser les échanges entre le Moto G et le PC. Tout d'abord, dans Developper options, l'option USB debugging doit être activée :
Ensuite, dans la page Security de Settings, l'option Unknown sources doit l'être aussi - ce qui permet de comprendre pourquoi il est conseillé de ne jamais développer sur son téléphone personnel :
Enfin, le Moto G peut être connecté par USB au PC. A cet instant, il ne permet pas nécessairement l'échange de fichiers comme il se doit. Au moment où il est connecté au PC, une notification apparaît :
Taper sur la notificaiton permet d'accéder à une page USB Computer Connection où l'option Media device (MTP) doit être activée :
Ce n'est pas tout ce qu'il faut faire pour parvenir à dialoguer avec le Moto G depuis le PC à l'aide des outils en ligne de commandes. En effet, il reste encore à installer un pilote. Il en sera question le moment venu.
Développer l'app
L'application qu'il s'agit de développer est triviale, puisqu'elle ne fait qu'afficher le message "Hello world!". Comme expliqué plus tôt, son code est une reprise de celui proposé par Authmane Terki où seul le message et la hiérarchique des packages ont été retouchés - sans que cela soit indispensable d'ailleurs. Cliquez ici pour récupérer le code et vous amuser avec.
Le code est réparti dans plusieurs fichiers qui sont logés dans une arborescence que vous devez créer :
test/ +- AndroidManifest.xml +- bin/ +- obj/ +- res/ +- drawable/ +- layout/ +- activity_main.xml +- value/ +- strings.xml +- src/ +- com/ +- helloworld/ +- MainActivity.java
Le contenu de activity_main.xml est le suivant :
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent" >
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:text="@string/hello_msg"
tools:context=".MainActivity" />
</RelativeLayout>
Le contenu de strings.xml est le suivant :
<resources> <string name="app_name">Hello world!</string> <string name="hello_msg">Hello world!</string> <string name="menu_settings">Settings</string> <string name="title_activity_main">MainActivity</string> </resources>
Le contenu de MainActivity.java est le suivant :
package com.helloworld;
import android.app.Activity;
import android.os.Bundle;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
Le contenu de AndroidManifest.xml est le suivant :
<?xml version='1.0'?>
<manifest xmlns:a='http://schemas.android.com/apk/res/android' package='com.helloworld' a:versionCode='0' a:versionName='0'>
<application a:label='Hello world!'>
<activity a:name='com.helloworld.MainActivity'>
<intent-filter>
<category a:name='android.intent.category.LAUNCHER'/>
<action a:name='android.intent.action.MAIN'/>
</intent-filter>
</activity>
</application>
</manifest>
Le code est donc en Java, mais il est tout à fait possible de développer une app en Kotlin. Passer de Java à Kotlin, ou adopter Kotlin directement si l'on n'a jamais pratiqué Java, c'est d'ailleurs une des recommandations qui seront formulées à la fin de cet article.
Installer le SDK
L'app étant développée, il reste à la compiler, la packager et l'installer sur le Moto G. Toutes ces opérations nécessitent des ressources et des outils que chacun s'attend à trouver dans le Software Development Kit (SDK).
Où trouver ce SDK ? Dans le cas d'Android, c'est toute une affaire. Qui recherche "android sdk" sur Google est renvoyé ici, sur une page du site officiel d'Android pour les développeurs. Sur cette page, il n'est pourtant pas question de SDK, mais d'Android Studio et d'outils en ligne de commandes. Enfin, il est tout de même fait mention au SDK en ceci que parmi les outils, il existerait un SDK manager qui permettrait de l'installer.
Télécharger et installer les outils en lignes de commande proposés conduit à une impasse. Dans le répertoire où l'archive est déballée, on trouve bien un SDK Manager.bat. Toutefois, son exécution depuis une fenêtre de commandes - même en mode Administrateur - permet seulement de constater que l'outil procède à une sorte d'inventaire, sans plus.
L'explication réside ici. Google encourage les développeurs à utiliser Android Studio, et donc les décourage de s'en passer à l'aide des outils en ligne de commandes. Dans cet esprit, l'interface du SDK manager a été désactivée.
Ne pas pouvoir utiliser le SDK manager pose un problème de taille, puisqu'il permet d'installer certains outils et le SDK proprement dit, c'est-à-dire tout ce qui est requis pour compiler en ciblant une plate-forme. Fort heureusement, il existe une solution. Elle consiste à installer une précédente version du SDK qui se trouve ici. Après avoir récupéré le fichier android-sdk_r24.4.1-windows.zip, désarchivez-le dans un répertoire quelconque, par exemple c:\android. Vous trouverez à la racine un fichier SDK Manager.exe. Double-cliquez dessus, et vous accéderez à l'interface du SDK manager :
Dans le cas qui nous intéresse, sélectionnez uniquement les éléments suivants :
- dans Tools, Android SDK Tools, dans sa version la plus récente ;
- dans Tools, Android SDK Platform-tools, dans sa version la plus récente ;
- dans Tools, Android SDK Build-tools, dans sa version la plus récente ;
- dans Android 5.1.1 (API22), SDK Platform.
Les trois premiers éléments sont des outils. Le dernier est le SDK à proprement parler. Pour le dernier, comme il s'agit de développer une app pour Lollipop, c'est un SDK pour Android 5.1.1 qu'il faut choisir. Et comme il ne s'agit que de produire du bytecode pour la machine virtuelle Java (JVM) fonctionnant sur le Moto G, et non du code natif, il suffit de choisir le SDK de la plate-forme.
Cliquez alors sur le bouton Install pour procéder à l'installation. Cette dernière prend peu de temps. Au final, le répertoire c:\android devrait légèrement dépasser les 700 Mo et contenir un peu plus de 10 000 fichiers.
Produire un APK
Pour pouvoir être installée sur le Moto G, l'app doit se présenter sous la forme d'un fichier Android Package Kit (APK). Pour produire un tel fichier, vous devez parcourir un certain nombre d'étapes en vous appuyant sur des outils en ligne de commandes. Ce qui est décrit ici est une pure reprise des explications données par Authmane Terki.
Ouvrez une fenêtre de commandes. Pour commencer, créez une variable qui vous permettra de faire facilement référence au répertoire où se trouve l'aborescence de l'app créée plus tôt :
set PROJET=R:\Documents\Projets\android\test
Générez le fichier R.java :
cd /d C:\android\build-tools\28.0.3 aapt.exe package -f -m -J %PROJET%\src -M %PROJET%\androidManifest.xml -S %PROJET%\res -I C:\android\platforms\android-22\android.jar
Compilez l'app :
cd /d %PROJET% javac.exe -d obj -bootclasspath C:\android\platforms\android-22\android.jar %PROJET%\src\com\helloworld\*.java
Générez le fichier classes.dex :
cd /d C:\android\build-tools\28.0.3 call dx.bat --dex --output=%PROJET%\bin\classes.dex %PROJET%\obj
Créez le fichier APK, et intégrez-y le fichier classes.dex (cette dernière manoeuvre est un peu étrange, et semble tenir à un bogue de l'outil AAPT qui autrement rajoute le fichier dans l'APK au fond de toute une arborescence plutôt qu'à la racine) :
aapt.exe package -f -m -F %PROJET%\bin\hello.unaligned.apk -M %PROJET%\androidManifest.xml -S %PROJET%\res -I c:\android\platforms\android-22\android.jar cd /d %PROJET% copy bin\classes.dex . >NUL C:\android\build-tools\28.0.3\aapt.exe add %PROJET%\bin\hello.unaligned.apk classes.dex del classes.dex
Signez l'APK. Pour cela, vous devez d'abord générer un fichier .keystore à l'aide de l'outil KEYTOOL du JDK... :
cd /d C:\android\build-tools\28.0.3 keytool -genkeypair -validity 365 -keystore helloworld.keystore -keyalg RSA -keysize 2048
...puis utiliser ce fichier pour signer l'APK (pour éviter d'avoir à saisir le mot de passe "motdepasse", il est ici spécifié parmi les paramètres) :
cd /d C:\android\build-tools\28.0.3 call apksigner.bat sign --ks-pass pass:motdepasse --ks helloworld.keystore %PROJET%\bin\hello.unaligned.apk
Alignez l'APK :
zipalign.exe -f 4 %PROJET%\bin\hello.unaligned.apk %PROJET%\bin\hello.apk
Pour simplifier, les commandes qui viennent d'être présentées (exception faite de l'utilisation de KEYTOOL) ont été regroupées dans un BAT make.bat que vous trouverez dans l'archive de l'exemple présenté dans cet article.
Installer l'app
Il existe plusieurs manières de déployer une app mise sous la forme d'un APK :
- ajouter l'APK sur Google Play, d'où il pourra être téléchargé et installé via l'app Google Play sur le Moto G ;
- copier l'APK dans un répertoire du Moto G, d'où il pourra être utilisé via un gestionnaire de fichiers, en l'espèce le Moto File Manager ;
- transférer l'APK et commander son installation via USB à l'aide de l'outil en ligne de commandes Android Debug Bridge (ADB) du SDK.
La première solution est très contraignante. La seconde ne permet pas de voir ce qui se passe en cas de problème. C'est donc la troisième qu'il faut retenir.
Pour communiquer avec le Moto G depuis le PC, il faut installer un pilote particulier. Dans le cas précis, vous trouverez ce pilote ici. En fait, il s'agit de l'application Motorola Device Manager dont l'installation entraîne celle du pilote, et que vous pouvez désinstaller ensuite sans que cela entraîne la désinstallation du pilote.
Une fois le pilote installé, branchez votre Moto G au PC via le câble USB. Windows moulinera un peu avant d'associer le pilote au Moto G. Si vous avez procédé aux réglages détaillés plus tôt sur ce dernier, vous pouvez maintenant entreprendre d'installer l'APK à l'aide de l'outil ADB.
A ce stade, il est indispensable de savoir ce qui va se passer. Si l'installation plante, pourquoi ? Impossible de le savoir sur la seule base du retour d'ADB, car ce n'est jamais qu'un code d'erreur qu'il affiche. La solution est d'utiliser LOGCAT, qui n'est qu'une des nombreuses fonctionnalités d'ADB.
LOGCAT rapportant en temps réel ce qui se passe sur le Moto G, c'est donc dans une autre fenêtre de commandes qu'il faut le lancer :
@echo off cd /d C:\Android\platform-tools cls adb.exe logcat -c adb.exe logcat -v long | findstr com.helloworld
Dans la première fenêtre de commandes, vous pouvez alors utiliser ADB pour procéder à l'installation :
cd /d C:\Android\platform-tools adb.exe install %PROJET%\bin\hello.apk
Si l'installation se déroule bien, vous verrez apparaître l'app dans la liste des apps sur le Moto G, et vous pourrez taper dessus pour afficher le fameux message "Hello world!".
 |
 |
Pour vous simplifier la vie, les commandes qui permettent de transférer l'APK ont été regroupées dans un BAT install.bat, et celles qui permettent de surveiller ce qui se passe, dans un BAT log.bat. Vous les trouverez dans l'archive de l'exemple présenté dans cet article.
Go west, young man!
Disposant désormais d'un environnement de développement qui permet de ne pas perdre de temps, il est possible de se lancer dans un apprentissage qui se révélera des plus utiles pour résoudre des problèmes et dépasser des limitations quand on en viendra à utiliser un IDE. Pour cela, la meilleure solution est de faire une lecture attentive du guide des outils en ligne de commandes qui se trouve ici.
Pour améliorer l'ergonomie de l'environnement, il est possible d'installer un shell plus puissant que celui de Windows. A priori, le choix devrait se porter sur PowerShell. Quant à l'éditeur, il convient de ne pas perdre de temps sur un éditeur générique qu'il serait très difficile de configurer pour qu'il dialogue avec les outils en ligne de commandes. Le moment venu, mieux vaut basculer sur Android Studio ou une alternative comme Intellij IDEA dont il existe une version gratuite - la community edition. Toutefois, avant cette étape, il n'est pas inutile de s'être initié à Gradle pour gérer les projets et Git pour gérer les versions, car ces outils sont très utilisés - Gradle est mentionné, car il est intégré à Android Studio. Aussi, il convient très probablement d'avoir laissé tomber Java pour Kotlin, le petit langage qui monte, notamment grâce au coup de pouce géant que Google qui lui a donné en l'intégrant à Android Studio.
J'espère n'avoir oublié aucune étape. Si vous constatez qu'il en manque, même la plus anodine, n'hésitez surtout pas à me le faire savoir ici.