Programmation
mobile sous
Android
INSEA- 2018/2019
Chaimae ANIBOU
Mohamed Nabil SAIDI
Plan
1. Plate forme et environnement de
développement
2. Première application Android
3. Interfaces graphiques
4. Communication entre les applications
5. Persistance des données
6. Programmation concurrente & Connectivité
7. Services web
2
Application mobile (Caractéristiques)
•
Cible : appareil électronique mobile (smartphone, tablette, etc.)
•
Contexte logiciel :
•
o
non connecté : agenda, baladeur, . . .
o
localisé : navigation GPS, travaux géolocalisés
o
connecté : tout Internet … avec un contexte mobile !
Contexte matériel :
o
ressources plus faibles : CPU / RAM / DD / ROM
o
la consommation des ressources doit être minimale
o
GUI adaptée
3
Application mobile (Principaux OS)
•
Android (Google) : Linux
•
BlackBerry OS, QNX : Unix
•
iOS (Apple) noyau hybride XNU : Mach(libre) + BSD (Unix)
•
Ubuntu Touch (Canonical) : Linux
•
Windows Phone, Windows 8 (Microsoft)
•
Tizen (Linux Foundation), supporté par Samsung / Intel
•
Firefox OS (Mozilla Corporation) : Linux
•
Arrêtés : HP webOS (Linux), Symbian_OS (Nokia), etc.
4
OS/smartphone dans le monde
5
Android (Origine)
•
Initialement un OS pour appareil photo
•
Acheté par Google en 2005
•
Objectif du rachat : créer une plateforme mobile
o Flexible,
o Accessible à tous les intégrateurs et développeurs,
o Profiter de la convergence web / mobile.
Android : système complet, ouvert et gratuit dans le monde du
6
mobile
Stratégie Google
•
Concept OpenSource
Plateforme mobile ouverte
Plus de revenus
Plus
d’utilisateurs
•
•
Plus de
développeurs
Android Market / Google Checkout
Publicité mobile
7
Android pour qui ?
•
•
•
•
Constructeurs de matériels (téléphones, GPS, netbook, ebook,
lecteur multimédia, bornes internet...),
Opérateurs,
Éditeurs de solutions logicielles.
Points forts:
o Constructeurs :
 Open Source, pas de coût de licence, Adaptabilité.
o Développeurs :
 Langage Java, Modularité, Kit de développement gratuit,
SDK complet, Android Market.
o Utilisateurs :
 Multitâches, Nouvelles applications, Nombreuses
applications par défaut.
8
Historique des versions d’Android
Code Name
API Level
Version
Date
Android
1
1.0
09/2008
Petit Four
2
1.1
02/2009
Cupcake
3
1.5
04/2009
…
…
…
…
Oreo
28
8.0
08/2017
9
Architecture d’Android
•
Une architecture autour du noyau Linux
•
Android est conçue pour des appareils mobiles au sens large
(téléphones, tablettes, ordinateurs portables, TV, des
baladeurs…)
•
La plate-forme Android est composée de différentes couches :
o
o
o
o
o
un noyau Linux qui lui confère notamment des
caractéristiques multitâches ;
des bibliothèques graphiques, multimédias ;
une machine virtuelle Java adaptée : la Dalvik Virtual
Machine ;
un framework applicatif proposant des fonctionnalités de
gestion de fenêtres, de téléphonie, de gestion de
contenu...
des applications, dont un navigateur web, une gestion
10
des contacts, un calendrier…
Composants d’Android
11
Composant : Noyau Linux
•
Couche basse de la plateforme pour la gestion des services du
système
•
o Gestion de la mémoire
o Gestion des processus
o Pilotes matériels
o Gestion réseau
o Sécurité
Première abstraction entre matériel et couche applicative
•
Gestion du Power Management
•
Binder pour faciliter la communication inter processus
12
Composant : Librairies natives
•
Librairie système C : libc
o
•
Dérivée de BSD (UNIX - Berkeley Software
Distribution) optimisée pour les systèmes embarqués
o rapides
Stockage, Rendu graphique, multimédia
o
•
SQLite : un SGBD simple et puissant accessible pour
toutes les
o API Média basée sur OpenCore de PacketVidéo (mpeg4,
o SGL/OpenGL ES, librairies 2D et 3D
o LibWebCore (moteur de navigation web utilisé)
Gestionnaire de surfaces (Surface Manager) : Pour créer des
interfaces visuelles
13
Composant : Framework Applicatif
•
Architecture conçue pour faciliter la réutilisation
•
Il fournit des API permettant aux développeurs de créer des
applications riches.
•
Chaque application est basée sur des services et systèmes :
o
o
o
o
o
Gestionnaire d’activités (Activity Manager) : gère le
cycle de vie des applis et l'enchaînement des vues
Gestionnaire des ressources (Ressources Manager) :
accès aux ressources statiques (images, fichiers, …)
Gestionnaire de fenêtres (Window Manager) : gère
les fenêtres des applications; quelle fenêtre doit être
afficher devant une autre à l'écran.
Mécanisme des vues (View System) : fournit tous les
composants graphiques.
…
14
Composant : Android Runtime
•
•
DALVIK Virtual Machine (avant Lollipop)
o Dalvik : ville en islande
o VM optimisée pour les systèmes embarqués
o VM à registres avec un jeu important d'instructions
o Conversion du bytecode : .class → .dex
o Exécute un fichier .dex généré par dx tool
o Une instance par processus
Un compilateur (ART) de bytecode vers le natif Android
Runtime (à partir de Lollipop).
15
Architecture Android
•
Android est conçu par des développeurs pour des
développeurs.
•
Android nécessite aucune certification pour devenir
développeur.
•
Avec Android, on peut distribuer et monétiser des
applications.
•
Puissant et intuitif, Android facilite le développement mobile.
•
Ouvert, un SDK simple et puissant. L’absence de coût de
licence attire plus de développeur.
•
Facilité d’accès au matériel de bas niveau avec une série
d’API.
•
Android fonctionne sur plusieurs marques de Smartphones.
16
Android et JAVA
•
Android ressemble à JAVA mais l’en est pas. Les applications
sont écrites par JAVA mais ne sont pas interprétés par la
machine virtuelle Java ME.
•
Les applications Java ne fonctionnent pas nativement sous
Android.
•
Les applications Android sont exécutées par une machine
virtuelle spécifique Dalvik (ART) et non par une JVM
classique.
•
Android inclus une implémentation Open source spécifique de
java basée non pas sur OpenJdk, mais sur le projet Harmony
(implémentation java 5 de la fondation apache).
•
Google a adapté Harmony et supprimé certains packages non
nécessaires en environnement mobile.
17
Android et JAVA
18
Créer une application Android
•
Connaissances Techniques
o
•
Android (runtime + framework) → POO + Java
Outils logiciels
o
Java Runtime Environment (JRE) pour exécuter les
outils Android
o
Android SDK
o
Android Virtual Device Manager (AVD), contenu dans
le Android SDK
o
un éditeur de texte
19
Android SDK
•
Le kit de développement Android (SDK) fournit
l’environnement de travail pour développer, tester et déboguer
des applications Android.
•
Dans le SDK on trouve:
o
Composés de bibliothèques d’API Android, les API
Android qui sont le cœur du SDK.
o
Des outils de développement qui permettent de compiler et
déboguer vos applications.
o
Le Virtual Device Manager et l’Emulateur qui fournit un
meilleur environnement de test.
o
Des exemples de code et un support en ligne.
20
Développer sous Android
•
Application Android, en pratique on utilise deux solutions :
o
Android SDK + Eclipse
o
Android Studio
https://developer.android.com/studio/index.html
21
Android Studio
22
Lancement et configuration
23
SDK Manager (Tools > Android)
•
Gère les versions du SDK d’Android installés
•
Gère les images des virtuals devices
o
Pour ARM, pour INTEL, pour chaque version d’Android
•
Gère les sources des différents SDK
•
Gère les sources des exemples
24
Création Projet
25
Choix version cible
26
Ajout d’une Activity
27
Configuration de l’Activity
28
Arborescence du projet
29
Arborescence du projet
Ressources JAVA
30
Arborescence du projet
Ressources images
31
Arborescence du projet
Interface Homme/Machine
pour l’interaction (interface
graphique) en XML.
32
Arborescence du projet
chaines de caractères et
dimensions
33
Palette de création
34
Palette de création
35
Android Virtual Devices
36
Android Virtual Devices
37
Android Virtual Devices
38
Émulateur Android
39
Première Application
My Application
Hello World!
40
Les applications Android
41
Structure d'une application Android
Une application Android est composée de deux
parties :
•
Une série de fichier XML décrivant
o l'application (version de l'API utilisée, activité
principale, etc.)
o les ressources (texte, image, layout, etc.)
•
du code Java pour spécifier la partie dynamique de
l'application
Les fichiers XML sont plus ou moins obligatoire
42
Structure d'un projet
• AndroidManifest.xml : décrit
les propriétés de l’application
• java/ : contient les fichiers
source
• res/ : contient les ressources
(images, descriptions d’interfaces,
valeurs) . Organisé en sous
dossiers par types (drawable,
layout, mipmap, values, …)
• Gradle Scripts : Scripts de
compilation
43
Application Android : Composition
44
Application Android : Fichier de configuration
C’est un fichier indispensable à chaque application
qui décrit entre autres :
•
Le point d’entrée de votre application (quel code doit
être exécuté au démarrage de l’application);
•
Quels composants constituent ce programme ;
•
Les permissions nécessaires à l’exécution du
programme (accès à Internet, accès à l’appareil
photo...).
45
Exemple : AndroidManifest.xml
46
Application Android : Les vues
Définition
Les éléments de l’interface graphique que l’utilisateur voit
et sur lesquels il pourra agir.
Les vues contiennent des composants, organisés
selon diverses mises en page :
•
•
•
les uns à la suite des autres,
en grille,
…
47
Application Android : Les contrôles
Définition
Les contrôles sont eux-mêmes un sous-ensemble
des vues :
• boutons,
• champs de saisie,
• case à cocher,
• …
Ils ont besoin d’accéder aux textes et aux images qu’ils
affichent (par exemple un bouton représentant un téléphone
aura besoin de l’image du téléphone correspondante). Ces
textes et ces images seront puisés dans les fichiers
ressources de l’application.
48
Les activités
49
Développer une application Android
•
Contrairement à une application classique, une
application Android est découpé en écran
o Chaque écran est géré par une activité (Activity)
o Une activité est une classe qui hérite de Activity
ou d’une classe dérivée de Activity
o Aucune méthode main dans un programme
Android
•
Le système Android contrôle les activités, pas le
développeur
o Le code d'une activité réagit à des évènements du
système Android
50
État d'une activité
•
Une seule activité visible à l'écran au premier plan
•
Une activité peut se trouver dans 3 états qui se différencient
surtout par leur visibilité :
o Active (resumed) : elle est visible en totalité.
o Suspendue (paused) : elle est partiellement visible à
l'écran (c'est le cas quand vous recevez un SMS).
o Arrêtée (stopped) : elle est tout simplement oblitérée par
une autre activité, on ne peut plus la voir du tout.
•
Passage de l'état visible à invisible :
o En lançant une nouvelle activité masquant l'activité
courante
51
o En détruisant l'activité courante (finish(), bouton "retour")
Cycle de vie d'une activité
L'activité réagie au demande du système Android (qui lui
même réagi au demande de l'utilisateur)
52
Activity.onXXX()
Les méthodes appelées lors des changements d'état :
• onCreate(Bundle savedInstanceState) : appelée à la création. Le
paramètre permet de récupérer un état sauvegardé lors de l'arrêt de
l'activité (si on a fait une sauvegarde)
• onStart() : appelée quand l'activité démarre
• onRestart() : appelée quand l'activité redémarre
• onResume() : appelée quand l'activité vient en premier plan
• onPause() : appelée quand l'activité n'est plus en premier plan
• onStop() : appelée quand l'activité n'est plus visible
• onDestroy() : appelée quand l'activité se termine
On redéfinie les méthodes que l'on veut et on oublie pas d'appeler en
premier super.onXXX()
53
Les Ressources
54
Répertoires des ressources
Le répertoire res/ contient toutes les ressources qui seront mises
dans le fichier application (apk). Il est constitué de sous répertoires :
• drawable (images)
• layout (description en XML des interfaces)
• values (définitions en XML de constantes (avec i18n) : string,
color, dim, style…)
• anim (description en XML d’animations)
• menus (description en XML de menus pour l’application)
• xml (fichiers XML utilisés directement par l’application)
• raw (tous les autres types de ressources : sons, vidéos, …)
• …
On peut ajouter d’autres sous répertoires
55
Exemple : internationalization (i18n)
56
La classe R
• C’est une classe générée par Android Studio qui permet à
l’application d’accéder aux ressources
• Elle contient des classes internes dont les noms correspondent
aux types de ressources (id, drawable, layout …)
• Elle est constituée à partir des fichiers placés dans les sous
répertoires du répertoire res/
• Une propriété est créée pour :
o
o
o
Chaque image placé dans drawable
Chaque identificateur défini dans des fichiers XML (objets
d’interface, constantes)
Chaque fichier placé dans les répertoires xml , raw …
57
Référence aux resources
58
Les composants graphiques
59
Vues et gabarits
Les éléments graphiques héritent de la classe View. On peut regrouper des
éléments graphiques dans une ViewGroup. Des ViewGroup particuliers
sont prédéfinis: ce sont des gabarits (layout) qui proposent une
prédispositions des objets graphiques:
• LinearLayout : dispose les éléments de gauche à droite ou du haut
vers le bas
• RelativeLayout : les éléments enfants sont placés les uns par rapport
aux autres
• TableLayout : disposition matricielle
• FrameLayout : disposition en haut à gauche en empilant les éléments
• GridLayout : disposition matricielle avec N colonnes et un nombre
infini de lignes
Les déclarations se font principalement en XML, ce qui évite de passer par
les instanciations Java.
60
Attributs des gabarits
Les attributs des gabarits permettent de spécifier des attributs
supplémentaires. Les plus importants sont:
• android:layout_width et android:layout_height :
o ="match_parent" : l'élément remplit tout l'élément parent
o ="wrap_content" : prend la place minimum nécessaire à
l'affichage
o ="fill_parent" : comme match_parent (deprecated, API<8)
• android:orientation : définit l'orientation d'empilement
• android:gravity : définit l'alignement des éléments
61
Exemple : LinearLayout
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:id="@+id/accueilid"
>
</LinearLayout>
62
Exemples : ViewGroup
Un ViewGroup contient des éléments graphiques. Pour
construire un gabarit linéaire on fera :
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:id="@+id/accueilid"
>
<TextView
android:id="@+id/le_texte" android:text="@string/hello"
/>
<TextView
android:id="@+id/le_texte2" android:text="@string/hello2"
/>
63
</LinearLayout>
View en Java
64
View basique
65
EditText
66