Programmation Mobile

Par Miguel Landry FOKO SINDJOUNG, PhD

Année Académique 2022-2023

Table des matières
CHAPITRE I : Introduction aux plateformes mobiles ............................................................................ 4
I- Introduction ............................................................................................................................... 4
II- Principaux concepts .............................................................................................................. 4
1- Plateformes et Système d’exploitation ................................................................................. 4
2- Frameworks d’application et applications .......................................................................... 5
III- Développement d’applications mobiles ............................................................................... 5
1- Choisir sa plateforme ............................................................................................................ 5
2- Connaitre le framework de votre application ..................................................................... 8
3- Connaitre son appareil mobile ........................................................................................... 10
4- Explorer les outils disponibles ............................................................................................ 10
5- Assistance pendant le développement ................................................................................ 10
6- Publier votre application .................................................................................................... 11
CHAPITRE II : Introduction à la programmatrion Java pour les plateformes mobiles ........................ 13
I- Introduction ............................................................................................................................. 13
II- Comment java et Android fonctionnent ensemble? ......................................................... 13
1- L’API d’Android ................................................................................................................. 13
2- Java est un Langage Orienté Objet (LOO) ....................................................................... 14
3- Qu’est ce que Android ?...................................................................................................... 14
III- L’environnement de développement.................................................................................. 15
1- Le JDK.................................................................................................................................. 15
2- Installer Android Studio ..................................................................................................... 15
IV- Qu’est ce qui constitue les applications Android ? ........................................................... 15
1- Ressources Android ............................................................................................................. 15
2- La structure d’un code java pour Android ....................................................................... 16
............................................................................................................................................................... 17
CHAPITRE III : Notre première application Android .......................................................................... 17
I- Création du projet ................................................................................................................... 17
1- Une note sur le controle de versions .................................................................................. 18
II- Déploiement et test de l’application. ...................................................................................... 18
1- Déploiement sur un émulateur ........................................................................................... 18
2- Déploiement sur un appareil mobile reel. ......................................................................... 18
III- Résumé ................................................................................................................................. 19
CHAPITRE IV : Création des interfaces............................................................................................... 19

Page 1 sur 49
 I- Structure de design d’une interface utilisateur (UI) ............................................................ 20
1- Configuration des widgets et creation de simples UI ....................................................... 20
II- Création d’une UI réelle ..................................................................................................... 21
III- Résumé ................................................................................................................................. 22
CHAPITRE V : Le cycle de vie d’une application Android ................................................................. 23
I- Introduction au cycle de vie Android .................................................................................... 23
II- Une explication simplifiée du cycle de vie Android .......................................................... 24
III- Qu’avons nous besoin de connaitre?.................................................................................. 24
IV- Qu’avons nous besoin de faire? .......................................................................................... 25
V- Application mettant en évidence le cycle de vie sous Android ........................................ 26
VI- Résumé ................................................................................................................................. 29
CHAPITRE VI : Etude des widgets sous Android ................................................................................ 30
I- Exploration de l’UI d’Android ............................................................................................... 30
1- Décclaration et initialisation d’objets ................................................................................ 30
2- Création des Widgets .......................................................................................................... 31
II- Exploration de la Palette. .................................................................................................... 31
1- EditText ................................................................................................................................ 31
2- ImageView............................................................................................................................ 32
3- Radio button et group ......................................................................................................... 32
4- Le widget switch .................................................................................................................. 35
5- Checkbox .............................................................................................................................. 35
6- WebView .............................................................................................................................. 36
7- Date and Time...................................................................................................................... 36
III- Une application mettant en pratique l’utilisation des widgets ........................................ 36
1- Création du projet d’exploration des widgets et des UI................................................... 36
2- Développement de l’application d’exploration des widgets ............................................. 39
IV- Résumé ................................................................................................................................. 43
CHAPITRE VII : Avoir un dialogue avec l'utilisateur .......................................................................... 45
I- Fenêtre du dialogue ................................................................................................................. 45
II- L’application de démonstration du dialogue ........................................................................ 45
CHAPITRE VIII : Introduction au développement d’applications mobiles multi-plateforme ............. 49
I- Introduction ...................................................................................................................... 49
II- La plateforme IONIC ................................................................................................. 49
III- La plateforme WINDEV MOBILE .............................................................................. 49

Page 2 sur 49
 IV- Projets .............................................................................................................................. 49
References: ............................................................................................................................................ 49

Page 3 sur 49
CHAPITRE I : Introduction aux plateformes mobiles

I- Introduction

Les appareils mobiles deviennent de plus en plus une partie intégrante de la vie des personnes. En 2010,
une étude d’une entreprise Américaine (Gartner) espérait que les applications mobiles devaient atteindre
un chiffre d'affaire massif de 21,6 milliards en 2013 générant un chiffre d'affaires de 29,5 milliards de
dollars. En tant que développeurs, nous pouvons donc considérer ce phénomène comme une opportunité
de développer un logiciel susceptible de toucher un vaste public. En outre, pour les développeurs
mobiles individuels, cette industrie pourrait offrir des avantages très lucratifs. Même aujourd'hui, la
possibilité de réaliser des bénéfices est énorme. Les histoires de réussite de développeurs, débutants et
experts, qui deviennent millionnaires après avoir créé des applications à succès sont légions. Les
opportunités d’emploi pour les développeurs mobiles sont également très bonnes. Selon les informations
sur les carrières d’ACM, la demande de développeurs d’applications mobiles est forte, mais le nombre
de personnes qualifiées disponibles est insuffisant. Par conséquent, si en tant que développeur, votre CV
dispose de connaissances en développement mobile, vous avez un avantage sur ceux qui n’en ont pas.
Cette connaissance sera utile même si vous ne souhaitez pas centrer votre carrière sur le développement
d'applications mobiles. De plus en plus d'entreprises se lancent dans l'industrie des applications mobiles
et introduisent des applications mobiles pour leurs utilisateurs; par conséquent, vous pouvez utiliser
cette connaissance dans presque tous les domaines. Ainsi, ce chapitre se veut un point de départ pour
les lecteurs du monde du développement d’applications mobiles en donnant une introduction et une vue
d’ensemble des différents aspects des plateformes et des applications mobiles.

Le chapitre est organisé comme suit:

Dans un premier temps, nous aborderons quelques concepts de base importants pour le développement
mobile. Ensuite, nous donnerons un guide pas à pas pour développer des applications, de la conception
à la publication. Simultanément, nous allons présenter et expliquer les concepts associés. Ensuite, nous
couvrirons les différences entre développement de bureau et développement mobile - principalement les
contraintes et les opportunités qu’a le développement mobile. Pour conclure, nous examinons ce que le
futur du mobile réserve, puis donnons un résumé des concepts abordés dans le chapitre.

II- Principaux concepts

Avant de nous intéresser au développement d’applications mobiles, examinons quelques-uns de ses

concepts clés.

1- Plateformes et Système d’exploitation

Pour pouvoir développer des applications mobiles, nous devons d'abord comprendre les
principes sous-jacents des plates-formes mobiles et leur lien avec les applications mobiles. Les
plateformes mobiles sont essentiellement ceux qui permettent aux logiciels et aux services de
fonctionner sur des appareils mobiles. Des exemples de plates-formes mobiles incluent Palm,
BlackBerry, iPhone, Android et Windows Mobile.
Les systèmes d'exploitation mobiles fournissent des outils permettant aux applications de
partager des données et des services. Les exemples de systèmes d'exploitation mobiles incluent
Palm OS, Symbian, Windows Mobile, Mac OS X et Android (Remarque: par souci de
simplicité, les «plates-formes mobiles» et le «système d’exploitation mobile» seront utilisés de
manière interchangeable dans le reste de ce chapitre). Pour ce chapitre, nous allons nous
concentrer sur trois plates-formes: IoS, Android et Windows Phone 7.

Page 4 sur 49
 2- Frameworks d’application et applications

Les frameworks d’applications mobiles sont un ensemble de bibliothèques de classes offrant aux
développeurs une interface pour construire des applications. Java ME, Cocoa Touch, Android SDK et
WebKit par exemple. Les applications sont construites à l'aide de frameworks d'application sur une
plate-forme donnée. La section suivante couvre les étapes que les développeurs doivent suivre lors du
développement d'applications mobiles.

III- Développement d’applications mobiles

Dans cette section, nous examinerons toutes les étapes à prendre en compte pour concevoir, développer,
publier et maintenir votre application. Les principaux concepts et idées sont expliqués au fur et à mesure
quand ils sont introduits.

1- Choisir sa plateforme

La toute première étape du développement d’applications mobiles consiste à choisir la plate-forme sur
laquelle on doit construire l'application. Cela peut dépendre du nombre de facteurs, dont les suivants:

• Les utilisateurs visés: La plate-forme BlackBerry est connue pour être dominante dans
l'entreprise marché et continue de le faire - bien que d’autres plates-formes gagnent
progressivement du marché partagé. Par conséquent, si votre application est destinée aux
utilisateurs de l'entreprise, BlackBerry peut être votre meilleur choix pour le moment. Par
contre, si votre application doit être utilisée par le marché de masse, vous pouvez décider de
développer votre application pour des plateformes telles qu’Android et iOS.
• Marché partagé: Analyser la part de marché actuelle et prévue pour déterminer laquelle des
plate-formes aura la plus grande part de marché dans les années actuelles et à venir
• Caractéristiques: Chaque plate-forme possède des fonctionnalités uniques que vous pouvez
exploiter dans votre application. Tenez-en compte lors de la conception de vos applications pour
optimiser votre application.

Jetons un coup d’œil sur les plateformes que nous avons choisies:

a) L’architecture basique d’Android est présentée dans la figure ci-dessous:

Page 5 sur 49
Linux Kernel: Le noyau Linux gère les services système essentiels et agit en tant que hardware
abstraction layer (HAL) entre le matériel physique de l'appareil et le SDK Android. Les principales
fonctionnalités incluent la gestion de la mémoire de bas niveau, la gestion des processus, mise en réseau
et autres services liés aux systèmes d'exploitation

Native Libraries: Les bibliothèques natives Android sont toutes des bibliothèques partagées écrites en
C ou C ++, compilé pour l’architecture matérielle particulière utilisée par le téléphone. Certains des
importants bibliothèques incluent OpenGL pour les graphiques 2D et 3D, la base de données SQLite et
la bibliothèque WebKit pour parcourir le contenu HTML.

Android Runtime: Cela inclut la machine virtuelle Dalvik (DVM) et les bibliothèques java principales.
Basé sur java VM, le design de Dalvik a été optimisé pour les faibles besoins en mémoire d’appareils
mobiles. Il permet à plusieurs machines virtuelles de s'exécuter simultanément.

Application Framework: Cette couche fournit les blocs de construction de haut niveau avec lesquels
les applications sont créées. Les classes importantes sont le gestionnaire d’activités qui contrôle le cycle
de vie des applications, Gestionnaire de localisation qui fournit des options de détection de localisation
et Ressource directeur.

Applications: Les applications elles-mêmes constituent la couche la plus élevée de l'architecture

Android. Elle se compose d'applications et de widgets. Les widgets sont des gadgets qui ne fonctionnent
que sur une petite zone de l'écran d'accueil

Caractéristiques uniques:

Page 6 sur 49
 • Open: La plate-forme Android est fournie par le biais de licences open source. Les développeurs
ont accès sans précédent aux fonctions basiques lors du développement d'applications.
• Free: Les applications Android sont libres de se développer. Il utilise des outils de
développement familier et peu coûteux. Le kit de développement logiciel (SDK) est également
disponible gratuitement pour Télécharger. Il ne nécessite que des frais d’inscription pour la
publication de vos applications pour la première fois. Les mises à jour de l'application sont
gratuites.

b) Ci-dessous l’architecture basique de iOS:

Le noyau sous iOS est basé sur la même variante du noyau Mach sous Mac OS X. Au dessus de ce
noyau se trouvent des couches de services utilisées pour implémenter des applications sur la plate-forme.
Ces couches comprennent le système d'exploitation principal, les services principaux, les services
multimédia et la couche Cocoa Touch. Cette hiérarchisation donne aux développeurs d'applications
différents degrés de contrôle. L'intention est pour les développeurs d’utiliser les cadres de niveau
supérieur pour le développement général, car ils libèrent les développeurs chargés de la mise en œuvre
des comportements standards du système. Lorsque cela est insuffisant, le niveau inférieur des
frameworks donnent plus de contrôle aux développeurs.

• Core OS, Core Services: Ceux-ci fournissent des services de bas niveau fondamentaux comme
les entrées/sorties de fichiers et les sockets réseau.
• Media: Cette couche fournit des services permettant de prendre en charge le dessin 2D et 3D,
ainsi que les fichiers audio et vidéo.
• Cocoa Touch: Cette couche fournit l'infrastructure fondamentale utilisée par les applications.
Outre la prise en charge de la programmation orientée objet pour les collections, la gestion de
fichiers et les opérations réseau, cette couche permet également d'accéder aux informations de
profil de l'utilisateur du périphérique, à l'accéléromètre et à d'autres fonctionnalités matérielles.

c) Les détails de l'architecture du téléphone Windows Phone 7 n'ont pas encore été rendus publics
par Microsoft.

Page 7 sur 49
Caractéristiques uniques:

L’un des composants distinctifs de Windows Phone 7 est l’interface utilisateur, appelée interface
utilisateur Metro, utilisant le langage de conception Metro de Microsoft. L’interface utilisateur de Metro
utilise des outils simples, propres et modernes que son langage de conception. Pour atteindre ces
objectifs, Metro utilise deux concepts: les plaques dynamiques et les hubs. Toute application peut être
épinglée sous “Démarrer” en tant que vignette dynamique et les applications peuvent choisir d’animer
ou de mettre à jour les vignettes dynamiques avec les informations clés relatives à l’application (par
exemple, le nombre de courriers électroniques non lus pour une application de messagerie électronique).
Cela permet à l'utilisateur de voir en un coup d'œil à tout moment s'il y a des éléments qui ont besoin de
son attention. Les seconds sont des hubs, dans lesquels des fonctions de même nature sont regroupées.
Le hub Personnes, par exemple, agit non seulement comme un carnet d’adresses sur le téléphone de
l’utilisateur, le courrier électronique, les comptes de serveur d’échange, mais s’intègre également à
Facebook et affiche les statuts et les mises à jour de Facebook pour les contacts des utilisateurs. De
même, le hub Photos ne contient pas seulement les photos et vidéos prises par l'utilisateur sur son
téléphone, il affiche également les photos partagées par ses amis sur Facebook.

Cette approche adoptée par Metro diffère grandement des deux autres plates-formes, car au lieu de
prendre une approche centrée sur les applications où le téléphone est simplement une passerelle vers les
applications, Metro se concentre davantage sur l'expérience de l'utilisateur.

2- Connaitre le framework de votre application

Après avoir choisi votre plate-forme, l'étape suivante consiste à vous familiariser avec son framework.
Les frameworks d’applications mobiles sont un ensemble de bibliothèques de classes offrant aux
développeurs une interface pour construire des applications. Java ME, Touch, SDK Android, WebKit et
Cocoa sont des exemples de frameworks d'application incluant.

a) Android

Les applications Android sont écrites en langage de programmation Java à l'aide des bibliothèques
Android fournies par le SDK. Les développeurs peuvent également créer des composants logiciels en C
et C ++ à l'aide du kit de développement natif Android (NDK), mais ce dernier ne constitue pas une
alternative complète au modèle de développement Java. Android étant une plate-forme ouverte, les
développeurs ont accès au même framework d’application que les applications téléphoniques
principales. Les principales composantes du cadre sont:

• Views – bloc de construction de base pour les composants d'interface utilisateur tels que les
dispositions et les menus.
• Content Providers – permet le partage de données entre applications telles que l'accès aux
contacts de l'utilisateur.
• Resource Manager
• Notification Manager – permet aux applications d'afficher des alertes dans la barre d'état.
• Activity Manager – gère le cycle de vie de l'activité

b) iOS

Page 8 sur 49
Apple fournit la plupart de ses interfaces système dans des packages spéciaux appelés "frameworks".
Une framework est un répertoire contenant une bibliothèque partagée dynamique et les ressources (telles
que les fichiers d’en-tête, les images, les applications auxiliaires, etc.) nécessaires pour soutenir cette
bibliothèque.

Les frameworks ont été agencés de manière similaire à la couche dans l'architecture d'iOS.

• Core OS Layer:
- Accelerate Framework: fournit une interface pour effectuer des calculs mathématiques
- External Accessory Framework: Ce frameworks est utilisé pour communiquer avec tous les
accessoires matériels attachés à un périphérique iOS.
- Security Framework: Prend en charge l'ajout de fonctionnalités de sécurité telles que la
gestion des certificats, des clés, des stratégies de confiance, etc.
• Core Services Layer ; Certains des frameworks sous cette couche incluent:
- Address Book Framework: Prend en charge l’accès aux informations de contact sur la base
de données de contacts de l’utilisateur.
- CFNetwork Framework: Ensemble d'interfaces basées sur le langage C qui permettent de
travailler avec des protocoles réseau.
- Core Data Framework: Gère les applications qui utilisent l'application Model-View-
Controller.
- Core Foundation Framework: Ensemble d'interfaces C fournissant des fonctionnalités de
base de gestion des données et de service pour des applications telles que la gestion de la
date / heure, la gestion des préférences, etc..
- Event Kit Framework: Fournit une interface pour accéder aux événements du calendrier sur
dispositif.
• Media Layer ; Certains des frameworks sous cette couche incluent:
- Assets Library Framework: Prise en charge de la récupération de photos et de vidéos à partir
du périphérique de l'utilisateur.
- AV Foundation Framework: Fournit des cours pour la lecture de contenu audio.
- OpenGL ES Framework: Fournit une interface pour dessiner du contenu 2D et 3D.
• Cocoa Touch Framework ; Certains des frameworks sous cette couche incluent:
- Address Book UI Framework: Fournit une interface pour la création de nouveaux contacts
et éditer les contacts actuels.
- Event Kit UI Framework: Fournit une interface pour visualiser et éditer des données liées
au calendrier.
- iAd Framework: Permet au développeur d'ajouter des publicités aux applications
- Map Kit Framework: Fournit une interface pour ajouter une carte à défilement à la vue
existante.
- UIKit Framework: Prend en charge l'accès à certaines fonctionnalités spécifiques à
l'appareil, telles que les données d'accéléromètre, l'appareil photo, les informations sur la
durée de vie de la batterie, etc

c) Windows Phone 7

Catte plateforme fournit deux frameworks:

• Le Silverlight framework: Pour le développement d'applications XAML basées sur les

événements qui permettent aux développeurs de développer des expériences utilisateur basées
sur le balisage créatif.
Page 9 sur 49
 • Le XNA framework: pour les jeux en boucle qui permettent des expériences de jeu et de
divertissements immersifs et amusants.

3- Connaitre son appareil mobile

Connaître les spécifications de l'appareil pour lequel vous allez développer l'application est extrêmement
essentiel. L'appareil constituera le point d'interaction entre les utilisateurs et votre application. Par
conséquent, l'intégration de ces spécifications dans votre application vous permettra de fournir une
meilleure expérience utilisateur. Il faut garder à l’esprit les caractéristiques telles que les dimensions de
l’écran, la position et l’orientation des boutons, la puissance de traitement, les capacités graphiques, les
fonctionnalités tactiles, etc.

4- Explorer les outils disponibles

Explorez les outils disponibles et déterminez ceux qui vous aideront le mieux à développer les
applications. Pour les applications mobiles, les émulateurs peuvent être utilisés pour simuler les
conditions de mobilité sur les ordinateurs de bureau pour effectuer des tests préliminaires.

• L'IDE le plus populaire et le plus connu est Eclipse, qui fournit une prise en charge complète
des applications Android via le plug-in Android Development Tools (ADT). Les applications
Android peuvent également être développées à partir de la ligne de commande ou d'un simple
éditeur de texte avec les outils appropriés installés. Des outils tiers également disponibles, tels
que IntelliJ IDEA ou Android Studio, assurent la prise en charge du dernier SDK Android et
offrent des fonctionnalités supplémentaires telles que la navigation rapide entre le code et les
ressources, le débogueur graphique et la prise en charge des tests unitaires.
• Xcode: Un environnement de développement complet fournit une gestion de projet, un éditeur
de source puissant et un débogueur graphique. Simulateur iOS: Exécutez, testez et déboguez
votre application localement sur votre Mac à l'aide d'un iPhone et d'un iPad simulés.
Instruments: collectez, affichez et comparez graphiquement les données de performances en
temps réel pour optimiser votre application. Interface Builder: Interface Builder facilite la
conception d'une interface utilisateur par glisser-déposer
• Tous les outils de développement Windows Phone 7 sont fournis sous forme de package
téléchargeable complet à partir de la page Mise en route de App Hub. Ces outils incluent Visual
Studio 2010, Microsoft Expression Blend 4.0, XNA Game Studio 4.0, Windows Phone
Emulator, Silverlight et .NET Framework 4. Si vous possédez déjà une copie de ce logiciel,
le programme d'installation installera simplement le support de développement du SDK et de
Windows Phone. en plus de votre logiciel existant. Sinon, une édition gratuite et express des
outils sera installée à la place.

5- Assistance pendant le développement

Vous pouvez utiliser diverses ressources pour vous aider en cas de problèmes ou de doutes rencontrés
au cours du développement. Les plates-formes disposent de forums officiels où les développeurs peuvent
s'entraider pour résoudre leurs problèmes de développement. Vous pouvez également utiliser les canaux
IRC qui offrent un moyen simple et rapide pour trouver des solutions.

Page 10 sur 49
 6- Publier votre application

Une fois votre application développée et testée, elle doit être publiée dans les magasins d'applications.
Les magasins d'applications constituent un point de contact unique pour le téléchargement d'applications
et de mises à jour. Les développeurs ajoutent leurs applications, leurs mises à jour et leur prix, tandis
que les utilisateurs téléchargent et ajoutent des critiques pour les applications dans les magasins
d'applications. Pour publier vos applications dans les magasins d'applications, vous devez respecter les
règles et les réglementations définies par les plateformes respectives. Pour certaines plates-formes
comme iOS et Windows Phone 7, votre application doit être approuvée avant de pouvoir être publiée
sur le marché.

• Android Market: Les développeurs doivent suivre un certain nombre d'étapes avant de pouvoir
publier leurs applications sur le marché Android (Google Play Store). La première étape consiste
à signer numériquement l'application avec un certificat à l'aide d'une clé privée détenue par le
développeur de l'application. Une fois les applications signées, l'étape suivante du déploiement
consiste à les publier. Les applications Android peuvent être distribuées aux utilisateurs finaux
de quelque manière que ce soit, notamment via le serveur Web du développeur. Android Market
est un service fourni par Google permettant aux utilisateurs de rechercher et de télécharger des
applications Android sur leurs appareils et aux développeurs de les distribuer aux utilisateurs
finaux du monde entier. Pour publier une application sur le développeur Android Market, vous
devez d’abord vous enregistrer et accepter les conditions générales spécifiées. Des frais
d'inscription de 25 $ sont requis pour la première fois pour créer un compte. Par la suite, la
publication des mises à jour et la création d'une licence sont gratuities
• App Store: Apple App Store est le premier magasin d'applications pour smartphones. En janvier
2011, il comptait plus de 350 000 applications disponibles et 10 milliards de téléchargements.
En mars 2011, le PDG d’Apple, Steve Jobs, a annoncé qu’Apple avait versé au total 2 milliards
de dollars américains à ses développeurs d’applications (soit 70% du chiffre d’affaires des
applications). L'App Store d'Apple est réputé pour son contrôle strict des applications soumises.
Chaque candidature soumise sera examinée par les employés d’Apple avant d’être approuvée.
Afin de réussir ce processus de révision de code, l'application doit montrer que (1) cela
fonctionne comme annoncé; (2) il ne plante pas l'iDevice et (3) il n'utilise pas d'API privées.
Pour publier des applications sur l'AppStore, les développeurs doivent s'inscrire au programme
iOS Developers Program et s'acquitter d'une taxe annuelle de 99 USD (pour les abonnements
individuels). L'application doit passer par un processus de signature de code complexe avant de
pouvoir être validée. Une fois qu'elle est prête, vous pouvez soumettre l'application à Apple
avec des informations de base, y compris Nom, Catégorie, Résumé et Captures d'écran. Après
cela, tout ce que vous pouvez faire est d’attendre. Le processus de révision prend souvent des
semaines à terminer.
• Pour déployer des applications sur des appareils Windows Phone réels, le téléphone doit d'abord
être déverrouillé en tant que téléphone développeur. Cela peut être fait via l'outil
d'enregistrement de développeur Windows Phone installé avec le SDK, même si un développeur
doit d'abord être officiellement enregistré auprès de Microsoft en tant que membre d'App Hub.
L'adhésion à App Hub est accompagnée d'un abonnement annuel de 99,00 USD, bien que les
étudiants puissent bénéficier de l'exonération des frais d'inscription via le programme
Dreamspark

Page 11 sur 49
Page 12 sur 49
CHAPITRE II : Introduction à la programmatrion Java pour les plateformes mobiles

I- Introduction

Dans ce chapitre, nous ne perdons pas de temps à commencer à développer des applications Android.
Nous examinerons ce qui est formidable à propos d'Android, ce que sont exactement Android et Java,
comment ils fonctionnent et se complètent, et ce que cela signifie pour nous en tant que futurs
développeurs. Après cela, nous consacrerons un peu de temps à la configuration de notre environnement
de développement, puis à la création et au déploiement de notre première application. À la fin de ce
chapitre, nous aurons fait ce qui suit:

• Configuré le Java development Kit (JDK), composant de l'environnement de

développement Android requis.
• Installé Android Studio, notre environnement de développement Android
• Construit notre toute première application Android
• Déployé un émulateur Android
• Exécuté notre application sur un émulateur Android et un appareil réel

II- Comment java et Android fonctionnent ensemble?

Après avoir écrit un programme en Java pour Android, nous cliquons sur un bouton pour changer notre
code en une autre forme comprise par Android. Cette autre forme s'appelle Dalvik EXecutable (DEX),
et le processus de transformation s'appelle la compilation. La compilation a lieu sur la machine de
développement après avoir cliqué sur ce bouton. Nous verrons ce travail juste après la mise en place de
notre environnement de développement.

Android est un système assez complexe, mais vous n'avez pas besoin de le comprendre en profondeur
pour pouvoir créer des applications étonnantes. La partie du système Android qui exécute notre code
DEX compilé est appelée la Dalvik Virtual Machine (DVM). Le DVM est un logiciel écrit dans une
autre langue qui s’exécute sur une version spécialement adaptée du système d’exploitation Linux. Donc,
ce que l'utilisateur voit d'Android, est en soi une application fonctionnant sur un autre système
d'exploitation.

La DVM a pour objectif de masquer la complexité et la diversité du matériel et des logiciels utilisés par
Android, tout en exposant toutes ses fonctionnalités utiles. Cette exposition de fonctionnalités
fonctionne généralement de deux manières. Le DVM lui-même doit avoir accès au matériel, ce qui est
le cas, mais cet accès doit être convivial pour les programmeurs et facile à utiliser. La manière dont la
DVM nous permet l’accès est en effet facile à utiliser grâce à l’API (Application Programming
Interface) d’Android.

1- L’API d’Android

L'API Android est le code qui facilite vraiment l'exécution de tâches exceptionnelles. Une simple
analogie pourrait être établie avec une machine, peut-être une voiture. Lorsque vous appuyez sur
l'accélérateur, de nombreuses choses se passent sous le capot. Nous n'avons pas besoin de comprendre
la combustion ni les pompes à carburant, car un ingénieur intelligent nous a fourni une interface. Dans
ce cas, une interface mécanique, la pédale d'accélérateur. Prenez la ligne de code Java suivante à titre
d'exemple. Il sera probablement un peu intimidant si vous êtes complètement nouveau sur Android:

Page 13 sur 49
[Link]
(LocationManager.GPS_PROVIDER);

Cependant, une fois que vous apprenez que cette seule ligne de code recherche les satellites disponibles,
puis communique avec eux en orbite autour de la Terre tout en récupérant votre latitude et longitude
précises sur la planète, il est facile de commencer à entrevoir la puissance et la profondeur de l’API
Android en conjonction avec la DVM. Même si ce code a l'air un peu difficile pour le moment, imaginez
parler à un satellite d'une autre manière! L'API Android est principalement un tas de code Java. Alors,
comment pouvons-nous utiliser tout ce code pour faire des choses cool sans être submergés par sa
complexité? Comment trouver et manipuler les pédales, le volant et le toit ouvrant de l'API Android?

2- Java est un Langage Orienté Objet (LOO)

Java est un langage de programmation qui existe depuis beaucoup plus longtemps qu'Android. C'est un
langage orienté objet. Cela signifie qu'il utilise le concept d'objets de programmation réutilisables. Si
cela ressemble à du jargon technique, une autre analogie aidera. Java nous permet, à d’autres personnes
(comme l’équipe de développement Android), d’écrire du code Java pouvant être structuré à partir de
"choses" réelles et, voici l’important, il peut être réutilisé.

3- Qu’est ce que Android ?

Nous savons que pour faire avancer les choses sur Android, nous écrivons notre propre code Java, qui
utilise également le code Java de l'API Android. Ceci est ensuite compilé dans le code DEX et exécuté
par la DVM, qui à son tour établit des connexions avec un système d'exploitation sous-jacent appelé
Linux. Ensuite, les fabricants des périphériques Android et des composants matériels individuels
écrivent des logiciels avancés, appelés pilotes, qui garantissent que leur matériel (CPU, GPU, récepteurs
GPS, etc.) peut fonctionner sur le système d'exploitation Linux sous-jacent. Notre code Java compilé,
ainsi que d'autres ressources, est placé dans un ensemble de fichiers appelé Android Application
Package (APK), et c'est ce dont la DVM a besoin pour exécuter notre application. Ce processus est
expliqué dans la figure suivante:

Page 14 sur 49
 En résumé, tout ce que nous devons faire, c'est apprendre à lire et à coder Java afin de pouvoir
commencer à apprendre et à tirer parti de l'API Android. Tous ces outils sont gratuits, regardons
donc l'environnement de développement que nous utiliserons.

III- L’environnement de développement

Un environnement de développement est un terme qui signifie avoir tout ce dont vous avez besoin
pour développer, vous installer et être prêt à aller dans un endroit. Nous avons besoin des deux choses
suivantes pour commencer:

Nous avons beaucoup parlé de la compilation de notre code Java, ainsi que du code Java d'autres
personnes, en code DEX qui s'exécutera sur la DVM, sur les appareils Android des utilisateurs. Pour
utiliser le code Java, nous avons besoin d’un logiciel libre appelé JDK. Le JDK inclut également le code
d'autres personnes, distinct de l'API Android.

Il faut toute une gamme d’outils pour développer Android, et nous avons également besoin de l’API
Android, bien sûr. L'ensemble de ces exigences est collectivement appelé Software Development Kit
(SDK) d’Android. Heureusement, le téléchargement et l'installation d'une seule application nous
permettront de regrouper ces éléments. Cette application unique s'appelle Android Studio. Android
Studio est un environnement de développement intégré (EDI) qui prend en charge toutes les
complexités de la compilation de notre code et de la liaison avec le JDK et l'API Android. Une fois que
nous avons installé JDK et Android Studio, nous pouvons faire tout ce dont nous avons besoin dans
cette application.

1- Le JDK

Cela peut être aussi simple que de télécharger, de double-cliquer sur le fichier téléchargé et de suivre les
instructions d'installation. Cependant, parfois ce n'est pas le cas. Donc, il vaut probablement la peine de
parcourir le processus d’installation étape par étape et de la façon dont quelques options peuvent rendre
les choses plus faciles. (Voir travaux pratiques).

2- Installer Android Studio

Maintenant que le JDK est installé et prêt à fonctionner, nous ne sommes plus qu’à une étape de la
construction de notre première application Android. L'installation d'Android Studio peut prendre un peu
plus de temps que le JDK et est un peu plus nuancée (voir travaux pratiques pour plus de détails).

IV- Qu’est ce qui constitue les applications Android ?

Nous savons déjà que nous écrirons du code Java qui utilisera lui-même le code Java d'autres personnes
et sera compilé en code DEX qui s'exécute sur la DVM. En plus de cela, nous allons également ajouter
et éditer d'autres fichiers. Ces fichiers sont appelés ressources Android.

1- Ressources Android

Notre application comprendra des ressources telles que des images, des sons et des dispositions
d'interface utilisateur conservées dans des fichiers distincts du code Java. Ils comprendront également
des fichiers contenant le contenu textuel de notre application. Il est habituel de faire référence au texte
de notre application via des fichiers séparés, car cela facilite leur modification et facilite la création
d'applications fonctionnant dans plusieurs langues.
Page 15 sur 49
De plus, les dispositions de nos applications en matière d'interface utilisateur, malgré l'option de les
implémenter avec un concepteur visuel, sont en réalité lues à partir de fichiers texte par Android. Bien
entendu, Android (ou tout ordinateur) ne peut pas lire et reconnaître un texte de la même manière qu'un
humain. Par conséquent, nous devons présenter nos ressources de manière hautement organisée et
prédéfinie. Pour ce faire, nous utiliserons le langage XML (Extensible Markup Language). XML est un
sujet énorme mais, heureusement, son objectif principal est d'être lisible à la fois par l'homme et par la
machine. Nous n'avons pas besoin d'apprendre ce langage, nous devons simplement observer (et ensuite
nous conformer) à quelques règles. En outre, la plupart du temps, lorsque nous interagissons avec XML,
nous le faisons via un éditeur visuel soigné fourni par Android Studio. Nous pouvons dire quand nous
traitons avec une ressource XML car le nom du fichier se terminera par l'extension .xml. Vous n'avez
pas besoin de le mémoriser, car nous reviendrons constamment sur ce concept tout au long du cours.

2- La structure d’un code java pour Android

En plus de ces ressources, il convient de noter que Java, utilisé dans Android, a une structure pour son
code. Il existe plusieurs millions de lignes de code dont nous pouvons tirer parti. Ce code devra
évidemment être organisé de manière à faciliter la recherche et la référence. Il est organisé sous des
packages prédéfinis spécifiques à Android..

Chaque fois que nous créons une nouvelle application Android, nous choisissons un nom unique appelé
package. Nous verrons comment procéder dans la section Notre première application Android. Les
packages sont souvent séparés en sous-packages, ils peuvent donc être regroupés avec d'autres packages
similaires. Nous pouvons simplement les considérer comme des dossiers et des sous-dossiers.

Nous pouvons également penser à tous les packages mis à notre disposition par l'API Android sous
forme de livres contenant du code, issus d'une bibliothèque. Certains packages Android courants que
nous utiliserons sont les suivants:

[Link]

[Link]

[Link]

Comme vous pouvez le constater, ils sont organisés et nommés de manière à rendre leur contenu aussi
évident que possible.

Les classes sont contenues dans ces packages. Nous verrons dans notre toute première application
comment importer facilement les packages d'autres personnes, ainsi que des classes spécifiques de ces
packages, pour les utiliser dans nos projets. Une classe sera presque toujours contenue dans son propre
fichier, portant le même nom que la classe et portant l'extension de fichier .java.

En Java, nous divisons davantage nos classes en sections qui effectuent les différentes actions de notre
classe. Nous appelons ces sections des méthodes. Ce sont, le plus souvent, les méthodes de la classe que
nous allons utiliser pour accéder aux fonctionnalités fournies dans ces millions de lignes de code. Nous
n'avons pas besoin de lire le code. Nous avons juste besoin de savoir quelle classe fait ce dont nous
avons besoin, dans quel package elle se trouve et quelles méthodes de la classe nous donnent
précisément les résultats que nous recherchons. Le diagramme suivant montre une représentation de
l'API Android. Nous pouvons penser à la structure du code que nous écrirons exactement de la même

Page 16 sur 49
manière, même si nous n'aurons très probablement qu'un seul paquet par application. Bien sûr, en raison
de la nature orientée objet de Java, nous n'utiliserons que des composants sélectifs de cette API. Notez
également que chaque classe a ses propres données distinctes. En règle générale, si vous souhaitez
accéder aux données d’une classe, vous devez disposer d’un objet de cette classe.

CHAPITRE III : Notre première application Android

En programmation, il est de tradition que la première application d'un nouvel étudiant utilise lae
langage/le système d'exploitation qu'il utilise pour dire bonjour au monde. Nous allons rapidement
construire une application qui fait exactement cela.

I- Création du projet

Page 17 sur 49
Nous allons commencer par la creation de ce projet (Confèrefère TP)

1- Une note sur le controle de versions

Dans ce cours, nous aborderons tout ce que vous devez savoir pour publier des applications
professionnelles. Une chose dont nous ne discuterons pas est de travailler en collaboration dans le cadre
d’une équipe ou de toute stratégie de sauvegarde de votre code. Si vous avez seulement l'intention de
créer vous-même des applications, vous n'avez pas besoin d'en savoir plus. Cependant, Android Studio
fonctionne de manière presque transparente avec un certain nombre de systèmes de contrôle de version
(SCV) et de référentiels de code différents. SCV et leurs référentiels de code associés présentent un
certain nombre d'avantages, à savoir:

o Vous pouvez autoriser plusieurs programmeurs à contribuer au même projet et sur le même
fichier
o Vous pouvez cliquer sur un bouton pour ramener votre travail à une position spécifiée si vous
se rendre compte que vous avez mal tourné
o Vous pouvez stocker votre code de manière transparente dans un référentiel sur le cloud/Web
et travailler sur votre projet à partir de n'importe quel ordinateur de développement sans vous
soucier de la sauvegarde des fichiers.

Obtenir tous ces avantages n’est pas compliqué et, dans certains cas, c’est même gratuit. Le problème
que présente l’introduction de VCS dans un cours comme celui-ci est qu’il existe énormément d’options
et qu’il n’ya pas d’option simple, universellement meilleure, qui conviendra à tout le monde. En outre,
cela crée un autre obstacle avant que nous puissions nous lancer dans la création d'applications.

II- Déploiement et test de l’application.

Nous devons tester fréquemment nos applications tout au long du développement pour détecter
d'éventuelles erreurs, blocages ou autres erreurs imprévues. Il est également important de vous assurer
que l'application est correcte et qu'elle fonctionne correctement sur chaque type/taille de périphérique
que vous souhaitez cibler. Il est clair que nous ne possédons pas chacun des milliers d’appareils Android.
C’est là que les émulateurs entrent en jeu. Cependant, les émulateurs sont parfois un peu lents et
encombrants, bien qu’ils se soient beaucoup améliorés récemment. Si nous voulons avoir une idée réelle
de l'expérience que nos utilisateurs vont vivre, rien ne vaut le déploiement d'une application sur un
appareil réel. Nous voudrons donc probablement utiliser à la fois des appareils réels et des émulateurs
lors du développement de nos applications. Nous allons tout d'abord déployer sur un émulateur, puis sur
un périphérique réel.

1- Déploiement sur un émulateur

(Voir TP)

2- Déploiement sur un appareil mobile reel.

La première chose à faire est de visiter le site Web du fabricant de votre périphérique et d’obtenir et
installer tous les pilotes requis pour votre périphérique et votre système d’exploitation.

(Voir TP).

Page 18 sur 49
 III- Résumé

Jusqu'à présent, nous avons mis en place un environnement de développement Android et créé et déployé
une application sur un émulateur et un appareil réel. Si vous avez encore des questions sans réponse (et
vous en avez probablement plus qu'au début de ce chapitre), ne vous inquiétez pas, car à mesure que
nous approfondirons les mondes Android et Java, les choses deviendront plus claires. Au fur et à mesure
que les chapitres progressent, vous allez acquérir une compréhension très complète de la manière dont
tout s’articule, puis le succès dépendra simplement de la pratique et de la profondeur de l’API Android.
Dans le chapitre suivant, nous allons modifier l'interface utilisateur à l'aide du concepteur visuel et du
code XML brut, écrire nos premières méthodes Java et utiliser certaines méthodes fournies par l'API
Android.

CHAPITRE IV : Création des interfaces

Dans ce chapitre, nous allons apprendre quelques notions de base de l'interface utilisateur, telles que la
manière dont nous contrôlons la taille et la position des widgets dans nos présentations. Nous
comprendrons mieux le code XML légèrement effrayant et verrons comment nous pourrions éviter de
le modifier directement à l'aide du concepteur d'interface utilisateur, en couvrant les éléments suivants:
• Examen de la structure de code sous-jacente à une conception/mise en page d'interface
utilisateur
• Apprendre à positionner les widgets avec précision
• Construire trois interfaces utilisateur très simples à partir de rien

Page 19 sur 49
 I- Structure de design d’une interface utilisateur (UI)

Lorsque nous créons un nouveau projet, Android Studio crée une nouvelle disposition pour nous.
Comme nous l'avons vu, cette disposition générée automatiquement est très simple et ne contient qu'un
seul widget TextView. Sans surprise, le widget TextView est le moyen standard d’affichage de texte.
Sur la palette, il est étiqueté Plain TextView, mais dans le code XML, il est simplement écrit TextView.
J'y ferai référence de la manière qui semble la mieux adaptée au contexte actuel.

Ce que nous n’avons pas examiné de plus près, c’est que le fichier activity_main.xml généré contient
également une mise en page. Il existe différents types de mises en page. RelativeLayout est celle fournie
avec notre mise en page générée automatiquement. Voici le XML qui fait cette mise en page:

<RelativeLayout xmlns:

android="[Link]
xmlns:tools="[Link]
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
tools:context=".LayoutExperiments">

</RelativeLayout>

Tout ce qui est entre la fermeture> qui définit les propriétés de la présentation elle-même et le </
RelativeLayout> est un enfant (comme notre TextView solitaire) de la présentation. Cet enfant sera
influencé par les propriétés de son parent et devra également utiliser des propriétés appropriées à son
parent. Selon le type de présentation dans lequel un enfant est contenu, il devra utiliser la syntaxe
appropriée pour influencer son apparence/sa position. La seule façon d'apprendre toutes les subtilités
des différents types de disposition et leur incidence sur leurs widgets enfants est de commencer à les
utiliser.

Nous allons d’abord explorer les widgets simples et leurs propriétés, puis les mises en page, puis nous
les utiliserons de manière significative dans une série de mini-projets de mise en page.

1- Configuration des widgets et creation de simples UI

Les widgets sont tous les éléments d'interface utilisateur de la palette sous le titre Widgets. Tout d'abord,
examinons certaines propriétés d'un widget. Notez que certains widgets ont des propriétés qui leur sont
propres, mais il y en a beaucoup que tous les widgets partagent et qu'il est utile d'examiner. Découvrons
quelques-unes des manières dont nous pouvons configurer et utiliser les widgets avant de les utiliser
réellement.

L'application des concepts mentionnés dans le titre se fera en réalisant l'interface suivante:

Page 20 sur 49
 II- Création d’une UI réelle

L'objectif de cette section est d'apprendre à réaliser une interface plus complexe. Nous allons
ensuite réaliser l'interface suivante :

En guise d’expérience, essayez de faire pivoter l’écran en mode portrait. Vous obtenez une image
semblable à la suivante:

Pas trop mal mais certainement imparfait. Il existe plusieurs solutions possibles à ce problème:
1. Fournissez une mise en page supplémentaire dans un fichier du même nom et mettez-la dans un
dossier nommé layout-portrait dans le dossier res.

Page 21 sur 49
 2. Verrouillez la présentation en mode paysage et empêchez l'utilisateur de la faire pivoter. Nous
pouvons le faire en code XML ou Java.
3. Trouvez une solution tout à fait plus élégante mais légèrement plus complexe en utilisant des
fragments.

Nous allons utiliser la deuxième solution

lorsque nous construirons notre première
application complète.

III- Résumé
La principale chose à apprendre de ce chapitre est que l'expérience et la pratique sont beaucoup plus
utiles que de vastes volumes de connaissances. Si vous avez une bonne idée pour une nouvelle interface
utilisateur cool, mais que ce chapitre ne vous a pas montré comment le faire, alors il est probable que
quelqu'un d'autre ait déjà partagé cette connaissance, et une recherche rapide sur le Web fournira
généralement un tutoriel ou une discussion fournissant vos solutions. Maintenant que vous connaissez
le concepteur d'interface utilisateur, les didacticiels sur le Web doivent être facilement compréhensibles.

Malgré des progrès importants, il y a un très gros éléphant dans la pièce. Bien sûr, notre interface ne fait
rien! Notre formulaire soigné ne collecte pas un seul fragment de données et notre liste de défilement
intelligente n’affiche aucun détail lorsque nous cliquons sur l’un des éléments.
Pour résoudre ces problèmes, nous devons d’abord nous familiariser avec Java. C'est ce que nous allons
commencer à faire dans le prochain chapitre.

Page 22 sur 49
CHAPITRE V : Le cycle de vie d’une application Android

Dans ce court chapitre, nous examinerons le cycle de vie d’une application Android. Au début, il peut
sembler un peu étrange qu'un programme informatique ait un cycle de vie, mais cela aura bientôt un
sens. Nous verrons les étapes traversées par une application, de la création à la destruction, et comment
cela nous aide à savoir où placer notre code Java, en fonction de ce que nous essayons de réaliser.

En bref, nous allons examiner:

• Une introduction au cycle de vie Android
• Quelle méthode peut on surcharger avec @Override
• Les phases du cycle de vie Android
• Ce que nous devons savoir et faire exactement pour coder nos applications
• Une mini application de démonstration du cycle de vie
• Un aperçu de la structure du code, prêt à intégrer le codage Java dans le chapitre suivant.
Commençons à apprendre sur le cycle de vie Android.

I- Introduction au cycle de vie Android

Nous avons parlé un peu de la structure de notre code; que nous écrivons des classes, et au sein de ces
classes, nous avons des méthodes qui contiennent notre code. Nous savons également que lorsque nous
voulons que le code d’une méthode soit exécuté, nous appelons cette méthode en utilisant son nom. De
plus, dans les chapitres précédents, nous avons appris qu'Android lui-même appelle la méthode onCreate
juste avant que l'application soit prête à démarrer. Ce que nous allons regarder maintenant, c'est ce qui
se passe tout au long du cycle de vie de chaque application que nous écrivons: quand elle commence et
se termine, ainsi que quelques étapes intermédiaires. Et ce que nous verrons, c'est qu'Android interagit
réellement avec notre application à de nombreuses reprises, à chaque fois qu'elle est exécutée. Pour ce
faire, il appelle des méthodes contenues dans la classe Activity. Même si la méthode n'est pas visible
dans notre code Java, Android l'appelle toujours au moment opportun. Si cela ne semble pas avoir de
sens, alors lisez la suite

Vous êtes-vous déjà demandé pourquoi la méthode onCreate comportait une ligne de code étrange juste
avant?

@ Override

Ce qui se passe ici, c'est que lorsque vous appelez onCreate, nous demandons à Android de bien vouloir
utiliser notre propre version, car nous avons certaines choses à faire à ce moment-là. En outre, vous vous
souviendrez peut-être de la première ligne de code étrange de la méthode onCreate:

[Link](savedInstanceState)

Ceci dit à Android d'appeler la version originale/officielle de onCreate avant de passer à la version
remplacée. Ce n'est pas juste une bizarrerie d'Android, le remplacement de méthode est intégré à Java.
Il existe également de nombreuses autres méthodes que nous pouvons éventuellement remplacer, et elles
nous permettent d’ajouter notre code à des moments appropriés du cycle de vie de notre application
Android. La raison pour laquelle nous devons nous préoccuper des méthodes de notre application que
Android appelle à tout moment, c'est parce qu'elles contrôlent la vie et la mort de notre code. Par
exemple, que se passe t-il si notre application permet à l'utilisateur de saisir un moment d'inspiration,
peut-être un poème ou un rappel vital, dans notre application de prise de notes hypothétique, lorsque la
sonnerie du téléphone sonne? Il est essentiel, et heureusement assez simple, que nous apprenions quand,
pourquoi et quelles méthodes Android appellera dans le cadre du cycle de vie de notre application. On
peut alors savoir où nous devons surcharger des méthodes pour ajouter notre propre code et où ajouter
la fonctionnalité réelle (code) qui définit notre application. Examinons le cycle de vie d'Android, puis
passons aux détails de Java, et nous saurons exactement où mettre le code que nous écrivons.

Page 23 sur 49
 II- Une explication simplifiée du cycle de vie Android

If you have ever used an Android device, you have probably noticed it works quite differently than many
other operating systems. For example, you can be using an app, say you're checking what people are
doing on Facebook. Then you get an e-mail notification and you tap the e-mail icon to read it. Mid-way
through reading the e-mail you might get a Twitter notification, and because you're waiting on important
news from someone you follow, you interrupt your e-mail reading and change apps to Twitter, with one
touch. After reading the tweet, you fancy a game of Angry Birds, but mid-way through the first daring
fling you suddenly remember that Facebook post. So you quit Angry Birds and tap the Facebook icon.
Then you resume Facebook, probably at the same point you left it. You could have resumed reading the
e-mail, decided to reply to the tweet, or started an entirely new app.
All this backwards and forwards takes quite a lot of management on the part of the operating system,
apparently independent from the individual apps themselves. The difference between, say, a Windows
PC and Android in the context we have just discussed is this: with Android, although the user decides
which app they are using, the OS decides if and when to actually close down (destroy) an application,
and our user's data (like the hypothetical note) along with it. We just need to consider this when coding
our apps.

III- Qu’avons nous besoin de connaitre?

Le système Android a plusieurs phases différentes dans lesquelles une application donnée peut se situer.
En fonction de la phase, le système Android détermine la manière dont l'application est visualisée par
l'utilisateur ou non. Android a ces phases, il peut donc décider quelle application est actuellement
utilisée, puis allouer la bonne quantité de ressources, telles que la mémoire et la puissance de traitement.

Mais cela nous permet également, en tant que développeurs d'applications, d'interagir avec ces phases.
Nous avons déjà soulevé la question de savoir ce qui se passera si l'utilisateur quitte notre application
pour répondre à un appel téléphonique, perdront-ils leur progrès / données / note importante?

Android a un système assez complexe qui, simplifié un peu à des fins d’explication, signifie que chaque
application d’un appareil Android se trouve dans l’une des phases suivantes:
• A la création
• Au démarage
• A là reprise
• A l’exécution
• En pause
• A l’arrêt
• A la destructiont

La liste des phases paraîtra assez logique. À titre d'exemple, l'utilisateur appuie sur l'icône de
l'application Facebook pour créer l'application. Puis c'est démarré. Tout cela est assez simple jusqu'à
présent, mais le suivant dans la liste reprend. Ce n’est pas aussi illogique qu’il pourrait paraître au début.
Si, pendant un moment, nous pouvons simplement accepter que l'application reprenne après son
démarrage, tout deviendra clair au fur et à mesure que nous avancerons.

Après la reprise, l'application est en cours d'exécution. C’est à ce moment que l’application Facebook
contrôle l’écran et probablement la plus grande part de la mémoire système et de la puissance de
traitement. Maintenant, qu'en est-il de notre exemple lorsque nous sommes passés de l'application
Facebook à l'application e-mail?

Lorsque vous appuyez sur une notification pour aller lire votre courrier électronique, l'application
Facebook sera probablement entrée dans la phase de pause, suivie de l'arrêt, et l'application de courrier
électronique entrera dans la phase en cours de création, suivie de la reprise, puis de l'exécution.

Page 24 sur 49
Si nous décidons de revenir sur Facebook, comme dans le scénario précédent, l'application Facebook ne
sera probablement pas créée, puis redémarrera, reprendra et sera de nouveau exécutée, probablement
sur le poste où nous l'avons laissée. Notez que, à tout moment, Android peut décider de s’arrêter puis de
détruire une application. Dans ce cas, lorsque nous relancerons l'application, elle devra être créée à
nouveau lors de la première phase.

Donc, si l'application Facebook avait été assez longtemps inactive, ou si Angry Birds avait eu besoin de
tant de ressources système qu'Android l'avait détruite, notre expérience de recherche du message exact
que nous lisions précédemment aurait peut-être été différente. Si toute cette phase commence à être
source de confusion, vous serez heureux de savoir que la seule raison de le mentionner est que:
• Tu sais que ça existe
• Nous avons parfois besoin d'interagir avec elle
• Nous allons avancer pas à pas quand nous le ferons

IV- Qu’avons nous besoin de faire?

Lorsque nous programmons une application, comment pouvons-nous interagir avec cette complexité?
La bonne nouvelle est que le code Android généré automatiquement lors de la création de notre premier
projet en fait la majeure partie pour nous. Comme nous en avons discuté, nous ne voyons simplement
pas les méthodes qui gèrent cela, mais nous avons la possibilité de les remplacer et d'ajouter notre propre
code à cette phase.

Cela signifie que nous pouvons apprendre l’application Java et créer des applications Android jusqu’à
ce que nous arrivions à l’une des rares instances pour lesquelles nous devons faire quelque chose, en
particulier dans l’une des phases.

Voici une explication rapide des méthodes fournies par Android, pour notre commodité, pour gérer les
phases du cycle de vie. Pour clarifier notre discussion sur les méthodes de cycle de vie, elles sont
énumérées à côté de leurs phases correspondantes, que nous avons discutées. Cependant, comme vous
le verrez, les noms de méthodes indiquent assez clairement où ils se situent. Il existe également une
brève explication ou suggestion concernant le moment où nous pourrions utiliser une méthode donnée
et ainsi interagir pendant une phase spécifique. Nous rencontrerons la plupart de ces méthodes à mesure
que nous progressons dans le cours. Nous avons bien sûr déjà vu onCreate:

• onCreate: Cette méthode est exécutée lors de la création de l'activité. Ici, tout est prêt pour
l’application, y compris l’interface utilisateur (comme l’appel setContentView), les graphiques
et le son.
• onStart: Cette méthode est exécutée lorsque l’application est en phase de démarage.
• onResume: Cette méthode fonctionne après onStart mais peut également être entrée, peut-être de
manière plus logique, si notre activité est reprise après une pause antérieure. Nous pouvons
recharger des données utilisateur précédemment enregistrées (telles qu'une note importante) à
partir du moment où l'application a été interrompue, par exemple par un appel téléphonique ou
par l'utilisateur exécutant une autre application.
• onPause: Vous êtes probablement en train de maîtriser ces méthodes. Cela se produit lorsque
notre application est en pause. Ici, nous pourrions sauvegarder des données non sauvegardées
(telles que la note) qui pourraient être recharges.
• onResume. Les activités passent toujours dans un état de pause lorsqu'un autre élément de
l'interface utilisateur est affiché en haut de l'activité en cours (par exemple, une boîte de dialogue
contextuelle) ou lorsque l'activité est sur le point d'être arrêtée (par exemple, lorsque l'utilisateur
accède à un autre élément. activité).
• onStop: Cela concerne la phase d'arrêt. C'est ici que nous pourrions annuler tout ce que nous
avons fait dans onCreate, tel que la libération de ressources système ou l'écriture d'informations

Page 25 sur 49
 dans une base de données. Si nous arrivons ici, nous allons probablement nous faire détruire
bientôt.
• onDestroy: C'est à ce moment que notre activité est finalement détruite. Il n'y a pas de retour en
arrière à cette phase. Ceci est notre dernière chance de démanteler notre application de manière
ordonnée. Si nous arrivons ici, nous allons certainement traverser les phases du cycle de vie dès
le début.

Toutes les descriptions de méthodes et leurs phases associées doivent paraître simples. Peut-être que la
seule vraie question est: qu'en est-il de la phase de fonctionnement? Comme nous le verrons lorsque
nous écrivons notre code dans les autres méthodes / phases, les méthodes onCreate, onStart et onResume
prépareront l'application, qui persistera ensuite, formant la phase en cours d'exécution. Ensuite, les
méthodes onPause, onStop et onDestroy seront utilisées par la suite. Nous pouvons maintenant examiner
ces méthodes du cycle de vie en action. Nous le ferons en les écrasant tous et en ajoutant un message
Log et un message Toast.

V- Application mettant en évidence le cycle de vie sous Android

Cette expérience rapide nous aidera à nous familiariser avec les méthodes de cycle de vie utilisées par
notre application et nous permettra également de jouer avec un peu plus de code Java:

1. Lancez un nouveau projet et appelez-le Lifecycle Demonstration.

2. Acceptez les périphériques cibles par défaut.
3. Choisissez Activité vide et ne vous préoccupez pas de la personnalisation de l'activité des
options du tout.
4. Ouvrez le fichier [Link] dans l'éditeur de code. S'il n'est pas ouvert par défaut,
cliquez avec le bouton gauche de la souris sur l'onglet MainActivity situé au-dessus de l'éditeur.

Vous avez créé un nouveau projet avec tous les paramètres par défaut. Nous n'aurons besoin que du
fichier [Link] pour cette démonstration et nous ne créerons pas d'interface utilisateur.

Dans le fichier [Link], recherchez la méthode onCreate et ajoutez ces deux lignes de code
juste avant l'accolade fermante} qui marque la fin de la méthode onCreate:

[Link](this, "In onCreate", Toast.LENGTH_SHORT).show();

Log.i("info", "In onCreate");

La méthode onCreate entière devrait maintenant ressembler exactement à ceci, où le code en surbrillance
correspond aux deux lignes que nous venons d’ajouter:

@Override
protected void onCreate(Bundle savedInstanceState) {

[Link](savedInstanceState);
setContentView([Link].activity_main);
[Link](this, "In onCreate", Toast.LENGTH_SHORT).show();
Log.i("info", "In onCreate");

Après l'accolade fermante} de la méthode onCreate, laissez une ligne vide et ajoutez les cinq méthodes
de cycle de vie suivantes et leur code contenu. N'oubliez pas que vous devrez utiliser la combinaison de
touches Alt + Entrée à deux reprises pour importer les classes nécessaires à Toast et à Log. Notez
également que l'ordre dans lequel nous ajoutons nos méthodes substituées n'a pas d'importance. Android
les appellera dans le bon ordre quel que soit l'ordre dans lequel nous les tapons:

Page 26 sur 49
@Override
public void onStart() {
// First call the "official" version of this method
[Link]();
[Link](this, "In onStart", Toast.LENGTH_SHORT).show();
Log.i("info", "In onStart");
}

@Override
public void onResume() {
// First call the "official" version of this method
[Link]();
[Link](this, "In onResume", Toast.LENGTH_SHORT).show();
Log.i("info", "In onResume");
}

@Override
public void onPause() {
// First call the "official" version of this method
[Link]();
[Link](this, "In onPause", Toast.LENGTH_SHORT).show();
Log.i("info", "In onPause");
}

@Override
public void onStop() {
// First call the "official" version of this method
[Link]();
[Link](this, "In onStop", Toast.LENGTH_SHORT).show();
Log.i("info", "In onStop");
}

@Override
public void onDestroy() {
// First call the "official" version of this method
[Link]();
[Link](this, "In onDestroy", Toast.LENGTH_SHORT).show();
Log.i("info", "In onDestroy");
}

Tout d’abord, parlons du code lui-même. Notez que les noms de méthodes correspondent tous aux
méthodes et phases du cycle de vie que nous venons de décrire. Notez que toutes les déclarations de
méthode sont précédées de la ligne de code @Override. Voyez également que la première ligne de code
dans chaque méthode est [Link]….

Qu'est-ce qui se passe réellement ici?

• Android appelle nos méthodes aux différents moments dont nous avons déjà parlé.
• Le mot clé @Override indique que ces méthodes remplacent/annulent la version d'origine de la
méthode fournie avec l'API Android. Notez que nous ne voyons pas ces méthodes surchargées,
mais elles sont là. Si nous ne les redéfinissons pas, ces versions originales seraient appelées par
Android au lieu de la nôtre.
• La syntaxe [Link]…, qui correspond à la première ligne de code de chacune des méthodes
remplacées, appelle ensuite ces versions d'origine. Nous ne les remplaçons donc pas simplement
pour ajouter notre propre code, nous les appelons également et leur code est également exécuté.

Enfin, le code que vous avez ajouté obligera chacune des méthodes à générer un message Toast et un
message Log. Toutefois, les messages produits varient, comme le montre le texte situé entre les
guillemets doubles "". Les messages produits indiqueront clairement quelle méthode les a produits.

Page 27 sur 49
Maintenant que nous avons examiné le code, nous pouvons jouer avec notre application et en savoir
plus sur le cycle de vie de ce qui se passe:

1. Exécutez l'application sur un périphérique ou un émulateur.

2. Regardez l'écran de l'émulateur et vous verrez s'afficher l'un après l'autre les messages suivants
sous forme de messages Toast: In onCreate, In onStart et In onResume.
3. Notez les messages suivants dans la fenêtre logcat. S'il y a trop de messages, n'oubliez pas que
vous pouvez les filtrer en définissant la liste déroulante Niveau de journalisation sur Info:
info: dans onCreate
info: dans onStart
info: dans onResume
4. Appuyez maintenant sur le bouton Retour de l'émulateur ou du périphérique. Notez que vous
recevez les trois messages Toast suivants dans cet ordre. Dans onPause, dans onStop, dans
onDestroy. Vérifiez que nous avons la sortie correspondante dans la fenêtre logcat.
5. Ensuite, lancez une application différente. Peut-être que l'application Hello Android du chapitre
2, La première application, peut-elle être effleurée de son icône sur l'écran de l'émulateur.
6. Essayez maintenant ceci: appuyez sur le sur l'émulateur, mais varie légèrement d'un périphérique
à l'autre.
7. Vous devriez maintenant voir toutes les applications récemment exécutées sur l'appareil. Voici ce
que mon.
8. Appuyez sur l'application de démonstration du cycle de vie et remarquez que les trois messages
de départ habituels sont affichés. C'est parce que notre application a déjà été détruite.
9. Cependant, appuyez à nouveau sur le bouton du gestionnaire de tâches et passez à l'application
Hello Android. Notez que cette fois, seuls les messages In onPause et In onStop sont affichés.
Vérifiez que nous avons la sortie correspondante dans le logcat. L'application n'a pas été détruite.
10. Maintenant, à nouveau à l'aide du bouton du gestionnaire de tâches, basculez vers l'application
Lifecycle Demonstration. Vous verrez que seuls les messages In onStart et In onResume ont été
affichés, indiquant qu'onCreate n'était pas nécessaire pour que l'application s'exécute à nouveau.
Ceci est comme prévu car l'application n'a pas été détruite auparavant, simplement arrêtée.

Ensuite, parlons de ce que nous avons vu lorsque nous avons exécuté l'application. Lorsque nous avons
lancé l'application de démonstration Lifecycle Demonstration pour la première fois, nous avons constaté
que les méthodes onCreate, onStart et onResume étaient appelées. Ensuite, lorsque nous avons fermé
l'application à l'aide du bouton Précédent, les méthodes onPause, onStop et onDestroy ont été appelées.
De plus, nous savons grâce à notre code que les versions originales de toutes ces méthodes sont
également appelées car nous les appelons nous-mêmes avec le code [Link]…, qui est la première
chose que nous faisons dans chacune de nos méthodes remplacées.
Le comportement bizarre de nos applications est apparu lorsque nous avons utilisé le gestionnaire de
tâches pour basculer entre les applications. De plus, lors de l'abandon de Lifecycle Demonstration, il n'a
pas été détruit. Ensuite, lors du retour en arrière, il n’était pas nécessaire de lancer onCreate.

Il est tout à fait possible (mais pas si probable) que vous obteniez des résultats légèrement différents
lorsque vous avez suivi les étapes précédentes. Ce qui est certain, c’est que lorsque nos applications sont
exécutées sur des milliers d’appareils différents par des millions d’utilisateurs différents qui ont des
préférences différentes en matière d’interaction avec leurs appareils, Android appellera les méthodes du
cycle de vie à des moments que nous ne pouvons pas vraiment prédire.

Par exemple, que se passe-t-il lorsque l'utilisateur quitte l'application en appuyant sur le bouton
d'accueil? Lorsque nous ouvrons deux applications l'une après l'autre, puis que nous utilisons le bouton
Précédent pour passer à l'application précédente: cela va-t-il détruire ou simplement arrêter
l'application? Que se passe-t-il lorsque l'utilisateur a une douzaine d'applications dans son gestionnaire
de tâches et que le système d'exploitation doit détruire certaines applications qui n'étaient précédemment
qu'arrêtées: notre application sera-t-elle l'une des "victimes"? Vous pouvez bien sûr tester tous ces
scénarios sur l'émulateur, mais les résultats ne seront vrais que lorsque vous le testerez. Il n'est pas
garanti que le même comportement sera affiché à chaque fois, et certainement pas sur tous les appareils

Page 28 sur 49
Android. Enfin de bonnes nouvelles! La solution à toute cette complexité est de suivre quelques règles
simples:

• Configurez votre application prête à fonctionner dans la méthode onCreate

• Chargez les données de votre utilisateur dans la méthode onResume
• Enregistrer les données de votre utilisateur dans la méthode onPause
• Rangez votre application et faites-en un bon citoyen Android avec la méthode onDestroy.
• Surveillez tout au long du livre les occasions où nous aimerions utiliser onStart et onStop.

Si nous faisons ces choses et que nous verrons comment faire au cours du support, nous pourrons
simplement cesser de nous inquiéter pour tout ce qui concerne le cycle de vie et laisser Android le gérer!

VI- Résumé
Dans ce chapitre, nous avons vu que ce n'est pas seulement nous qui pouvons appeler notre code. Le
système d'exploitation peut également appeler le code contenu dans les méthodes que nous avons
remplacés. En ajoutant le code approprié aux méthodes de cycle de vie substituées appropriées, nous
pouvons être sûrs que le bon code sera exécuté au bon moment. Ce que nous devons faire maintenant,
c’est apprendre à écrire un peu plus de code Java.

Page 29 sur 49
CHAPITRE VI : Etude des widgets sous Android

Maintenant que nous avons une très bonne vue d'ensemble de la mise en page et du codage d'une
application Android, de notre nouvelle connaissance de la programmation orientée objet et de la manière
dont nous pouvons manipuler une interface utilisateur à partir de notre code Java, nous sommes prêts à
expérimenter davantage de widgets de la palette.
La POO est parfois délicate, mais en apprenant progressivement de nouveaux concepts, en les
pratiquants et en les familiarisant, il deviendra au fil du temps notre ami. Dans ce chapitre, nous allons
beaucoup nous diversifier en revenant à la palette Android Studio et en regardant une demi-douzaine de
widgets que nous n’avons pas vus du tout ou n’avons pas encore pleinement utilisés. Une fois cela fait,
nous les placerons tous dans une mise en page et nous nous entraînerons à les manipuler avec du code
Java. Dans ce chapitre, nous allons:
• Actualiser nos mémoires sur la façon de déclarer et d'initialiser des widgets de présentation
• Découvrir rapidement comment créer des widgets avec uniquement du code Java
• Consulter les widgets EditText, ImageView, RadioButton (et RadioGroup), Switch, CheckBox,
WebView et TextClock.
• Apprendre à utiliser une classe anonyme
• Créer une mini-application de démonstration de widget en utilisant tous les widgets précédents

Commençons par un bref récapitulatif.

I- Exploration de l’UI d’Android

Lançons Android Studio et préparons-nous un peu plus profondément dans la palette. Pendant que nous
attendons son démarrage, récapitulons rapidement les objets, en particulier à l'aide d'objets de notre
présentation d'interface utilisateur.

1- Décclaration et initialisation d’objets

Nous savons que lorsque nous appelons setContentView dans la méthode onCreate, Android gonfle tous
les widgets et mises en forme et les transforme en objets Java réels sur le tas. Nous savons que pour
utiliser un widget à partir du segment de mémoire, nous devons d'abord déclarer un objet du type correct,
puis l'utiliser pour obtenir une référence à l'objet de widget d'interface utilisateur sur le segment de
mémoire à l'aide de sa propriété unique id. Par exemple, nous obtenons une référence à TextView avec
une propriété id de txtTitle et l'attribuons à un nouvel objet appelé myTextView comme ceci :

// Prenez une référence à un objet sur le tas

TextView myTextView = (TextView) findViewById([Link]);

Maintenant, en utilisant notre variable d'instance myTextView, nous pouvons faire tout ce que la classe
TextView a été conçue pour faire. Par exemple, nous pouvons définir le texte de sorte qu'il soit affiché
comme ceci:

[Link]("Hi there");

On peut le faire disparaître comme ça:

// Bye bye
[Link]([Link])

On peut encore changer le texte et le faire réapparaître:

[Link]("BOO!");
// Surprise
[Link]([Link])

Page 30 sur 49
Il est à noter que nous pouvons manipuler n’importe quelle propriété que nous avons définie en Java.
En outre, nous avons laissé entendre, mais pas réellement vu, que nous pouvons créer des widgets à
partir de rien en utilisant uniquement du code Java.

2- Création des Widgets

Nous pouvons également créer des widgets à partir d'objets Java qui ne font pas référence à un objet de
notre mise en page. Nous pouvons déclarer, instancier et définir les propriétés d'un widget, tout en code,
comme ceci:

Button myButton = new Button();

Le code précédent crée un nouveau bouton en utilisant new(). Le seul inconvénient est que Button doit
faire partie d'une mise en page avant de pouvoir être affichée. Nous pourrions donc obtenir une référence
à un élément de présentation à partir de notre présentation XML ou en créer un nouveau dans le code.

Si nous supposons que nous avons LinearLayout dans notre structure XML avec une propriété id égale
à linearLayout1, nous pourrions y placer notre bouton de la ligne de code précédente, comme ceci:

// Obtenez une référence à LinearLayout

LinearLayout linearLayout = (LinearLayout) findViewById ([Link]);
// Ajouter votre bouton dessus
[Link](myButton)

Nous pourrions même créer une présentation entière en code Java pur en créant d'abord une nouvelle
présentation, puis tous les widgets que nous voulons ajouter, et enfin en appelant setContentView sur la
présentation qui contient nos widgets. Dans le code suivant, nous créons une mise en page juste en Java,
bien que très simple, avec un seul widget Button dans LinearLayout:

// Création d’un LinearLayout

LinearLayout linearLayout = new LinearLayout();
// Création d’un Button
Button myButton = new Button();
// Ajout de myButton au LinearLayout
[Link](myButton);
// Rendre le LinearLayout vue principale
setContentView(linearLayout);

Il est sans doute évident, mais il convient également de souligner que concevoir une mise en page
détaillée et nuancée uniquement en Java est beaucoup plus gênante, difficile à visualiser, et non de la
manière la plus courante. Il y a des moments, cependant, où nous trouverons utile de faire les choses de
cette façon. Nous sommes assez avancé maintenant avec les dispositions et les widgets. Cependant, il
est évident que la palette contient de nombreux autres widgets (et éléments d'interface utilisateur) que
nous n'avons pas encore explorés. Alors faisons-le.

II- Exploration de la Palette.

Faisons un tour d'horizon de certains des éléments précédemment inexplorés de la palette, puis nous
pouvons en faire glisser un tas sur une présentation et voir certaines de leurs méthodes qui pourraient
être utiles. Nous pouvons alors mettre en place un mini projet pour les mettre tous à profit.

1- EditText

Le widget EditText fait ce que son nom suggère. Si nous mettons EditText à la disposition de nos
utilisateurs, ils seront en mesure d’éditer le texte qu’il contient. Nous l'avons vu au chapitre 4,
Conception des mises en page, lors de la conception d'un formulaire d'inscription. Ce que nous n’avons
pas vu, c’est comment capturer les informations à partir de là ou à quel endroit nous placerions ce code

Page 31 sur 49
de capture de texte. Le bloc de code suivant suppose que nous avons déclaré un objet du type EditText
et que nous l'avons utilisé pour obtenir une référence à EditText dans notre structure XML. Nous
pourrions écrire un code comme celui-ci pour un clic de bouton, peut-être un bouton de soumission pour
un formulaire, mais il pourrait également aller partout où nous le jugeons nécessaire pour notre
application:

String editTextContents = [Link]()

// editTextContents contient dès lors la valeur saisie par l’utilisateur

Nous verrons cela dans un contexte réel dans la prochaine mini-application.

2- ImageView

Nous avons déjà mis une image sur notre mise en page à quelques reprises jusqu'à présent, mais nous
n'avons jamais eu de référence à une image à partir de notre code Java ou fait quoi que ce soit avec elle
auparavant. Le processus est exactement le même. Suivez les étapes suivantes pour obtenir une référence
à ImageView comme à n'importe quel autre widget:

1. Déclarer un objet
2. Recupérer la reference en utilisant findViewById method et un parameter id valide comme ceci:

ImageView imageView = (ImageView) findViewById([Link]);

Ensuite, nous pouvons continuer à faire de belles choses avec notre image en utilisant un code comme
celui-ci:

// Rendre l’image 50% TRANSPARENT

[Link](.5f);

Dans le code précédent, nous avons utilisé la méthode setAlpha() sur imageView. La méthode
setAlpha() prend une valeur comprise entre 0 et 1. La transparence totale est 0 et aucune transparence
est égale à 1.

Nous allons utiliser certaines des méthodes ImageView dans notre prochaine mini application.

3- Radio button et group

RadioButton est utilisé lorsque l'utilisateur a le choix entre deux options ou plus qui s'excluent mutuellement.
Autrement dit, si vous en choisissez un, les autres choix ne peuvent pas être choisis, comme une radio à l'ancienne.
Regardez un radiogroupe simple avec quelques options de RadioButton dans cette image suivante:

Lorsque l'utilisateur sélectionne une option, les autres options sont automatiquement désélectionnées.
Nous contrôlons les widgets RadioButton en les plaçant dans RadioGroup dans notre interface
utilisateur. Nous pouvons, bien sûr, utiliser le concepteur visuel pour faire simplement glisser un groupe
de RadioButtons sur RadioGroup. Lorsque nous le faisons, la disposition XML ressemble à ceci:

<RadioGroup
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_alignParentTop="true"

Page 32 sur 49
 android:layout_alignParentLeft="true"
android:layout_alignParentStart="true"
android:id="@+id/radioGroup">
<RadioButton
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Option 1"
android:id="@+id/radioButton3"
android:checked="true"
/> />
<RadioButton
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Option 2"
android:id="@+id/radioButton2"
android:checked="false"
/> />
<RadioButton
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Option 3"
android:id="@+id/radioButton3"
android:checked="false"
/>
<RadioGroup/>

Notez que dans le code précédent, chaque bouton radio et radiogroupe possède un jeu de propriétés
id approprié. Nous pouvons ensuite obtenir une référence, comme on peut s'y attendre, comme suit:

// Recupérer les références de tous nos widgets

RadioGroup radioGroup = (RadioGroup) findViewById([Link]);
RadioButton rb1 = (RadioButton) findViewById([Link].radioButton1);
RadioButton rb2 = (RadioButton) findViewById([Link].radioButton2);
RadioButton rbnew3 = (RadioButton) findViewById([Link].radioButton3);

Comme nous le verrons, dans la pratique, nous pouvons gérer à peu près tout, à partir de la référence
RadioGroup. Vous pensez peut-être, comment savons-nous quand ils ont été cliqués? Ou vous
pouvez penser que garder trace de celui qui est sélectionné peut être gênant. Pour cela, nous avons
besoin de l’aide de l’API Android et de Java.

RadioButton se comporte différemment d'un bouton classique, et écouter des clics dans onClick
(après avoir implémenté OnClickListener) ne fonctionnera pas, car RadioButton n'est pas conçu de
cette manière. Ce que nous devons faire, c'est utiliser une autre fonctionnalité Java. Nous devons
implémenter une classe, une classe anonyme, dans le seul but d'écouter les clics sur RadioGroup.
Le bloc de code suivant suppose que nous avons une référence à RadioGroup appelée radioGroup:

[Link]( new [Link]() {

@Override
public void onCheckedChanged(RadioGroup group, int checkedId) {
// Handle clicks here
}
} );

Dans le code précédent, spécifiquement, la ligne [Link] de son

accolade d'ouverture {, à l'accolade de fermeture} est ce qu'on appelle une classe anonyme car elle
n'a pas de nom. Le code de classe réel ne s'exécute pas quand onCreate est appelé; il prépare
simplement la classe à gérer les éventuels clics sur le radiogroupe. Nous allons maintenant en
discuter plus en détail.

Je me souviens de la première fois que j'ai vu une classe anonyme, et ça m'a presque donné envie
de me cacher dans un placard, mais ce n'est pas aussi complexe que cela puisse paraître au premier
abord. Le code ajoute un écouteur à radioGroup. Pendant ce temps, nous déclarons et instancions

Page 33 sur 49
une classe d'écoute et nous la préparons à écouter radioGroup tout en surchargeant simultanément
la méthode requise, onCheckedChanged. Cela ressemble à l’équivalent RadioGroup de onClick.
Passons en revue. Tout d'abord, nous appellerons la méthode setOnCheckedChangedListener sur
notre classe radioGroup:

[Link](

Nous passons dans une nouvelle classe anonyme et les détails de sa méthode surchargée comme
argument:

new [Link]() {
@Override
public void onCheckedChanged(RadioGroup group, int checkedId) {
// Handle clicks here
}
}

Enfin, nous avons la parenthèse fermante de la méthode et, bien sûr, le point-virgule pour marquer
la fin de la ligne. La seule raison pour laquelle nous le présentons sur plusieurs lignes est de le rendre
plus lisible. En ce qui concerne le compilateur, tout pourrait être regroupé:

Si nous utilisons le code précédent pour créer et instancier une classe qui écoute les clics sur notre
classe RadioGroup, peut-être dans la méthode onCreate, cette méthode écoutera et répondra pendant
toute la durée de l'activité. Il ne vous reste plus qu'à apprendre à gérer les clics dans la méthode
onCheckedChanged que nous avons surchargée. Notez que l'un des paramètres de la méthode
transmise lors de l'appui sur le radiogroupe est int ID vérifié. Ceci contient l'identifiant du bouton
radio actuellement sélectionné. C'est exactement ce dont nous avons besoin, presque. Vous serez
peut-être surpris de constater que checkId est int. Android stocke tous les ID au format int, même si
nous les déclarons avec des caractères alphanumériques, tels que radioButton1 ou radioGroup. Tous
nos noms conviviaux sont convertis en int lorsque l'application est compilée. Alors, comment savoir
quel élément int fait référence à un ID tel que radioButton1, ou radioButton2, etc.? Ce que nous
devons faire est d’obtenir une référence à l’objet réel référencé par CheckId. On ferait comme ceci:

RadioButton rb = (RadioButton) [Link](checkedId);

Maintenant, nous pouvons récupérer l'ID familier que nous utilisons pour le bouton radio
actuellement sélectionné, pour lequel nous avons maintenant une référence stockée dans rb. Nous
le faisons avec la méthode getId, comme ceci:

[Link]();

Nous pourrions donc gérer les clics de RadioButton en utilisant un bloc de commutateur avec une
casse pour chaque RadioButton possible sur laquelle appuyer, ainsi que la méthode [Link] () en
tant qu'expression du bloc de commutateur. Le code suivant montre tout le contenu de la méthode
onCheckedChanged dont nous avons parlé:

// Obtenir une référence au bouton radio actuellement coché

RadioButton rb = (RadioButton) [Link](checkedId);
// Switch based on the 'friendly' id
switch ([Link]()) {
case [Link].radioButton1:
// Do something here
break;
case [Link].radioButton2:
// Do something here
break;
case [Link].radioButton3:
// Do something here
break;

Page 34 sur 49
 }
// Fin du bloc switch

Voir ce bloc en action dans la prochaine mini-application de travail où nous pouvons appuyer les
boutons pour de vrai rendront cela plus clair.

4- Le widget switch

Le widget Switch (à ne pas confondre avec le mot clé Java minuscule, switch) est semblable à un widget
Button, à la différence qu'il a deux états possibles qui peuvent être lus et traités. Une utilisation évidente
du widget Switch serait d’afficher et de masquer quelque chose. Chaque fois que nous allons masquer/
afficher TextView, nous allons modifier la propriété Text sur Button pour indiquer clairement ce qui se
produirait si l'utilisateur cliquait de nouveau. Ce qui aurait pu être plus logique pour l'utilisateur et plus
simple pour nous, en tant que programmeurs, aurait été d'utiliser Switch, comme illustré dans la figure
suivante :

Le code suivant suppose que nous avons déjà un objet appelé mySwitch avec une référence à un objet
Switch dans la présentation. Nous pourrions afficher et masquer TextView. Pour écouter et répondre
aux clics, nous utilisons à nouveau une classe anonyme. Cette fois, cependant, nous utilisons la version
CompoundButton de OnCheckedChangedListener au lieu de RadioGroup. Nous devons substituer la
méthode onCheckedChanged, et cette méthode a un paramètre booléen, isChecked. La variable
isChecked est simplement false pour off et true pour on. Voici comment nous pourrions remplacer plus
intuitivement ce texte masquant / montrant du code:

[Link]( new [Link]() {

public void onCheckedChanged( CompoundButton buttonView, boolean isChecked) {
if(isChecked){
// Currently visible so hide it
[Link]([Link]);
}else{
// Currently hidden so show it
[Link](View. VISIBLE);
}
}
});

Si le code de la classe anonyme a toujours l’air un peu étrange, ne vous inquiétez pas, plus on en sait
plus on l’utilise. Et nous le ferons encore une fois maintenant quand nous regarderons CheckBox.

5- Checkbox

Nous avons utilisé CheckBox dans notre structure de formulaire au Chapitre 4, Conception de modèles.
Comme avec EditText, cependant, nous n’avons pas cherché à obtenir des données. Avec CheckBox,
nous détectons simplement son état (coché ou non coché) à un moment donné, peut-être lorsque le
bouton de soumission d'un formulaire est cliqué. Ce code suivant nous donne un aperçu de la façon dont
cela pourrait se produire, encore une fois, en utilisant une classe interne qui agit comme un auditeur:

[Link]( new [Link]()

{
public void onCheckedChanged( CompoundButton buttonView, boolean isChecked) {
if ([Link]()) {
// It's checked so do something
} else {
// It's not checked do something else
}
}

Page 35 sur 49
});

Dans le code précédent, nous supposons que myCheckBox a été déclaré et initialisé, puis nous utilisons
exactement le même type de classe anonyme que nous avons utilisé pour que Switch détecte et réponde
aux clics.

6- WebView

Ce widget peut être utilisé comme conteneur pour une application entière. Nous pouvons mettre le code
de pages Web complètes dans notre dossier res, puis manipuler ces pages en utilisant le langage
JavaScript de nos applications. Il est assez courant que la fonctionnalité d'une application entière soit
contenue dans des pages Web, de simplement la présenter par l'application Android, et peut-être
d'ajouter un peu de fonctionnalité supplémentaire via WebView. Les applications qui font cela ont
toutefois rarement le même niveau d’apparence professionnelle qu’une véritable application Android
native, car les fonctionnalités de l’interface utilisateur que vous étudiez dans ce cours sont bien plus
puissantes et flexibles que celles pouvant être atteintes via un site Web régulier. Nous pouvons
également utiliser WebView dans une application pour afficher une page Web à l'utilisateur, mais sans
avoir à quitter l'application pour ouvrir un navigateur Web. Ce code charge Google dans WebView:

WebView webView = (WebView) findViewById([Link]);

[Link]("[Link]

Comme d'habitude, le code Java précédent suppose que nous avons un widget WebView dans notre
XML de présentation avec sa propriété id définie sur webView. Lorsque nous utilisons ce widget, nous
devons informer l’utilisateur que l’application va accéder à Internet et lui demander sa permission au
moment de l’installation de l’application. Nous le faisons en ajoutant la ligne suivante au
[Link] file:

<uses-permission android:name="android. [Link]"></uses-

permission>

Nous ferons cela pour de vrai dans la prochaine mini application.

7- Date and Time

Les appareils Android ont généralement des horloges et des calendriers. Cependant, nous pouvons
vouloir montrer une horloge ou demander à l'utilisateur de choisir une date dans notre application. Dans
la palette, nous pouvons sélectionner toute une gamme de widgets de date et d’heure utiles. Les widgets
barrés sont obsolètes et ne sont généralement plus utilisés:

Dans notre prochaine application, nous utiliserons le widget TextClock pour vous montrer certaines de
ses fonctionnalités. Avec toutes ces nouvelles informations, faisons en sorte qu'une application utilise
les widgets Android plus profondément que ce que nous avons jusqu'à présent.

III- Une application mettant en pratique l’utilisation des widgets

Nous venons de parler de sept widgets. Les widgets EditText, ImageView, RadioButton (et
RadioGroup), Switch, CheckBox, WebView et TextClock. Faisons une mini application et faisons
quelque chose de réel avec chacun d'eux. Nous allons aussi utiliser.

1- Création du projet d’exploration des widgets et des UI

Page 36 sur 49
Tout d'abord, nous allons configurer un nouveau projet et préparer la mise en page de l'interface
utilisateur. Ces étapes rapides obtiendront tous les widgets à l’écran et définiront les propriétés de
l’identifiant, prêtes à saisir une référence. Cela nous aidera à jeter un coup d'œil à l'application cible
(comme illustré dans la figure suivante), qui est opérationnelle et fonctionne avant de commencer:

Voici comment cette application va démontrer ces nouveaux widgets:

• Les boutons radio permettront à l’utilisateur de changer l’heure affichée sur l’horloge avec un
choix de trois fuseaux horaires
• Le bouton sur le côté gauche, lorsque vous cliquez dessus, changera son texte en ce qui est
actuellement dans le widget EditText
• Les trois cases à cocher ajouteront et supprimeront les effets visuels d’Android image robot
• L’interrupteur allume et éteint WebView, qui affiche des informations sur un éminent
informaticien

Les positions exactes de la mise en page ne sont pas essentielles, mais les propriétés id spécifiées doivent
correspondre exactement les unes aux autres.

1. Créez un nouveau projet appelé Exploration de widget, définissez l'API minimum sur 17,
utilisez une activité vide et conservez tous les autres paramètres à leurs valeurs par défaut.
Nous utilisons l'API 17, car l'une des fonctionnalités du widget TextClock nous oblige à le
faire.
2. Créons un nouveau fichier de présentation car nous souhaitons que notre nouvelle présentation
soit basée sur LinearLayout. Cliquez avec le bouton droit sur le dossier de présentation dans
l'explorateur de projet et sélectionnez Fichier de ressources de présentation sous Nouveau dans
le menu contextuel.
3. Dans la fenêtre Nouveau fichier de ressources, entrez exploration_layout.xml dans le champ
Nom du fichier et LinearLayout dans le champ Elément racine. Maintenant, cliquez sur OK.
4. Dans la fenêtre de propriétés, modifiez la propriété d'orientation de LinearLayout en
horizontale.
5. À l'aide des commandes déroulantes situées au-dessus de la vue Conception, assurez-vous que
Nexus 5 est sélectionné dans la vue Paysage.
6. Nous pouvons maintenant commencer à créer notre mise en page. Faites glisser et déposez
trois mises en page RelativeLayout sur la conception pour créer trois divisions verticales de
notre conception. Définissez la propriété weight de chaque disposition RelativeLayout sur .33.
Nous avons maintenant trois divisions verticales égales, comme dans la figure précédente.
7. Faites glisser Switch, puis WebView de la palette vers la droite de RelativeLayout. Le côté
droit de notre mise en page devrait maintenant ressembler à la figure précédente.

Page 37 sur 49
 8. Faites glisser trois widgets CheckBox, l'un au-dessus de l'autre, puis faites glisser ImageView
en dessous d'eux sur la présentation centrale RelativeLayout. La colonne centrale devrait
maintenant ressembler à celle de la figure précédente, à ceci près que nous ne pourrons voir
ImageView que lorsque nous aurons placé une valeur appropriée dans sa propriété src. Nous
le ferons dans quelques instants.
9. Faites glisser RadioGroup vers la gauche de RelativeLayout et ajoutez quatre widgets
RadioButton dans RadioGroup.
10. Sous RadioGroup, faites glisser un widget PlainText de la catégorie TextFields de la palette.
Ajoutez un widget Button à la droite du widget PlainText. Ajoutez TextClock de la palette à
la moitié inférieure gauche de RelativeLayout. Vous recevrez un avertissement concernant le
niveau de l'API. Nous pouvons l'ignorer, car nous l'exécuterons sur un émulateur Nexus 5 à
jour.
11. Sous le groupe radio, ajoutez un widget Grand texte. Vous allez maintenant avoir une mise en
page qui ressemble un peu à ceci

1. Essayez de modifier votre mise en page afin qu'elle ressemble le plus possible à l'image
précédente. Notez que ImageView est invisible jusqu'à ce que nous y ajoutions une image réelle.
2. Maintenant, ajoutez les propriétés suivantes, indiquées dans le tableau ci-dessous, aux widgets
que nous venons de présenter:

Page 38 sur 49
Nous venons d'aménager et de définir les propriétés requises pour notre mise en page. Nous n'avons
encore rien fait auparavant, si ce n'est que certains types de widgets sont nouveaux pour nous. Nous
pouvons maintenant utiliser tous ces widgets dans notre code Java.

2- Développement de l’application d’exploration des widgets

Comme nous avons WebView qui se connectera à Internet (pour afficher une page Web), nous avons
également besoin de la permission de l'utilisateur. Donc, nous devons ajouter une ligne au fichier
[Link]. Ouvrez-le à partir du dossier manifeste de l'explorateur de projet. Maintenant,
ajoutez la ligne de code suivante qui est en surbrillance à la position indiquée par le contexte de la ligne
en surbrillance:
...
<uses-permission android﹕name="[Link]" />
<application android:allowBackup="true"
...

Maintenant, assurons-nous que notre nouvelle présentation est affichée en modifiant l'appel de
setContentView dans onCreate afin qu'il ressemble à ceci:
setContentView([Link].exploration_layout);

Le bloc de code suivant semble assez long et étendu, mais tout ce que nous avons fait est d’obtenir une
référence à chacun des widgets de notre présentation. Quand nous en viendrons à les utiliser, nous

Page 39 sur 49
discuterons du code plus en détail. La seule nouveauté du bloc de code suivant est que certains objets
sont déclarés comme finaux. Cela est nécessaire car ils vont être utilisés dans une classe anonyme.

Entrez ce code juste après l'appel de setContentView dans la méthode onCreate:

// Get a reference to all our widgets

RadioGroup radioGroup = (RadioGroup) findViewById([Link]);

RadioButton rbBeijing = (RadioButton) findViewById
([Link]);
RadioButton rbLondon = (RadioButton) findViewById([Link]);
RadioButton rbnewYork = (RadioButton) findViewById
([Link]);
final EditText editText = (EditText) findViewById([Link]);
final Button button = (Button) findViewById([Link]);
final TextClock tClock = (TextClock) findViewById([Link]);
final CheckBox cbTransparency = (CheckBox) findViewById
([Link]);
final CheckBox cbTint = (CheckBox) findViewById([Link]);
final CheckBox cbReSize = (CheckBox) findViewById ([Link]);
final ImageView imageView = (ImageView) findViewById([Link]);
Switch switch1 = (Switch) findViewById([Link].switch1);
final WebView webView = (WebView) findViewById([Link]);

Nous pouvons maintenant créer une classe anonyme pour écouter et gérer les clics sur les cases à cocher.
Chacun des trois blocs de code suivants implémente une classe anonyme pour chacune des cases à
cocher. Ce qui est différent dans chacun de ces trois blocs cependant, est la façon dont nous répondons
à un clic, et nous discuterons de chacun d’eux. La première case à cocher est intitulée Transparence et
nous utilisons la méthode setAlpha sur imageView pour modifier son degré de transparence
(transparent). La méthode setAlpha prend comme argument une valeur en virgule flottante comprise
entre 0 et 1. Ici, 0 est invisible et 1 n'est pas du tout transparent. Ainsi, lorsque cette case à cocher est
cochée, nous définissons l'alpha sur .1, de sorte que l'image est à peine visible, et lorsqu'elle n'est pas
cochée, nous la configurons sur 1, qui est complètement visible sans transparence. Le paramètre
isChecked booléen de onCheckedChanged contient la valeur true ou false si la case à cocher est cochée
ou non. Ajouter ce code après le bloc de code précédent dans onCreate

Now we can create an anonymous class to listen for and handle clicks on the checkboxes. Each of the
next three blocks of code implement an anonymous class for each of the checkboxes in turn. What is
different in each of the next three blocks of code, however, is the way in which we respond to a click,
and we will discuss each of them in turn. The first checkbox is labeled Transparency, and we use the
setAlpha method on imageView to change how transparent (see-through) it is. The setAlpha method takes
a floating point value between 0 and 1 as an argument. Here, 0 is invisible and 1 is no transparency at
all. So, when this checkbox is checked, we set the alpha to .1, so the image is barely visible, and when
it is unchecked, we set it to 1, which is completely visible with no transparency. The boolean isChecked
parameter of onCheckedChanged contains true or false as to whether the checkbox is checked or not. Add
this code after the previous block of code in onCreate:

[Link](new
[Link](){
public void onCheckedChanged(CompoundButton buttonView,boolean
isChecked) {
if([Link]()){

Page 40 sur 49
 [Link](.1f);
}else{
[Link](1f);
}
}
});

Dans la classe anonyme suivante, nous gérons la case à cocher intitulée Tint. Dans la méthode
onCheckedChanged, nous utilisons la méthode setColorFilter sur imageView pour superposer un calque
de couleur sur l'image. Lorsque isChecked est vrai, nous superposons une couleur et lorsque isChecked
est faux, nous la supprimons. La méthode setColorFilter prend comme argument une couleur au format
alpha, rouge, vert et bleu (ARGB). La couleur est fournie par la méthode statique argb de la classe Color.
Les quatre arguments de la méthode argb sont, comme on pouvait s'y attendre, des valeurs pour alpha,
rouge, vert et bleu. Ces quatre valeurs créent une couleur. Dans notre cas, les valeurs 150, 255, 0, 0
créent une forte teinte rouge. Et les valeurs 0, 0, 0, 0 ne créent aucune teinte.

Ajouter ce code après le bloc de code précédent dans onCreate:

[Link](new
[Link]() {
public void onCheckedChanged(CompoundButton buttonView, boolean
isChecked) {
if ([Link]()) {
[Link]([Link](150, 255, 0, 0));
} else {
[Link]([Link](0, 0, 0, 0));
}
}
});

Dans la classe anonyme qui gère la case à cocher Redimensionner avec libellé, nous utilisons la méthode
setScaleX pour redimensionner l'image du robot. Lorsque nous appelons setScaleX (2) et setScaleY (2)
sur imageView, nous doublons la taille de l'image, et setScaleX (1) et setScaleY (1) la retournent à la
normale. Ajouter ce code après le bloc de code précédent dans onCreate:

// And the last check box

[Link](new
[Link]() {
public void onCheckedChanged(CompoundButton buttonView,boolean
isChecked) {
if ([Link]()) {
[Link](2);
[Link](2);
} else {
[Link](1);
[Link](1);
}
}
});

Nous allons maintenant gérer les trois boutons radio. Comme ils font partie de RadioGroup, nous
pouvons les manipuler beaucoup plus succinctement que les objets CheckBox. Voici comment nous le
faisons.

Page 41 sur 49
Tout d’abord, nous nous assurons qu’ils sont libres de commencer en appelant clearCheck () sur
radioGroup. Ensuite, nous créons notre classe anonyme du type OnCheckedChangedListener et
substituons la méthode onCheckedChanged. Cette méthode sera appelée lorsque vous cliquerez sur un
bouton radio de RadioGroup. Tout ce que nous avons à faire est d’obtenir l’identifiant du widget
RadioButton sur lequel vous avez cliqué et répondez en utilisant une instruction switch avec les trois
cas possibles, un pour chaque widget RadioButton.

Rappelez-vous lorsque nous avons parlé pour la première fois de RadioButton que l'ID fourni dans le
paramètre ID vérifié de onCheckedChanged est int? C'est pourquoi nous devons d'abord créer un nouvel
objet RadioButton à partir de ID vérifié: RadioButton rb = (RadioButton) [Link] (ID
vérifié); Ensuite, nous pouvons appeler getId sur le nouveau widget RadioButton en tant que condition
de switch: switch ([Link] ()). Dans chaque cas, nous utilisons la méthode setTimeZone avec le code
de fuseau horaire Android approprié comme argument.

Ajoutez ce code suivant qui intègre tout ce que nous venons de décrire et inclut les deux lignes de code
précédentes. Ajoutez-le dans onCreate après le dernier code que nous avons entré pour gérer les cases à
cocher:

// Now for the radio buttons

// Uncheck all buttons
[Link]();
[Link](new
[Link]() {
@Override
public void onCheckedChanged(RadioGroup group, int checkedId) {
RadioButton rb = (RadioButton) [Link]
(checkedId);
switch ([Link]()) {
case [Link]:
[Link]("Europe/London");
break;
case [Link]:
[Link]("CST6CDT");
break;
case [Link]:
[Link]("America/New_York");
}// End switch block
}
});

Il est temps de passer à quelque chose de nouveau. Dans ce bloc de code suivant, nous utilisons une
classe anonyme pour gérer les clics sur un bouton normal. Nous avons appelé [Link]
comme auparavant. Cette fois, toutefois, au lieu de passer comme argument, nous avons créé une toute
nouvelle classe de la vue. Type OnClickListener et onClick substitué comme argument, comme nous
l'avons fait avec nos autres classes anonymes.

Dans la méthode onClick, nous utilisons setText pour définir la propriété text sur le bouton et la méthode
getText de editText pour obtenir le texte actuellement présent dans le widget EditText. Ajouter ce code
après le bloc de code précédent dans onCreate:

Let's listen for clicks on our regular Button.

We can do this with an anonymous class as well.
*/
[Link](new [Link]() {

Page 42 sur 49
 @Override
public void onClick(View v) {
// We only handle one button
// So no switching required
[Link]([Link]());
}
});

Dans le bloc de code suivant, nous utilisons la méthode loadUrl pour charger une page Web dans
webView:

Ensuite, nous allons créer une autre classe anonyme pour écouter et gérer les modifications apportées à
notre widget Switch.

Lorsque la variable isChecked a la valeur true, nous affichons webView et, lorsque la valeur est false,
nous la masquons.

Ajouter ce code après le bloc de code précédent dans onCreate:

// Make the webview display a page

[Link]("[Link]
[Link]([Link]);
[Link](new
[Link]() {
public void onCheckedChanged(CompoundButton buttonView,boolean
isChecked) {
if(isChecked){
[Link]([Link]);
}else{
[Link]([Link]);
}
}
});

Maintenant, nous pouvons exécuter notre application et essayer toutes les fonctionnalités. Vous pouvez
faire pivoter les émulateurs Android en mode paysage en appuyant sur la combinaison de touches Ctrl
+ F11 sur PC ou sur Ctrl + fn + F11 sur Mac.

Essayez de vérifier les boutons radio pour voir le fuseau horaire changer sur l'horloge. Entrez différentes
valeurs dans EditText, puis cliquez sur le bouton pour le voir saisir le texte et l'afficher sur lui-même.

Modifiez l'aspect de l'image à l'aide de différentes combinaisons de cases à cocher cochées et non
cochées, puis masquez et affichez la page Web à l'aide du widget de commutation. Passons maintenant
à une autre manière d'améliorer considérablement nos interfaces utilisateur.

IV- Résumé

Dans ce chapitre, nous avons exploré une multitude de widgets, vu comment implémenter des widgets
dans du code Java sans aucune disposition XML, utilisé nos premières classes anonymes pour gérer les
clics sur un widget et mis toute notre nouvelle prouesse de widget dans une mini-application.

Page 43 sur 49
Dans le prochain chapitre, nous verrons un élément totalement nouveau de l'interface utilisateur que
nous ne pouvons pas simplement faire glisser et laisser tomber de la palette, mais nous aurons toujours
beaucoup d'aide de l'API Android. Nous allons également commencer notre plus importante application.

In this CHAPITRE, we explored a plethora of widgets, saw how to implement widgets in Java code
without any XML layout, used our first anonymous classes to handle clicks on a widget, and put all our
new widget prowess into a mini app.

Page 44 sur 49
CHAPITRE VII : Avoir un dialogue avec l'utilisateur

Dans ce chapitre, nous verrons comment présenter à un utilisateur une fenêtre de dialogue
contextuelle. Nous pouvons ensuite mettre tout ce que nous savons dans la première phase de notre
première application, Note To Self. Ce chapitre contient les éléments suivants pour vous:

• Comment implémenter une application simple avec une boîte de dialogue contextuelle
• Comment ajouter DialogFragments pour démarrer l’application Note To Self
• Comment implémenter des boîtes de dialogue plus complexes pour capturer les entrées de
l'utilisateur
I- Fenêtre du dialogue

Souvent, nous voudrons montrer certaines informations à l'utilisateur ou peut-être demander la

confirmation d'une action dans une fenêtre contextuelle. Ceci est appelé une fenêtre de dialogue. Si vous
parcourez rapidement la palette, vous serez peut-être surpris de ne voir aucune mention des dialogues.
Les dialogues dans Android sont plus avancés qu'un simple widget ou même une mise en page. Ce sont
des classes qui peuvent contenir leurs propres dispositions et widgets. Le meilleur moyen de créer une
fenêtre de dialogue dans Android consiste à utiliser la classe Fragment. Les fragments sont un sujet vaste
et vital dans Android. La création d'une boîte de dialogue contextuelle soignée avec laquelle l'utilisateur
peut interagir constitue toutefois une excellente introduction aux fragments, sans la moindre
complication.

II- L’application de démonstration du dialogue

Nous avons précédemment mentionné que le meilleur moyen de créer un dialogue dans Android est
avec la classe Fragment. Sous Android, il existe un autre moyen de créer des dialogues, un peu plus
simple peut-être. Le problème avec cette classe Dialog un peu plus simple est qu’elle n’est pas aussi
bien prise en charge dans le cycle de vie de l’activité. Il est même possible que Dialog bloque
accidentellement l'application. Si vous écriviez une application avec une disposition d'orientation fixe
nécessitant une simple boîte de dialogue contextuelle, on pourrait faire valoir que la classe Dialog plus
simple devrait être utilisée. Toutefois, dans la mesure où nous souhaitons créer des applications
professionnelles modernes dotées de fonctionnalités avancées, il sera avantageux d’ignorer cette classe.
Plus spécifiquement, nous utiliserons la classe DialogFragment. Pour démarrer le mini-projet, créez un
nouveau projet vierge dans Android Studio et appelez-le Dialog Demo. Créez une nouvelle classe en
cliquant avec le bouton droit sur le dossier portant le nom de votre package contenant le fichier
[Link]. Sélectionnez la classe Java sous Nouveau et nommez-la MyDialog. Cliquez sur OK
pour créer la classe. La première chose à faire est de changer la déclaration de classe afin d'étendre
DialogFragment. Lorsque vous aurez terminé, votre nouvelle classe ressemblera à ceci:
public class MyDialog extends DialogFragment {… }

Ajoutons maintenant un peu de code à cette classe et voyons ce qui se passe à chaque étape.

Premièrement, nous substituons la méthode onCreateDialog qui sera appelée lorsque nous montrerons
plus tard la fenêtre de dialogue via le code de MainActivity. Ensuite, dans la méthode onCreateDialog,
nous mettons la main sur une nouvelle classe. Nous déclarons et initialisons un objet du type
[Link] qui nécessite une référence à MainActivity qui est passée dans son constructeur.
Page 45 sur 49
C'est pourquoi nous utilisons getActivity() comme argument. La méthode getActivity fait partie de la
classe Fragment (et par conséquent, DialogFragment également) et renvoie une référence à l'activité qui
a créé DialogFragment. Dans ce cas, il s’agit de notre classe MainActivity. Ajoutez ce code pour que la
variable de référence du générateur soit prête à être utilisée, puis nous verrons ce que nous pouvons en
faire:

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
// Use the Builder class because this dialog has a simple UI
[Link] builder = new
[Link](getActivity());

Nous pouvons maintenant utiliser notre objet générateur pour effectuer le reste du travail. Il y a quelque
chose de légèrement étrange dans les trois prochains blocs de code. Si vous parcourez rapidement les
trois blocs suivants, vous remarquerez qu’il manque nettement de points-virgules; Cela indique que ces
trois blocs de code ne représentent en réalité qu'une ligne pour le compilateur. Ce qui se passe ici est
quelque chose que nous avons vu auparavant dans une situation moins prononcée. Lorsque nous créons
un message Toast et que nous ajoutons une méthode .show () à la fin de celui-ci, nous enchaînons, c'est-
à-dire que nous appelons plusieurs méthodes, en séquence, sur le même objet. Cela équivaut à écrire
plusieurs lignes de code. C'est juste plus clair et plus court de cette façon. Dans le premier des trois blocs
utilisant le chaînage, nous appelons [Link] qui définit le message principal que l'utilisateur
verra dans la boîte de dialogue. Notez également qu’il est bon d’avoir des commentaires entre les parties
des appels de méthodes chaînées, car ceux-ci sont entièrement ignorés par le compilateur. Ensuite, nous
ajoutons un bouton à notre boîte de dialogue avec la méthode .setPositiveButton, et le premier argument
définit le texte sur OK. Le deuxième argument est une classe anonyme [Link]
qui gère les clics sur le bouton. Remarque que nous n'allons ajouter aucun code à la méthode onClick.
Ajoutez ce code, sans aucun point-virgule, bien sûr:

// Dialog will have "Make a selection" as the title

[Link]("Make a selection")
// An OK button that does nothing
.setPositiveButton("OK", new
[Link]() {
public void onClick(DialogInterface dialog, int id) {
// Nothing happening here
}
})
Ensuite, nous appelons encore une autre méthode sur le même objet générateur. Cette fois, c'est la
méthode setNegativeButton. De nouveau, les deux arguments définissent Cancel comme texte du bouton
et une classe anonyme à l'écoute des clics. Pour les besoins de cette démo, nous ne prenons aucune
action dans la méthode onClick remplacée. Après l'appel à setNegativeButton, nous voyons enfin un
point-virgule marquant la fin de la ligne de code. Nous renvoyons ensuite le code [Link] (). Cela
a pour effet de retourner à MainActivity (qui a d’abord appelé onDialogCreate), qui est notre nouvelle
fenêtre de dialogue entièrement configurée. Nous verrons ce code d'appel très bientôt. Ajoutez le code
suivant directement après le bloc de code précédent et dans la méthode onCreateDialog:

// A "Cancel" button that does nothing

.setNegativeButton("Cancel", new
[Link]() {
public void onClick(DialogInterface dialog, int id) {
// Nothing happening here either
}
});
// Create the object and return it

Page 46 sur 49
 return [Link]();
}// End onCreateDialog
Nous avons maintenant notre classe MyDialog qui étend FragmentDialog; Tout ce que nous avons à
faire pour cela est de déclarer un objet de MyDialog, de l'instancier et d'appeler sa méthode createDialog.

Ajoutons un bouton à notre mise en page. Accédez à l'onglet layout_main.xml, puis passez à l'onglet
Conception. Faites glisser un bouton sur la présentation et assurez-vous que sa propriété id est définie
sur button.

Maintenant, allez dans l'onglet MainActivity, et nous allons gérer un clic sur ce bouton en utilisant une
classe anonyme. Comme nous n’avons qu’un bouton dans la disposition, il semble judicieux de procéder
ainsi. Ajoutez ce code à la méthode onCreate. Juste avant, notez également que la seule chose qui se
passe dans le code est que la méthode onClick crée une nouvelle instance de MyDialog et appelle sa
méthode show qui, sans surprise, affichera notre fenêtre de dialogue telle que nous l'avons configurée
dans la classe MyDialog. . La méthode show nécessite une référence à FragmentManager (que nous
obtenons avec getFragmentManager); c'est la classe qui suit et contrôle toutes les instances de fragment
pour une activité. Nous transmettons également une pièce d'identité (nous transmettons 123) :

/*
Let's listen for clicks on our regular Button.
We can do this with an anonymous class.
*/
Button button = (Button) findViewById([Link]);
[Link](
new [Link]() {
@Override
public void onClick(View v) {
// We only handle one button
// So no switching required
MyDialog myDialog = new MyDialog();
[Link](getFragmentManager(), "123");
// This calls onCreateDialog
// Don't worry about the strange looking 123
// We will find out about this in CHAPITRE 18
}
}
);
}

Maintenant, nous pouvons exécuter l'application et admirer notre nouvelle fenêtre de dialogue qui
apparaît lorsque nous cliquons sur le bouton dans la présentation principale. Notez que cliquer sur l'un
des boutons de la fenêtre de dialogue le fermera. Ceci est le comportement par défaut. Cette capture
d'écran suivante montre notre fenêtre de dialogue en action:

Page 47 sur 49
Page 48 sur 49
CHAPITRE VIII : Introduction au développement d’applications mobiles multi-
plateforme
I- Introduction
II- La plateforme IONIC
III- La plateforme WINDEV MOBILE
IV- Projets

References:
1) [Link] Visited on 27/03/2018
2) [Link] , Visited on 30/06/19
3) [Link] , Visited on 30/06/19
4) Android Programming for Beginners, PACKT Publishing, Birmingham-Mumbai, ISBN 978-1-
78588-326-2
5) [Link] Visited on 27/03/2018
6) Leszek Wiland and Suman Banerjee. Introduction to Mobile Phone Programming in Java Me,
prepared for CS/ECE, UW-Madison ([Link]

Page 49 sur 49