Programmation

mobile avec
android
Par Cyrille MBIA
Développeur web/mobile
Expert en sécurité des systèmes numériques
JOUR

01
Introduction &
présentation
Jour 1
Environnement de développement

1.1. Introduction
1.1.1. Qu’est-ce qu’Android ?

Android est une surcouche au-dessus d’un système Linux :

 1.1.2. Historique

Né en 2004, racheté par Google en 2005, version 1.5 publiée en 2007

De nombreuses versions depuis. On en est à la version 13.0.0 (5 avril 2022) et
l’API 32. La version 13 est le numéro pour le grand public, et les versions d’API
sont pour les développeurs.
Exemples :
a. 4.1 JellyBean = API 16,
b. 6.x Marshmallow = API 23,
c. 9.x Pie = API 28
Une API (Application Programming Interface) est un ensemble de bibliothèques de
classes pour programmer des applications. Son numéro de version donne un
indice de ses possibilités.
1.1.3. Remarque sur les versions d’API

Chaque API apporte des fonctionnalités supplémentaires. Il y a compatibilité

ascendante. Certaines fonctionnalités deviennent dépréciées au fil du temps,
mais restent généralement disponibles.
On souhaite toujours programmer avec la dernière API (fonctions plus complètes
et modernes), mais les utilisateurs ont souvent des smartphones plus anciens, qui
n’ont pas cette API.
Or Android ne propose aucune mise à jour majeure. Les smartphones restent
toute leur vie avec l’API qu’ils ont à la naissance.
Les développeurs doivent donc choisir une API qui correspond à la majorité des
smartphones existant sur le marché.
 1.1.4. Distribution des versions
Voici la proportion des API en janvier 2021 :
 1.1.5. Remarques diverses

Évolution et obsolescence voulues et très rapides

Suivre les modes et envies du marché, réaliser des profits
Ce que vous allez apprendre sera rapidement dépassé (1 an)
a. Syntaxiquement (méthodes, paramètres, classes, ressources...)
b. Mais pas les grands concepts (principes, organisation...) qu’on retrouve
aussi sur iOS
Vous êtes condamné(e) à une autoformation permanente, mais c’est le lot des
informaticiens.
1.1.6. Programmation d’applications

Actuellement, les applications sont :

 «natives», c’est à dire programmées en Java, C++, Kotlin, compilées et
fournies avec leurs données sous la forme d’une archive Jar (fichier APK). C’est
ce qu’on étudiera ici.
 «web app», c’est une application pour navigateur internet, développée en
HTML5, CSS3, JavaScript, dans un cadre logiciel (framework) tel que Node.js,
Angular ou React.
 «hybrides», elles sont développées dans un framework comme Ionic, Flutter,
React Native... Ces frameworks font abstraction des particularités du système :
la même application peut tourner à l’identique sur différentes plateformes
(Android, iOS, Windows, Linux...).
La charge d’apprentissage est la même.
 1.1.7. Applications natives
Une application native Android est composée de :
 Sources Java (ou Kotlin) compilés pour une machine virtuelle appelée «ART
», amélioration de l’ancienne machine «Dalvik » (versions ≤ 4.4).
 Fichiers appelés ressources :
Format XML : interface, textes...
Format PNG : icônes, images...
 Manifeste = description du contenu du logiciel
version minimale du smartphone,
Fichiers présents dans l’archive avec leur signature,
Demandes d’autorisations, durée de validité, etc.
Tout cet ensemble est géré à l’aide d’un IDE (environnement de développement)
appelé Android Studio qui s’appuie sur un ensemble logiciel (bibliothèques, outils)
appelé SDK Android.
 1.1.8. Kotlin

C’est un langage de programmation « symbiotique » de Java :

 Une classe Kotlin est compilée dans le même code machine que Java,
 Une classe Kotlin peut utiliser les classes Java et réciproquement.
 On peut mélanger des sources Java et Kotlin dans une même application.
Kotlin est promu par Google parce qu’il permet de développer des programmes
plus sains. Par exemple, Kotlin oblige à vérifier chaque appel de méthode sur des
variables objets pouvant valoir null, ce qui évite les NullPointerException.
1.1.9. Exemple : objet pouvant être
null
En Java :
String getNomComplet(Personne p) { return
p.getPrenom()+" "+p.getNom();
}

private Personne p1 = getPersonne(); // peut retourner null

System...println(getNomComplet(p1)); // NullPointerException

En Kotlin :
fun getNomComplet(p: Personne): String { return
p.prenom+" "+p.nom
}
var p1: Personne = getPersonne() // retour null interdit
println(getNomComplet(p1)) // ne se compile pas
1.1.9. Exemple : objet pouvant être
null
En Java amélioré :
import androidx.annotation.NonNull;

import androidx.annotation.Nullable;

void getNomComplet(@NonNull Personne p) { return

p.getPrenom()+" "+p.getNom();
}

private @Nullable Personne p1 = getPersonne();

System...println(getNomComplet(p1)); // ne se compile pas

NB : les import dépendent des bibliothèques utilisées, ici c’est androidx comme
en TP.
Cependant, il faut y penser. Kotlin vérifie systématiquement de nombreuses
choses (initialisations, etc.).
1.1.10. Pas de Kotlin pour ce cours

Kotlin ne remplace pas une analyse sérieuse et une programmation rigoureuse.

Kotlin permet seulement de ne pas se faire piéger avec des bugs grossiers.
Nous ne travaillerons pas avec Kotlin car ce langage nécessite un apprentissage.
Sa syntaxe est particulièrement abrégée, ex : définition implicite des variables
membres à partir du constructeur, définition et appel implicites des
setters/getters, liaison entre vues et variables membres d’une classe interface
graphique, utilisation des lambda, etc. L’ensemble n’est pas toujours très lisible.
Celles et ceux qui voudront faire du Kotlin le pourront, mais sous leur seule
responsabilité.
1.2. SDK Android et Android Studio

1.2.1. SDK et Android Studio

Le Software Development Kit (SDK) contient :

 Les librairies Java pour créer des logiciels
 Les outils de mise en boîte des logiciels
 AVD : un émulateur de tablettes pour tester les applications
ADB : un outil de communication avec les vraies tablettes
Le logiciel Android Studio offre :
 Un éditeur de sources et de ressources
 des outils de compilation : gradle
 Des outils de test et de mise au point
 1.2.2. Android Studio

Pour commencer, il faut installer Android Studio selon la procédure expliquée sur
le site officiel.
Pour le SDK, vous avez le choix, soit de l’installer automatiquement avec Studio,
soit de faire une installation personnalisée. En général, vous pouvez choisir ce
que vous voulez ajouter au SDK (version des librairies, versions des émulateurs
de smarphones), à l’aide du SDK Manager.
NB: dans la suite, certaines copies écran sont hors d’âge, mais je ne peux pas les
refaire à chaque variante de Studio.
 1.2.3. SDK Manager
C’est le gestionnaire du SDK, une application qui permet de choisir les
composants à installer et mettre à jour.
1.2.4. Choix des éléments du SDK
Le gestionnaire permet de choisir les versions à installer, ex. :
 Android 13 (API 32)
 ...
 Android 7.0 (API 24)
 ...
Choisir celles qui correspondent aux tablettes qu’on vise, mais tout n’est pas à
installer : il faut cocher Show Package Details, puis choisir élément par élément.
Seuls ceux-là sont indispensables :
 Android SDK Platform
 Intel x86 Atom_64 System Image
Le reste est facultatif (Google APIs, sources, exemples et docs).
 1.2.5. Dossiers du SDK
Le gestionnaire installe les éléments dans plusieurs sous-dossiers :
 SDK Tools : indispensable, contient le gestionnaire,
 SDK Platform-tools : indispensable, contient adb,
 SDK Platform : indispensable, contient les librairies,
 System images : pour créer des AVD,
 Android Support : divers outils pour créer des applications,
 Exemples et sources.
C’est déjà prêt à l’IUT, dans des versions antérieures correspondant à la date de
préparation des machines. Il faut savoir qu’il y a pas loin d’une mise à jour par
semaine, et donc tout évolue constamment.
 1.3. Première application
1.3.1. Objectif du jour 1

Ce jour, ce sera seulement un aperçu rapide des possibilités :

 Création d’une application «HelloWorld » avec un assistant,
 Tour du propriétaire,
 Exécution de l’application,
 Mise sous forme d’un paquet.
 1.3.2. Assistant de création
d’application
Android Studio contient un assistant de création d’applications :
 1.3.3. Modèle d’application
Android Studio propose plusieurs projets de base pour développer le nôtre. En général, on part
de celui appelé Empty Activity. Il faut bien connaître les autres si on veut les choisir.
 1.3.4. Nom, package et version
Dans le second écran, l’assistant demande le nom du projet, son package, son emplacement, et
le niveau minimal de l’API.
 1.3.5. Résultat de l’assistant

L’assistant a créé de nombreux éléments visibles dans la colonne de gauche de

l’IDE :
 manifests : description et liste des classes de l’application
 java : les sources, rangés par paquetage,
 res : ressources = fichiers XML et images de l’interface, il y a des sous-dossiers
:
 layout : interfaces (disposition des vues sur les écrans)
 menu : menus contextuels ou d’application
 mipmap et drawable : images, icônes de l’interface
 values : valeurs de configuration, textes...
 Gradle scripts : c’est l’outil de compilation du projet.
NB: ne pas chercher à tout comprendre cette semaine.
1.3.6. Fenêtre du projet
 1.3.7. Éditeurs spécifiques

Les ressources (disposition des vues dans les interfaces, menus, images
vectorielles, textes...) sont définies à l’aide de fichiers XML.
Studio fournit des éditeurs spécialisés pour ces fichiers, par exemple :
 Formulaires pour :
 res/values/strings.xml : textes de l’interface.
 Éditeurs graphiques pour :
 res/layout/*.xml : disposition des contrôles sur l’interface.
.3.8.Exemple res/values/strings.xml
1.3.9. Exemple res/layout/main.xml
1.3.9. Exemple res/layout/main.xml

Ces éditeurs sont beaucoup plus confortables que le XML brut, mais ne
permettent pas de tout faire (widgets custom et plantages).
Assez souvent, il faut éditer le source XML directement :
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent" android:layout_height="match_parent" >
<TextView android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hello_world" />
</RelativeLayout>

Notez le namespace des éléments et le préfixe de chaque attribut.

1.3.11. Reconstruction du projet

Chaque modification d’un source ou d’une ressource fait reconstruire le projet

(compilation des sources, transformation des XML et autres). C’est automatique.
Dans de rares circonstances, mauvaise mise à jour des sources (partages réseau
ou gestionnaire de version) :
 il peut être nécessaire de reconstruire manuellement. Il suffit de sélectionner
le menu Build/Rebuild Project,
 il faut parfois nettoyer le projet. Sélectionner le menu Build/Clean Project.
Ces actions lancent l’exécution de Gradle.
 1.3.12. Gradle

Gradle est un outil de construction de projets comme Make (projets C++ sur
Unix), Ant (projets Java dans Eclipse) et Maven.
De même que make se sert d’un fichier Makefile, Gradle se sert de fichiers
nommés build.gradle pour construire le projet.
C’est assez compliqué car AndroidStudio fait une distinction entre le projet global
et l’application. Donc il y a deux build.gradle :
 Un script build.gradle dans le dossier racine du projet. Il indique quelles sont
les dépendances générales (noms des dépôts Maven contenant les librairies
utilisées).
 Un dossier app contenant l’application du projet.
 Un script build.gradle dans le dossier app pour compiler l’application.
 1.3.13. Structure d’un projet
AndroidStudio
Un projet AndroidStudio est constitué ainsi :
1. +-- app/
2. | +-- build/ FICHIERS COMPILÉS
3. | +-- build.gradle SPÉCIF. COMPILATION
4. | `-- src/
5. | +-- androidTest/ TESTS UNITAIRES ANDROID | +-- main/
6. | | +-- AndroidManifest.xml DESCR. DE L'APPLICATION
7. | | +-- java/ SOURCES
8. | | `-- res/ RESSOURCES (ICONES...)
9. | `-- test/ TESTS UNITAIRES JUNIT
10. +-- build/ FICHIERS TEMPORAIRES
11. +-- build.gradle SPÉCIF. PROJET
12. `-- gradle/ FICHIERS DE GRADLE
1.3.14. Utilisation de bibliothèques
Certains projets font appel à des bibliothèques externes. On les spécifie dans le
build.gradle du dossier app, dans la zone dependencies :

dependencies {
// support
implementation 'androidx.appcompat:appcompat:1.2.0'
// annotations
annotationProcessor 'org.projectlombok:lombok:1.18.16'
implementation 'androidx.annotation:annotation:1.1.0'
// fuites mémoire
debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.5'
1.3.14. Utilisation de bibliothèques

Les bibliothèques indiquées sont automatiquement téléchargées.

Il y a des cas plus complexes. Par exemple, Realm (une base de données
distribuée), voir sa page prerequisites :
 dans le build.gradle à la racine du projet, mettre :
dependencies { classpath 'io.realm:realm-gradle-plugin:10.0.1' }
 dans le build.gradle du dossier app, ajouter :
apply plugin: 'realm-android'
 1.3.15. Mises à jour
Google propose souvent des mises à jour : l’IDE, le SDK et Gradle. Et aussi les
build.gradle des projets.
Par exemple, ce build.gradle emploie une ancienne version de Realm, il faudrait
mettre 10.0.1 à la place de 7.0.8 :
buildscript { repositories { ... } dependencies { classpath
'com.android.tools.build:gradle:4.1.1' classpath 'io.realm:realm-gradle-
plugin:7.0.8' // <-! }
}
 1.3.15. Mises à jour
Android Studio affiche un avertissement s’il y a une mise à jour sur les serveurs
(repositories). Il faut alors éditer les numéros de version manuellement, puis
reconstruire le projet (sync now ou try again).
On doit parfois compléter le build.gradle du dossier app.
apply plugin: 'com.android.application'
android { compileSdkVersion 30
buildToolsVersion "30.0.3" <<== PAS PAR DEFAUT
compileOptions { // pour les lambda sourceCompatibility
JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8
} ...
} dependencies { implementation 'androidx.appcompat:appcompat:1.2.0' ...
 1.4. Première exécution
1.4.1. Exécution de l’application
L’application est prévue pour tourner sur un appareil (smartphone ou tablette)
réel ou simulé (virtuel).
Le SDK Android permet de :
 Installer l’application sur une vraie tablette connectée par USB
 Simuler l’application sur une tablette virtuelle AVD
AVD = Android Virtual Device
C’est une machine virtuelle comme celles de VirtualBox et VMware, mais basée
sur QEMU.
QEMU est en licence GPL, il permet d’émuler toutes sortes de CPU dont des ARM7,
ceux qui font tourner la plupart des tablettes Android.
1.4.2. Assistant de création d’une
tablette virtuelle
1.4.3. Caractéristiques d’un AVD
L’assistant de création de tablette demande :
 Modèle de tablette ou téléphone à simuler,
 Version du système Android, • Orientation et densité de l’écran
 Options de simulation :
Snapshot : mémorise l’état de la machine d’un lancement à l’autre, mais exclut
Use Host GPU,
 Use Host GPU : accélère les dessins 2D et 3D à l’aide de la carte
graphique du PC.
 Options avancées :
 RAM : mémoire à allouer, mais est limitée par votre PC,
 Internal storage : capacité de la flash interne,
 SD Card : capacité de la carte SD simulée supplémentaire (optionnelle).
1.4.4. Lancement d’une application
Bouton vert pour exécuter, bleu pour déboguer :
NB: les icônes changent selon la version d’AndroidStudio.
1.4.5. Application sur l’AVD

L’apparence change
d’une version à l’autre
du SDK.
1.5. Communication AVD - Android
Studio
1.5.1. Fenêtres Android

Android Studio affiche plusieurs fenêtres utiles indiquées dans l’onglet tout en bas
:
Logcat Affiche tous les messages émis par la tablette courante
Messages Messages du compilateur et du studio
Terminal Shell unix permettant de lancer des commandes dans le dossier du
projet.
1.5. Communication AVD - Android
Studio
1.5.2. Fenêtre Logcat

Ils sont émis par les applications : debug, infos, erreurs... comme syslog sur Unix :
date, heure, gravité, source (code de l’émetteur) et message.
 1.5.3. Filtrage des messages
Il est commode de définir des filtres pour ne pas voir la totalité des messages de
toutes les applications de la tablette :
 Sur le niveau de gravité : verbose, debug, info, warn, error et assert,
 Sur l’étiquette TAG associée à chaque message, • sur le package de
l’application qui émet le message.
1.5.4. Émission d’un message vers
LogCat
Une application émet un message par ces instructions :

import android.util.Log; public class M ainActivity

extends Activity {public static final String TAG =

"monappli";

void maM ethode() {

Log.i(TAG, "appel de maM ethode()");

Fonctions Log.* :
 Log.i(String tag, String message) affiche une info,
 Log.w(String tag, String message) affiche une alerte,
 Log.e(String tag, String message) affiche une erreur.
 1.5.5. Logiciel ADB
Android Debug Bridge est une passerelle entre une tablette (réelle ou virtuelle) et
votre PC
 Serveur de connexion des tablettes
 Commande de communication
ADB emprunte à FTP (transfert de fichiers) et SSH (connexion à un shell).
 1.5.6. Mode d’emploi de ADB
En ligne de commande : adb commande paramètres...
 Gestion du serveur
 adb start-server : démarre le serveur,
 adb kill-server : arrête le serveur,
 adb devices : liste les tablettes connectées.
Exemple :
~/CoursAndroid/$ adb devices List of devices attached emulator-5554 device
c1608df1b170d4f device ~/CoursAndroid/$
Chaque tablette (device) possède un identifiant, ex: c1608df1b170d4f ou
emulator-5554 qu’il faut fournir aux commandes adb à l’aide de l’option -s.
 1.5.6. Mode d’emploi de ADB
Par défaut, c’est la seule tablette active qui est concernée.
 Connexion à un shell
 adb -s identifiant shell commande_unix... exécute la commande sur la
tablette
 adb -s identifiant shell ouvre une connexion de type shell sur la tablette.
Ce shell est un interpréteur sh simplifié (type busybox) à l’intérieur du système
Unix de la tablette. Il connaît les commandes standard Unix de base : ls, cd, cp,
mv, ps...
1.5.7. Système de fichiers Android
On retrouve l’architecture des dossiers Unix, avec des variantes :
 Dossiers Unix classiques : /usr, /dev, /etc, /lib, /sbin...
 Les volumes sont montés dans /mnt, par exemple /mnt/sdcard (mémoire flash
interne) et /mnt/extSdCard (SDcard amovible)
 Les applications sont dans :
 /system/app pour les pré-installées
 /data/app pour les applications normales
 Les données des applications sont dans /data/data/nom.du.paquetage.java
Ex: /data/data/fr.iutlan.helloworld/...
NB : il y a des restrictions d’accès sur une vraie tablette, car vous n’y êtes pas
root ...enfin en principe.
1.5.7. Système de fichiers Android
 Pour échanger des fichiers avec une tablette :
 adb push nom_du_fichier_local /nom/complet/dest envoi du fichier local
sur la tablette
 adb pull /nom/complet/fichier récupère ce fichier de la tablette • Pour
gérer les logiciels installés :
 adb install paquet.apk
 adb uninstall nom.du.paquetage.java
 Pour archiver les données de logiciels :
 adb backup -f fichier_local nom.du.paquetage.java ...
enregistre les données du/des logiciels dans le fichier local
 adb restore fichier_local restaure les données du/des logiciels d’après le
fichier.
1.6. Création d’un paquet installable
1.6.1. Paquet
Un paquet Android est un fichier .apk. C’est une archive signée (authentifiée)
contenant les binaires, ressources compressées et autres fichiers de données.
La création est relativement simple avec Studio :
1. Menu contextuel du projet Build..., choisir Generate Signed APK,
2. Signer le paquet à l’aide d’une clé privée,
3. Définir l’emplacement du fichier .apk.
Le résultat est un fichier .apk dans le dossier spécifié.
1.6.2. Signature d’une application
Lors de la mise au point, Studio génère une clé qui ne permet pas d’installer
l’application ailleurs. Pour distribuer une application, il faut une clé privée.
Les clés sont stockées dans un keystore = trousseau de clés. Il faut le créer la
première fois. C’est un fichier crypté, protégé par un mot de passe, à ranger
soigneusement.
Ensuite créer une clé privée :
 alias = nom de la clé, mot de passe de la clé
 informations personnelles complètes : prénom, nom, organisation, adresse,
etc.
Les mots de passe du trousseau et de la clé seront demandés à chaque création
d’un .apk. Ne les perdez pas.
1.6.3. Création du keystore
Création d’une clé
 1.6.6. Et voilà
C’est fini pour cette semaine, rendez-vous la semaine prochaine pour un cours sur
les interfaces Android.