Développez des applications Android connectées

AndroidStudio est l'application de référence pour le développement Android. Historiquement basé sur l'IDE Eclipse, il est maintenant basé sur l'IDE IntelliJ. Vous pouvez l'installer gratuitement et librement à partir de : https://developer.android.com/studio/index.html

Lors de son installation, l'outil installera également un le SDK Android (les outils de compilation/manipulation pour le développement Android), ainsi que différentes API (les différentes versions des bibliothèques Android). N'hésitez pas à installer les bibliothèques les plus à jour, ainsi que celles de vos périphériques de test.

Lancez AndroidStudio et demandez à créer un nouveau projet. La première question qui vous est posée est de donner un nom et un emplacement à votre projet. Notez que l'on vous demande également le nom de domaine de votre société. À partir de cette information, AndroidStudio générera un nom de package.

Vous devez ensuite choisir le niveau de rétro-compatibilité voulu. La version 15 est probablement un choix pertinent.

Une fois votre application créée, AndroidStudio peut l'initialiser avec une première activité. Pour votre première application le choix empty activity vous permettra d'avoir un code généré très léger. Mais n'hésitez pas à jouer avec les autres possibilités.

Vous avez ensuite le choix du nom du fichier java qui définira l'activité (MainActivity par défaut), ainsi que le nom du fichier XML qui contiendra la description de l'interface graphique (nomméactivity_main par défaut).

Après avoir validé la création de votre activité, l'éditeur de code s'ouvre en montrant l'arborescence du projet, le code Java de l'activité créée et le XML de son gabarit. Voilà, votre première application Android est faite ! Elle est exécutable et affiche le bon vieux message « Hello world ».

Je vous propose maintenant d'exécuter ce code avant de le détailler.

Pour exécuter une application Android, il est nécessaire d'avoir une machine Android. Elle peut être virtuelle ou physique. Le plus convivial et réactif est d'utiliser une machine physique. Elle sera généralement plus fluide, et a l'avantage que l'on peut physiquement se défouler dessus quand elle ne veut pas fonctionner comme on le voudrait.

Configuration d'un périphérique Android physique

Pour exécuter son application sur son téléphone ou sa tablette, il suffit qu'elle soit connectée en USB à la machine et cliquer sur « exécuter ». Mais la première fois, il peut être nécessaire d'autoriser cette action. Il faut  :

1. que le device ait son mode de débogage USB activé ;

2. que la clé d'identification de l'ordinateur soit acceptée sur le device.

Activez le débogage USB

Pour activer le débogage USB, il suffit de l'activer dans les préférences systèmes en allant dans « Options pour les développeurs ».

Mais pour que ce menu existe sur votre device, il est nécessaire d'activer les options de développement. Allez dans « à propos de la tablette » et cliquez 7 fois de suite sur le numéro de build, puis lancez votre téléphone par la fenêtre après avoir vérifié que la rue était dégagée (Ah ? La seconde consigne était moins crédible que la première ? ).

Après avoir fait les 7 clics, vous recevez la notification « Vous avez activé les paramètres de développement ! » qui vous annonce que le menu « Options pour les développeurs » est apparu.

Acceptez la clef d'identification de l'ordinateur

Une fois le débogage USB activé et le téléphone branché, exécutez votre programme. Les cibles d'exécution possibles sont découvertes et listées. Vous devriez voir votre device apparaître.

Lors de la première connexion, vous devrez valider sur son écran la demande de confirmation pour accepter les connexions à cet ordinateur :

Attendez maintenant la fin de la compilation de votre programme, de la génération de l'APK et de son déploiement et… profitez du doux spectacle de votre première application Android embarquée sur votre téléphone, lui-même prêt à repartir dans votre petite poche pour la montrer à tous ! 

Configuration d'une machine virtuelle Android

Si pour diverses raisons, vous préférez exécuter votre programme dans une machine virtuelle Android :  après avoir cliqué sur « exécuter », choisissez l'option « Create New Virtual Device ». Choisissez une machine physique dont vous voulez cloner les caractéristiques et c'est fini !

Bien sûr, vous pouvez modifier les caractéristiques de la machine créée par rapport au modèle choisi. Notamment la taille de la RAM, ou de la carte SD.

Maintenant que nous avons vu que le projet généré était un « Hello world » tout fait, je vous propose de regarder ce qui a été généré et qui constitue une application Android.

Structure générale du projet

La structure générale du projet se trouve sur la gauche de votre IDE.

Parmi ces multiples fichiers et dossiers, les éléments les plus importants sont :

• AndroidManifest.xml : ce fichier contient la description de l'application. L'exemple ci-dessous de Manifest montre qu'une application est notamment définie par le nom d'un package, une icône (c'est plus pratique pour la lancer), une étiquette (qui sera affichée sous l'icône), et une activité définie dans la classe MainActivity. Ensuite, une activité est définie par un filtre d'intention (intent-filter). Ce mécanisme permet d'associer une ou des activités à une action. Dans cet exemple l'action Main/Launcher  est celle qui est déclenchée quand on clique sur l'icône. MainActivity  sera donc l'activité lancée à ce moment-là.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.welcoming_machines.mywelcomemachine">
    <application android:allowBackup="true" 
                 android:icon="@mipmap/ic_launcher"
                 android:label="@string/app_name" 
                 android:supportsRtl="true" 
                 android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" ></action>
                <category android:name="android.intent.category.LAUNCHER" ></category>
            </intent-filter>
        </activity>
    </application>
</manifest>

• Dossier Java : il contient 3 sous dossiers. Seul le premier nous intéresse dans le cadre de ce cours. Il contient l'ensemble des classes Java de l'application, ce qui se limite au fichierMainActivity.java  dans cet exemple. Les 2 autres dossiers sont des outils mis à disposition pour développer une stratégie de tests de l'application.

• Le dossier res  contient l'ensemble des ressources du programme :

  • Toutes les images ou assimilés sont dans le dossier Drawable. Il existe toutefois une exception : les icônes. Celles-ci sont des images que l'on fournira volontiers en plusieurs résolutions afin de permettre une bonne adaptation aux différentes densités d'écran. Elles sont alors placées dans le dossier mimap.

  • Le dossier Layout  contient l'ensemble des éléments structurant les interfaces graphiques de l'application. Dans cet exemple, cela ce réduit à activity_main.xml

  • Le dossier values  contient divers fichiers XML complémentaires permettant de configurer l'application. En particulier, on notera le fichier strings.xml, dont l'usage permet de réaliser « aisément » une application multi-lingue.

Description de la classe Java MainActivity générée

Nous avons vu dans le Manifest que l'action réalisée lors d'un clic sur l'icône de l'application est de lancer une instance de la classe MainActivity. Dans notre exemple, cette classe se réduit aux quelques lignes suivantes :

package com.welcoming_machines.mywelcomemachine;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

Par rapport à un programme Java, on constate qu'il manque des choses dans cette classe héritant deAppCompatActivity : il n'y a ni main, ni constructeur. C'est normal. Le main correspond à la première ligne de code à exécuter au lancement d'un programme. Cela est remplacé ici par l'intention main/launcher  qui pointe vers l'activité MainActivity. Ensuite, le constructeur n'est pas utilisé dans les activités, car elles seront lancées via une intention (un Intent). Nous verrons plus loin qu'une activité a un cycle de vie dont la première méthode appelée est onCreate. Nous considérerons donc que cette méthode joue un peu le rôle du constructeur d'une activité.

La méthode onCreate  attend en paramètre un Bundle. Il est utilisé lorsque l'activité a été interrompue et que sa mémoire a été récupérée. Il contient alors les informations qui étaient précédemment présentes dans les différents éléments de champs de saisie et qui ont été sauvegardées. Il est nécessaire de retransmettre ce paramètre à la méthode onCreate  telle que définie dans la classe parent.

La seconde instruction présente dans la méthode onCreate (ligne 8 de l'exemple) permet de charger un Layout pour construire le visuel de l'activité. Ici c'est activity_main  qui est chargé.

Description du layout activity_main généré

Regardez maintenant le gabarit activity_main  qui a été généré et qui correspond au visuel de notre application. En l'ouvrant on peut choisir entre 2 visions du fichier sur les onglets en bas du cadre : Design ou Text.

Le mode design est très rassurant au début et permet globalement d'avancer très vite dans la réalisation d'un premier brouillon d'interface graphique. Le panneau latéral gauche montre la liste des Widgets standards que l'on peut placer directement dans son interface par glisser-déposer. La partie centrale montre en même temps le visuel attendu du Layout réalisé et sa structure générale (sur fond bleu). Lorsqu'un objet est sélectionné, ses principales caractéristiques sont affichées dans le panneau de droite.

Ce même fichier peut être édité en mode texte. On voit alors que ce XML est constitué de deux objets : un conteneur principal de type  Relative Layout  et un  TextView .

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools" android:id="@+id/activity_main"
    android:layout_width="match_parent" android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.welcoming_machines.mywelcomemachine.MainActivity">
    <TextView android:layout_width="wrap_content" android:layout_height="wrap_content"
        android:text="Hello World!" ></TextView>
</RelativeLayout>

Nous rentrerons plus dans les détails de la constitution d'une interface graphique dans le chapitre suivant.