Ecole Centrale Polytechnique d'Ingénieurs

Table des matières

INTRODUCTION ....................................................................................................................................... 3
APPROCHE TECHNIQUE :......................................................................................................................... 3
A) Environnement de développement d’applications mobiles ........................................................ 3
1) Côté serveur : ............................................................................................................................... 3
Installation et configuration des outils.............................................................................................. 4
2) Côté Client (Smartphonre) ......................................................................................................... 17
B) Création de projet ...................................................................................................................... 18
C) Exécution/Compilation .............................................................................................................. 23
Lancement sur émulateur ............................................................................................................. 23
D) Connexion client ......................................................................................................................... 35
La vue d’ensemble de la structure de projet Android .................................................................. 43
[Link] ................................................................................................................... 44
res/mipmap .................................................................................................................................. 45
Le Cycle de vie de l'Android Activity ..................................................................................... 47
Comment fonctionne l'application Android?........................................................................ 55
Le principe de fonctionnement:............................................................................................ 58
Qu'est-ce qui rend l'interface d'utilisateur? ......................................................................... 59
E) Création de bases de données .................................................................................................. 63
Qu'est ce que SQLite? ........................................................................................................... 63
Les contenus de cet exemple ................................................................................................ 64
➔ Les étapes pour travailler avec la base de données SQLite .................................................... 68
➔ Créer un projet et concevoir l'interface .................................................................................. 68
[Link] ................................................................................................................................. 69
activity_main.xml ............................................................................................................................. 72
[Link] ........................................................................................................................................ 74
list_row.xml ...................................................................................................................................... 75
[Link] ............................................................................................................................. 76
Ecole Centrale Polytechnique d'Ingénieurs
[Link]........................................................................................................................... 77
 Ecole Centrale Polytechnique d'Ingénieurs

INTRODUCTION

Le développement Android est basé sur le langage Java, un langage objet facile à apprendre et qui
vous permettra en quelques semaines de publier votre application Android sur le Google Play Store.
Sachez aussi qu'il existe de nombreux outils permettant de développer avec d'autres langages.

APPROCHE TECHNIQUE :

A) Environnement de développement d’applications mobiles

Prérequis : pour suivre ce cours, vous devez connaître les fondamentaux du langage Java.

1) Côté serveur :
Nous allons installer un environnement de développement nous permettant de créer nos
applications.
Besoin pour tout le monde

● 2 Go de mémoire RAM, mais on ne va pas se cacher qu'en dessous de 8 Go vous risquez

d'être limité.
● Plus de 1,5 Go d'espace disque pour tout installer.
● Niveau processeur, l'émulation ne peut se faire que sur 1 cœur de votre processeur, donc
augmenter le nombre de cœurs ne vous servira pas à grand-chose. C'est vraiment la
puissance pure qui compte. Il n'y a donc pas de minima mais le plus rapide sera le mieux.

❖ Pour Windows

Vous aurez besoin d'avoir Windows Vista ou plus récent.

❖ Pour Mac OS

Il vous faudra Mac OS 10.8.5 ou plus récent.

Ecole Centrale Polytechnique d'Ingénieurs
❖ Pour Linux

En ce qui concerne GNU/Linux, Google conseille d'utiliser une distribution Ubuntu plus récente que
la 14.04. Votre bureau devra fonctionner grâce à GNOME ou KDE. Enfin de manière générale,
n'importe quelle distribution convient à partir du moment que votre bibliothèque GNU C (glibc) est
au moins à la version 2.15. Si vous avez une distribution 64 bits, elle devra être capable de lancer des
applications 32 bits.

Tout ce que nous présenterons sera dans un environnement Windows 10.

Installation et configuration des outils

❏ Le Java Development Kit
● Téléchargement:

En tant que développeur Java vous avez certainement déjà installé le JDK (pour « Java Development
Kit »), mais je vais quand même décrire la procédure pour l’installer, si ce n’est pas encore faite

Rendez-vous ici et cliquez sur Download en dessous de JDK :

Choisissez ensuite la version adaptée à votre configuration.

On vous demande ensuite d'accepter (Accept License Agreement) avant de continuer.

Ecole Centrale Polytechnique d'Ingénieurs

Une fois le téléchargement terminé, vous pouvez installer le tout là où vous le désirez.

● Installation:

Double cliquez sur le fichier téléchargé. L’assistant d’installation du JDK se lance, poursuit les étapes
proposées jusqu’à accéder à la dernière page succès.

● Rappel:

Un petit rappel technique ne fait de mal à personne. Il existe deux plateformes en Java :

★ Le JRE (Java Runtime Environment), qui contient la JVM (Java Virtual Machine, rappelez-
vous, les bibliothèques de base du langage ainsi que tous les composants nécessaires au
lancement d'applications ou d'applets Java. En gros, c'est l'ensemble d'outils qui vous
permettra d’exécuter des applications Java.
★ Le JDK (Java Development Kit), qui contient le JRE (afin d’exécuter les applications Java),
mais aussi un ensemble d'outils pour compiler et déboguer votre code ! Vous trouverez un
peu plus de détails sur la compilation dans l'annexe sur l'architecture d'Android.

❏ Android studio

On va maintenant télécharger un fichier qui contient un ensemble d'outils indispensables pour

développer nos applications Android. Ce paquet contient Android Studio, un environnement de
développement spécialisé dans le développement d'applications Android, et un outil pour gérer
l'installation du SDK Android sur votre système (plus d'explications à ce sujet ci-dessous).

Pour se procurer ces outils, rendez-vous ici et cliquez sur Download Android Studio :
Ecole Centrale Polytechnique d'Ingénieurs

Pendant que le télécharge s'effectue, je vais répondre aux questions éventuelles que vous pourriez
avoir :

● C'est quoi un environnement de développement ?

Vous connaissez peut-être plutôt le mot IDE. Un IDE est un logiciel dont l'objectif est de faciliter le
développement. En d'autres termes, il vous est possible de développer sans un IDE, mais en utiliser
un est beaucoup plus pratique. En effet, il contient un certain nombre d'outils, dont au moins un
éditeur de texte - souvent étendu pour avoir des fonctionnalités avancées telles que l'auto-
complétion ou la génération automatique de code - des outils de compilation et un débogueur. Dans
le cas du développement Android, un IDE est très pratique pour ceux qui souhaitent ne pas avoir à
utiliser les lignes de commande.

● C'est quoi un SDK ?

Les applications Android sont développées en Java, mais un appareil sous Android ne comprend pas
le Java tel quel, il comprend une variante du Java adaptée pour Android. Un SDK, un kit de
développement dans notre langue, est un ensemble d'outils permettant de développer pour une
cible particulière. Par exemple, pour développer une console de jeu vidéo, on utilise un SDK
spécifique pour développer des applications pour cette console. Le SDK Android est donc un
ensemble d'outils que met à disposition Google afin de vous permettre de développer des
applications pour Android.
Ecole Centrale Polytechnique d'Ingénieurs
Une fois le téléchargement terminé, lancez l'installation. Pendant l'installation, vous devrez
répondre à certaines questions :

Sur cet écran, conservez les options Android SDK et Android Virtual Device, mais ne sélectionnez
Performance (Intel® HAXM) que si vous avez un processeur Intel capable d'émulation (comme
expliqué juste avant). Cliquez sur Next.
Ecole Centrale Polytechnique d'Ingénieurs

Dans cet écran, indiquez où vous souhaitez que Android Studio et le SDK soient installés, puis
cliquez sur Next:
Ecole Centrale Polytechnique d'Ingénieurs

Si votre ordinateur est suffisamment puissant, cet écran vous propose d'indiquer quelle quantité de
mémoire vive (RAM) vous souhaitez accorder à l'émulateur Android. La valeur par défaut est 2 Go
mais vous pouvez indiquer une valeur en choisissant Custom. Une fois votre sélection faite, cliquez
sur Next.

Une fois l'installation terminée, lancez Android Studio.

Sous Windows, cette fenêtre apparaîtra :

Ecole Centrale Polytechnique d'Ingénieurs

Elle vous demande si vous autorisez Android Studio à se connecter à Internet. Cliquez sur Autoriser
l’accès.

Au premier lancement, une boîte de dialogue va s'afficher et vous demander si vous aviez déjà une
version d'Android Studio installée précédemment. Si ce n'est pas le cas, sélectionnez la seconde
option :
Ecole Centrale Polytechnique d'Ingénieurs

Une fenêtre s'ouvrira pour vous demander ce que vous souhaitez faire. On va commencer par lui
demander de télécharger le SDK d'Android. Pour cela, cliquez sur Configure :
Ecole Centrale Polytechnique d'Ingénieurs

Cliquez ensuite sur SDK Manager :

Ecole Centrale Polytechnique d'Ingénieurs

Le Android SDK Manager s'ouvre et vous tomberez sur un écran similaire à celui-ci :
Ecole Centrale Polytechnique d'Ingénieurs

Dans ce tableau, vous trouverez deux types de lignes :

● Celles dont l'icône n'est pas un répertoire (une clé anglaise, un erlenmeyer, un petit
Bugdroid, ...) correspondent à des paquets, c'est-à-dire des fichiers qui seront téléchargés
pour ajouter de nouvelles fonctionnalités au SDK d'Android. A chaque ligne est associé un
statut à l'aide de la colonne Status. Par exemple, vous pouvez voir que le paquet Android
SDK Tools est déjà installé (Installed). En revanche, Documentation for Android SDK n'est pas
installé (Not installed). Chez moi, Android SDK Platform-tools est installé, mais n'est pas à
jour, l'Android SDK Manager me l'indique avec le status Update available. Il se peut qu'on
trouve plusieurs fois des paquets avec le même nom, dans ce cas c'est qu'il s'agit de versions
différentes du même paquet, comme vous pouvez le voir dans la colonne Rev. : on trouve la
version 19.1 d'Android SDK Platform-tools mais aussi la version 17 par exemple. On essayera
toujours d'avoir la dernière version de la plateforme.
Ecole Centrale Polytechnique d'Ingénieurs
● Les lignes dont l'icône est un répertoire représentent des groupes de paquets, qui
appartiennent tous à une même catégories. On trouve la catégories des outils (Tools) par
exemple. Regardez le nom des autres groupes, vous remarquerez que certains suivent un
certain motif. Il est écrit à chaque fois Android [un nombre] (API [un autre nombre]). La
présence de ces nombres s'explique par le fait qu'il existe plusieurs versions de la plateforme
Android qui ont été développées depuis ses débuts et qu'il existe donc plusieurs versions
différentes en circulation. Le premier nombre correspond à la version d'Android et le second
à la version de l'API Android associée.

Quand on développe une application, il faut prendre en compte ces numéros, puisqu'une application
développée pour une version précise d'Android fonctionnera sur les versions suivantes d'Android
mais pas sur les versions précédentes. A des fins pédagogiques, j'ai choisi de travailler avec une
version assez récente d'Android pour vous présenter toutes les possibilités de développement. Mais
dans vos développements réels, il vous faudra bien réfléchir à quelle version viser, en fonction du
public visé et de ce que vous aurez besoin dans les API d'Android.

NB: A l'heure actuelle, il semble sage de délaisser les versions précédant la version 4.0.3 (l'API 15).
Vous penserez peut-être qu'il est injuste de laisser de côté les personnes qui utilisent encore les
anciennes versions, mais sachez qu'ils ne représentent que 10% du parc mondial des utilisateurs
d'Android.

Pour choisir les fichiers nécessaires pour suivre ce cours, il vous suffit de sélectionner les éléments
suivants :
Ecole Centrale Polytechnique d'Ingénieurs

Puis cliquez sur Install xx packages... en bas de la page:

Ecole Centrale Polytechnique d'Ingénieurs

Il vous faudra ensuite valider les licences pour les fichiers que vous allez télécharger :

Si vous installez tous ces paquets, vous aurez besoin de 1 Go sur le disque de destination.

2) Côté Client (Smartphonre)

Il n’y a rien à installer comme outils. il nous faut juste un smartphone android
Ecole Centrale Polytechnique d'Ingénieurs

B) Création de projet
Ouvrez à nouveau Android Studio si vous l'avez fermé. Cliquez sur New --> New Project... pour
ouvrir l'assistant de création de projet.

Une nouvelle fenêtre s'ouvrira. Elle contient trois champs, comme vous pourrez le voir ici :
Ecole Centrale Polytechnique d'Ingénieurs

Voici à quoi servent ces trois champs :

● Application Name : il s'agit du nom qui apparaîtra sur l'appareil et sur Google Play !
Choisissez donc un nom judicieux.
● Company Domain : on se base sur le nom de domaine de son entreprise pour constituer ce
champ, c'est pourquoi il commence par [Link] chez moi (mais comme vous
ne travaillez pas chez OpenClassrooms il vous faudra utiliser un autre nom ). Mais à quoi
sert ce champ ? Il permet à Android Studio de déduire automatiquement un Package Name.
Et qu'est-ce qu'un Package Name ? C'est une chaîne de caractères qui sera utilisée pour
déterminer dans quel package se trouvera votre projet. Sachez que ce package agira comme
une sorte d'identifiant pour votre application sur le marché d'applications, alors faites en
sorte qu'il soit unique. De plus, il ne pourra pas être changé une fois votre application
publiée.
Vous pouvez si vous le voulez changer directement le Package Name en cliquant sur Edit.

Pour rappel, un package est un répertoire (physique ou virtuel) qui permet d'organiser notre code
source. Vous pouvez les considérer comme des récipients dans lesquels nous allons mettre nos
classes de façon à pouvoir trier votre code et différencier des classes qui auraient le même nom.
Concrètement, supposez que vous ayez à créer deux classes X — qui auraient deux utilisations
Ecole Centrale Polytechnique d'Ingénieurs
différentes, bien sûr. Vous vous rendez bien compte que vous seriez dans l'incapacité totale de
différencier les deux classes si vous deviez instancier un objet de l'une des deux classes X, et Java
vous houspillera en déclarant qu'il ne peut pas savoir à quelle classe vous faites référence. C'est
exactement comme avoir deux fichiers avec le même nom et la même extension dans un même
répertoire : c'est impossible car c'est incohérent.

Pour contrer ce type de désagrément, on organise les classes à l'aide d'une hiérarchie. Si je
reprends mon exemple des deux classes X , je peux les placer dans deux packages différents Y et Z
par exemple, de façon à ce que vous puissiez préciser dans quel package se trouve la classe X
sollicitée. On utilisera la syntaxe Y. X pour la classe X qui se trouve dans le package Y et Z. X pour
la classe X qui se trouve dans le package Z . Dans le cas un peu farfelu du code source d'un
navigateur internet, on pourrait trouver les [Link] ,[Link]
[Link] .

● Project Location : indiquez ici l'emplacement où les fichiers de votre projet seront créés.

Cliquez sur Next pour passer à l'écran suivant.

Ecole Centrale Polytechnique d'Ingénieurs
Cet écran vous permet de sélectionner le matériel de destination de votre application, ainsi que la
version d'Android minimum que doit utiliser ce matériel. Sélectionnez la version la plus récente.

Une fois votre sélection faites, cliquez sur Next.

Ici, on sélectionne déjà le type d'interface graphique qu'on voudra pour le premier écran de notre
application. Pour l'instant sélectionnez Blank Activity et cliquez sur Next.
Ecole Centrale Polytechnique d'Ingénieurs

Encore une fois, ces informations prendront tout leur sens dans la prochaine partie du cours. Cliquez
juste sur Finish.
Ecole Centrale Polytechnique d'Ingénieurs

C) Exécution/Compilation
Pour exécuter l’application, nous avons 2 possibilités:
● lancement sur émulateur
● lancement sur téléphone android (Smartphone)

Lancement sur émulateur

Assurez-vous d'avoir installé un appareil virtuel (un téléphone émulateur), qui est nécessaire pour
déployer votre application.

Lorsque vous installez Android Studio, il y a un choix d'installer le périphérique de simulation

virtuelle ( Android Virtual Device ou également reconnu comme Android Emulator), dans le cas où
vous ne l'installez pas, vous pouvez le faire plus tard.
Ecole Centrale Polytechnique d'Ingénieurs

Dans Android Studio sélectionnez :

● Tools/AVD Manager
Ecole Centrale Polytechnique d'Ingénieurs

Ici je crée un périphérique de simulation virtuelle Nexus 5 (4.95") - Ceci est un appareil
téléphonique populaire.
Ecole Centrale Polytechnique d'Ingénieurs
Ecole Centrale Polytechnique d'Ingénieurs
Ecole Centrale Polytechnique d'Ingénieurs
Ecole Centrale Polytechnique d'Ingénieurs
Ecole Centrale Polytechnique d'Ingénieurs
Ecole Centrale Polytechnique d'Ingénieurs
Ecole Centrale Polytechnique d'Ingénieurs
Une fois la création terminée, lancé l’exécution de l’application

La simulation d'écran a montré le téléphone, et écrit les mots "Hello World".

Ecole Centrale Polytechnique d'Ingénieurs
Ecole Centrale Polytechnique d'Ingénieurs

Si l'erreur d'exécution (ou le périphérique simulé ne s'ouvre pas), ou si vous voyez le message ci-
dessous, cela signifie que vous n'avez pas installé Intel Emulator Accelerator, vous devez l'installer.
Ecole Centrale Polytechnique d'Ingénieurs
Vous devez installer le logiciel de gestion de l'accélération le matériel de Intel.
❖ Lancement sur téléphone

Pour les utilisateurs de Windows

Tout d'abord, vous devez télécharger les drivers adaptés à votre terminal. Je peux vous donner la
marche à suivre pour certains terminaux, mais pas pour tous… En effet, chaque appareil a besoin de
drivers adaptés, et ce sera donc à vous de les télécharger, souvent sur le site du constructeur.
Cependant, il existe des pilotes génériques qui peuvent fonctionner sur certains appareils. En suivant
ma démarche, ils sont déjà téléchargés, mais rien n'assure qu'ils fonctionnent pour votre appareil.
En partant du répertoire où vous avez installé le SDK, on peut les trouver à cet emplacement
:\android-sdk\extras\google\usb_driver. Vous trouverez l'emplacement des pilotes à télécharger
pour toutes les marques dans le tableau qui se trouve sur cette page.

[Link]

Pour les utilisateurs de Mac

À la bonne heure, vous n'avez absolument rien à faire de spécial pour que tout fonctionne.

D) Connexion client
Maintenant que votre ordinateur peut reconnaître votre téléphone, on va faire en sorte que votre
téléphone puisse exécuter des applications que vous avez développé et exécuter un debugger. Pour
cela, allez dans les options.

En fonction de votre version d'Android, la manipulation pourrait être différente.

Dans les paramètres du téléphone, dirigez-vous vers le menu Sécurité :

Ecole Centrale Polytechnique d'Ingénieurs

C'est ici que vous pourrez activer les applications de sources inconnues en cliquant sur Sources
inconnues:
Ecole Centrale Polytechnique d'Ingénieurs

Retournez maintenant au menu des options. Attention ça va devenir un peu bizarre. Si vous ne voyez
pas l'option Options pour les développeurs, sélectionnez A propos du téléphone, le dernier élément
de la liste :
Ecole Centrale Polytechnique d'Ingénieurs

Naviguez tout en bas de cette page et appuyez sur Numéro de Build. Sept fois. C'est pas une blague,
appuyez sur ce bouton sept fois :
Ecole Centrale Polytechnique d'Ingénieurs

Félicitations ! Votre téléphone vous considère comme un développeur !

Retournez dans le menu précédent et une nouvelle option est apparue : Options pour les
développeurs. C'est votre prochaine destination :
Ecole Centrale Polytechnique d'Ingénieurs

Et enfin, dans ce menu, sélectionnez l'option Débogage USB et vous serez prêt :
Ecole Centrale Polytechnique d'Ingénieurs

Une fois la configuration terminée, retournons sur notre projet android et exécutons à nouveau
cette fois ci en branchant votre téléphone sur l’ordinateur afin de le détecter
De plus, il est possible que vous devez activer le paramètre de débogage USB général dans votre
périphérique. Si c'est le cas, votre périphérique doit afficher une boîte de dialogue vous demandant
d'autoriser le débogage USB :
Ecole Centrale Polytechnique d'Ingénieurs

Cliquez sur OK pour autoriser le débogage USB.

Exécutons à nouveau mais cette fois-ci en choisissant l’option terminal

et l’application se lance sur le téléphone.

Ecole Centrale Polytechnique d'Ingénieurs

La vue d’ensemble de la structure de projet Android

Voici est l'image de votre projet sur Android Studio:

Fichier ou Description
répertoire

AndroidManife C'est un fichier manifest qui décrit les caractéristiques fondamentales de

[Link] l'application et définit chacune de ses composantes.
Ecole Centrale Polytechnique d'Ingénieurs

java Cela contient les fichiers sources .java pour votre projet. Par défaut, il comprend
un fichier source [Link] ayant une classe d'activité (activity) qui
s'exécute lorsque votre application est lancée à l'aide de l'icône de l'application.

res/drawable La version antérieure d'Android a utilisé ce dossier pour stocker des images, la
version actuelle est remplacée par le dossier mipmap pour les images. Ce
répertoire n'est presque plus utilisé.

res/layout Il s'agit d'un répertoire pour les fichiers qui définissent l'interface d'utilisateur de
votre application.

res/menu Ce dossier comprend des fichiers XML définit des menu qui apparaîtront sur
Action Bar

res/mipmap Est utilisé pour contenir des images 'mipmap'.

res/values Il s'agit d'un répertoire pour les autres fichiers XML qui contiennent une
collection de ressources, telles que les définitions de chaînes (String) et de
couleurs.

[Link]

Quel que soit le composant que vous développez comme une partie de votre application, vous devez
déclarer tous ses composants dans un [Link]. Ce fichier fonctionne comme une
interface entre le système d'exploitation Android et votre application, donc, si vous ne déclarez pas
votre composant dans ce fichier, il ne sera pas considéré par le système d'exploitation. Par exemple,
un fichier de amanifest par défaut ressemblera à un fichier suivant
Ecole Centrale Polytechnique d'Ingénieurs

res/mipmap

Vous devez en savoir plus sur les images dans le dossier mipmap, voir l'image ci-dessous, il existe un
fichier image dans le dossier mipmap.
Ecole Centrale Polytechnique d'Ingénieurs

L'un des problèmes que j'ai occasionnellement rencontré lors de l'utilisation d'applications Android
est que je vois des images qui sont floues, pixelées ou étirées maladroitement. La solution à ce
problème est de créer un dossier déplaçable mipmap pour chacune des densités (density)
supportées par Android et de placer l'image correcte dans chaque dossier. Il existe 6 gammes de
densité différentes (mesurées en points par inch) compatibles avec Android:

1. ldpi: Des écrans à faible densité; Environ 120dpi

2. mdpi: Des écrans à moyenne densité (sur HVGA traditionnel); Environ 160dpi
3. hdpi: Des écrans à haute densité; Environ 240 ppp
4. xhdpi: Des écrans extra haute densité; Environ 320dpi. Ajouté en API Niveau 8
Ecole Centrale Polytechnique d'Ingénieurs

5. nodpi: Cela peut être utilisé pour les ressources bitmap que vous ne souhaitez pas minimiser
en fonction de la densité du périphérique
6. tvdpi: Des écrans quelque part entre mdpi et hdpi; Environ 213dpi. Ceci n'est pas considéré
comme un groupe de densité "primaire". Il est principalement destiné aux télévisions et la
plupart des applications ne devraient pas en avoir besoin. Les ressources mdpi et hdpi sont
suffisantes pour la plupart des applications et le système les modélisera selon les besoins. Ce
qualificatif a été introduit avec le niveau API 13

 Le Cycle de vie de l'Android Activity

Tout d'abord, qu'est-ce que Activity?

Activity est un code Java qui prend en charge un écran ou une interface d'utilisateur. En d'autres
termes, le bloc de construction de l'interface d'utilisateur est Activity. La classe Activity est une
classe prédéfinie dans Android et chaque application qui a UI doit l'hériter pour créer une fenêtre.

Par exemple, la classe MainActivity est un Activity qui étend provenant d'un Activity disponible
dans des bibliothèques Android. La figure ci-dessous illustre le cycle de vie d'un Activity.

Un cycle de vie de Activity décrit les processus d'un Activity depuis son lancement (Launched),
jusqu'à ce que les applications soient arrêtées. Y compris les processus dont Activity s'est arrêtée
temporairement, reprendre (resume), ..
Ecole Centrale Polytechnique d'Ingénieurs

Pour comprendre plus facilement, vous pouvez modifier le code de la classe MainActivity, remplacer
les méthodes onStart(), onResume(), .., Ajouter le message (message) qui démontre que la méthode
a été exécutée. Réexécutez l'application et voyez ce qui se passe dans le cycle de vie de Activity.
Ecole Centrale Polytechnique d'Ingénieurs
Ecole Centrale Polytechnique d'Ingénieurs

Réexécutez votre application, et vous voyez les message enregistrés sur la fenêtre du registre.
Ecole Centrale Polytechnique d'Ingénieurs

Vous pouvez configurer le filtre sur logcat uniquement pour afficher votre message.

Saisissez:

● Filter Name: My Filter

Ecole Centrale Polytechnique d'Ingénieurs

● Log Tag (regex): MyMessage

Maintenant, la fenêtre logcat n'affiche que votre message.

L'écran de votre téléphone:

Ecole Centrale Polytechnique d'Ingénieurs
Ecole Centrale Polytechnique d'Ingénieurs
Ecole Centrale Polytechnique d'Ingénieurs

 Comment fonctionne l'application Android?

Vous avez exécuté avec succès la première application Android, et maintenant nous allons regarder
comment Android a été exécuté depuis que l'application est appelée.

Ce que vous voyez sur la fenêtre Projet ne sont pas tous des composants impliqués, créant votre
application. Certains composants sont automatiquement générés par le programme de compilation.
Et il ne s'affiche pas dans la fenêtre Projet. Par exemple, en fonction de la structure des fichiers
sources de votre projet, le compilateur crée un fichier source [Link] qui définit des constantes pour
les ressources du projet.
Ecole Centrale Polytechnique d'Ingénieurs
Pour afficher le fichier [Link] sur Android Studio, ouvrez la classe MainActivity, cliquez avec le
bouton droit sur [Link].main_activity et sélectionnez Go To/Implementation(s)

Note: Android Studio> = 2.0 no longer allows you to view [Link] file, because this is an automatically
generated file and does not allow modifications.
Ecole Centrale Polytechnique d'Ingénieurs

Les constantes définies dans la classe [Link] sont créées correspondant aux ressources du Project:
Ecole Centrale Polytechnique d'Ingénieurs
Donc, quelque part dans le projet, vous pouvez utiliser les constantes pour référencer les ressources
dans le projet. Par exemple, [Link].activity_main est une constante qui renvoie le fichier
activity_main.xml dans le dossier res/layout.

 Le principe de fonctionnement:
Ecole Centrale Polytechnique d'Ingénieurs

 Qu'est-ce qui rend l'interface d'utilisateur?

Peut-être que vous pensez maintenant que activity_main.xml est le fichier qui crée une interface
d'application. C'est vrai 50%. Principalement, activity_main.xml est un fichier qui définit les entités
impliquées dans l'interface de l'application, et comment elles sont organisées sur l'écran. Activity lira
ce fichier et établira l'interface de l'application. Ainsi, l'interface des applications essentiellement
créée par Activity

Voici est le code Activity qui lit le fichier main_activity.xml pour créer l'interface.

Activity peut ne pas avoir besoin de lire le fichier xml pour créer l'interface de l'application:
Ecole Centrale Polytechnique d'Ingénieurs

Et réexécutez l'application:
Ecole Centrale Polytechnique d'Ingénieurs
Ecole Centrale Polytechnique d'Ingénieurs
La version actuelle de Android Studio ne vous soutient pas dans la conception d'une interface
intuitive sur Java. Cependant, il prend en charge efficacement dans la conception de l'interface
intuitive sur les fichiers xml, Android Studio générera le code XML pour vous. En fait, la conception
d'interface sur XML rendra vos applications plus faciles.

Retournez à activity_main.xml, vous pouvez facilement concevoir l'interface de l'application:

Le code XML est automatiquement généré:

Ecole Centrale Polytechnique d'Ingénieurs

E) Création de bases de données

 Qu'est ce que SQLite?

SQLite est une base de données relationnelle, source ouverte, elle est construite sur le système
d'exploitation Android, afin que vous puissiez l'utiliser à tout moment et sans autre configuration.
Ecole Centrale Polytechnique d'Ingénieurs

En général, avec des bases de données telles que Oracle, MySQL, ... vous avez besoin d'une
bibliothèque Driver et créez une connexion JDBC, mais avec SQLite, il n'est pas nécessaire.

 Les contenus de cet exemple

Supposons que vous créez une application qui fonctionne sur votre appareil Android, l'application
enregistre les notes de votre journée. Vous avez besoin d'une structure de table pour stocker les
notes.

● Le nom de la table: User

Column Name Data Type Constraint Description

User_Id int Primary Key Primary Key

User_Nom text Note title

User_Prenom text Content

Ecole Centrale Polytechnique d'Ingénieurs
Pour créer une table, il vous faudra réfléchir à son nom et à ses attributs. Chaque attribut sera défini
à l'aide d'un type de données. Ainsi, dans la table Metier de notre exemple, nous avons trois
attributs :

● ID, qui est un entier auto-incrémental pour représenter la clé ;

● Métier, qui est une chaîne de caractères ;
● Salaire, qui est un nombre réel.

Pour SQLite, c'est simple, il n'existe que cinq types de données :

● NULL pour les données NULL.

● INTEGER pour les entiers (sans virgule).
● REAL pour les nombres réels (avec virgule).
● TEXT pour les chaînes de caractères.
● BLOB pour les données brutes, par exemple si vous voulez mettre une image dans votre base
de données.

La création de table se fait avec une syntaxe très naturelle :

Pour chaque attribut, on doit déclarer au moins deux informations :

● Son nom, afin de pouvoir l'identifier ;

● Son type de donnée.

Mais il est aussi possible de déclarer des contraintes pour chaque attribut à l'emplacement de
{contraintes}. On trouve comme contraintes :

● PRIMARY KEY pour désigner la clé primaire sur un attribut ;

● NOT NULL pour indiquer que cet attribut ne peut valoir NULL ;
Ecole Centrale Polytechnique d'Ingénieurs
● CHECK afin de vérifier que la valeur de cet attribut est cohérente ;
● DEFAULT sert à préciser une valeur par défaut.

Il existe deux types de requêtes SQL. Celles qui appellent une réponse, comme la sélection, et celles
qui n'appellent pas de réponse. Afin d'exécuter une requête SQL pour laquelle on ne souhaite pas de
réponse ou on ignore la réponse, il suffit d'utiliser la méthode void execSQL(String sql). De manière
générale, on utilisera execSQL(String) dès qu'il ne s'agira pas de faire un SELECT, UPDATE, INSERT ou
DELETE.

❖ Créer une base de données et des tables à l'aide de SQLite Helper

Ecole Centrale Polytechnique d'Ingénieurs

Method Description

onCreate() Cette méthode n'est appelée qu'une seule fois dans l'application après la
création de la base de données et les instructions de création de table peuvent
être écrites dans cette méthode.

Cette méthode est appelée chaque fois qu'il y a une mise à jour dans la base de
onUpgrade() données comme la modification de la structure de la table, l'ajout de contraintes
à la base de données, etc.

❖ Insérer des données dans la base de données SQLite

❖ Lire les données de la base de données SQLite

❖ Mettre à jour les données dans la base de données SQLite

Ecole Centrale Polytechnique d'Ingénieurs

❖ Supprimer les données de la base de données SQLite

➔ Les étapes pour travailler avec la base de données SQLite

Vous devez créer une classe utilitaire pour travailler avec la base de données SQLite, cette classe
devrait s'étendre de la classe SQLiteOpenHelper. Il existe deux méthodes importantes dont vous
devez remplacer (override): onCreate() et onUpgrade().

1. Créez la classe MyDatabaseHelper s'étend à partir de SQLiteOpenHelper.

2. Après avoir étendu votre classe à partir de SQLiteOpenHelper vous devez outrepasser des
deux méthodes onCreate() et onUpgrage()
○ onCreate() - C'est là où vous devez écrire créer des instructions de table. C'est ce
qu'on appelle (called) lorsque la base de données est créée.
○ onUpgrade() - Cette méthode est appelée lors de la mise à niveau de la base de
données, comme la modification de la structure de la table, l'ajout de contraintes à
la base de données, etc.

F) Etude de cas

Implémenter les fonctions de crud simple (ajout, recherche, modifier, supprimer, afficher,
login)

➔ Créer un projet et concevoir l'interface

Créez un projet "Empty Activity" baptisé SQLiteDemo pour pratiquer cet exemple.
Ecole Centrale Polytechnique d'Ingénieurs

Une fois que nous avons créé une application, créez un fichier de classe [Link] dans \ java \
[Link] chemin pour implémenter les activités liées à la base de données SQLite.
Pour ce faire, clic droit sur votre dossier d'application sélectionner Classe Java et donner le nom
comme [Link].

Une fois que nous avons créé un nouveau fichier de classe [Link], ouvrez-le et écrivez le
code comme indiqué ci-dessous

[Link]

import [Link];
Ecole Centrale Polytechnique d'Ingénieurs
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

/**
* Created by Thiame on 08-15-2020.
*/

public class DbHandler extends SQLiteOpenHelper {

private static final int DB_VERSION = 1;
private static final String DB_NAME = "usersdb";
private static final String TABLE_Users = "userdetails";
private static final String KEY_ID = "id";
private static final String KEY_NAME = "name";
private static final String KEY_LOC = "location";
private static final String KEY_DESG = "designation";
public DbHandler(Context context){
super(context,DB_NAME, null, DB_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db){
String CREATE_TABLE = "CREATE TABLE " + TABLE_Users + "("
+ KEY_ID + " INTEGER PRIMARY KEY AUTOINCREMENT," + KEY_NAME + " TEXT,"
+ KEY_LOC + " TEXT,"
+ KEY_DESG + " TEXT"+ ")";
[Link](CREATE_TABLE);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion){
// Drop older table if exist
[Link]("DROP TABLE IF EXISTS " + TABLE_Users);
// Create tables again
onCreate(db);
}
Ecole Centrale Polytechnique d'Ingénieurs
// **** CRUD (Create, Read, Update, Delete) Operations ***** //

// Adding new User Details

void insertUserDetails(String name, String location, String designation){
//Get the Data Repository in write mode
SQLiteDatabase db = [Link]();
//Create a new map of values, where column names are the keys
ContentValues cValues = new ContentValues();
[Link](KEY_NAME, name);
[Link](KEY_LOC, location);
[Link](KEY_DESG, designation);
// Insert the new row, returning the primary key value of the new row
long newRowId = [Link](TABLE_Users,null, cValues);
[Link]();
}
// Get User Details
public ArrayList<HashMap<String, String>> GetUsers(){
SQLiteDatabase db = [Link]();
ArrayList<HashMap<String, String>> userList = new ArrayList<>();
String query = "SELECT name, location, designation FROM "+ TABLE_Users;
Cursor cursor = [Link](query,null);
while ([Link]()){
HashMap<String,String> user = new HashMap<>();
[Link]("name",[Link]([Link](KEY_NAME)));
[Link]("designation",[Link]([Link](KEY_DESG)));
[Link]("location",[Link]([Link](KEY_LOC)));
[Link](user);
}
return userList;
}
// Get User Details based on userid
public ArrayList<HashMap<String, String>> GetUserByUserId(int userid){
SQLiteDatabase db = [Link]();
ArrayList<HashMap<String, String>> userList = new ArrayList<>();
String query = "SELECT name, location, designation FROM "+ TABLE_Users;
Cursor cursor = [Link](TABLE_Users, new String[]{KEY_NAME, KEY_LOC, KEY_DESG},
KEY_ID+ "=?",new String[]{[Link](userid)},null, null, null, null);
Ecole Centrale Polytechnique d'Ingénieurs
if ([Link]()){
HashMap<String,String> user = new HashMap<>();
[Link]("name",[Link]([Link](KEY_NAME)));
[Link]("designation",[Link]([Link](KEY_DESG)));
[Link]("location",[Link]([Link](KEY_LOC)));
[Link](user);
}
return userList;
}
// Delete User Details
public void DeleteUser(int userid){
SQLiteDatabase db = [Link]();
[Link](TABLE_Users, KEY_ID+" = ?",new String[]{[Link](userid)});
[Link]();
}
// Update User Details
public int UpdateUserDetails(String location, String designation, int id){
SQLiteDatabase db = [Link]();
ContentValues cVals = new ContentValues();
[Link](KEY_LOC, location);
[Link](KEY_DESG, designation);
int count = [Link](TABLE_Users, cVals, KEY_ID+" = ?",new
String[]{[Link](id)});
return count;
}
}

Si vous observez le code ci-dessus, nous avons implémenté toutes les activités liées à la base de
données SQLite pour effectuer des opérations CRUD dans l'application Android.

Ouvrez maintenant le fichier activity_main.xml à partir du chemin du dossier \ res \ layout et

écrivez le code comme indiqué ci-dessous.

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>

Ecole Centrale Polytechnique d'Ingénieurs
<LinearLayout xmlns:android="[Link]
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:id="@+id/fstTxt"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="100dp"
android:layout_marginTop="150dp"
android:text="Name" />
<EditText
android:id="@+id/txtName"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="100dp"
android:ems="10"/>
<TextView
android:id="@+id/secTxt"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Location"
android:layout_marginLeft="100dp" />
<EditText
android:id="@+id/txtLocation"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="100dp"
android:ems="10" />
<TextView
android:id="@+id/thirdTxt"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Designation"
android:layout_marginLeft="100dp" />
<EditText
android:id="@+id/txtDesignation"
android:layout_width="wrap_content"
Ecole Centrale Polytechnique d'Ingénieurs
android:layout_height="wrap_content"
android:layout_marginLeft="100dp"
android:ems="10" />
<Button
android:id="@+id/btnSave"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="100dp"
android:text="Save" />
</LinearLayout>

Maintenant, nous allons créer un autre fichier de ressources de mise en page [Link] dans \ res
\layout pour afficher les détails dans la liste personnalisée de la base de données SQLite pour ce clic
droit layout aller à New sélectionner Layout Resource File et donner le nom comme details. xml.

Une fois que nous avons créé un nouveau fichier de ressources de mise en page [Link], ouvrez-
le et écrivez le code comme indiqué ci-dessous

[Link]

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="[Link]
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<ListView
android:id="@+id/user_list"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:dividerHeight="1dp" />
<Button
android:id="@+id/btnBack"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
Ecole Centrale Polytechnique d'Ingénieurs
android:layout_gravity="center"
android:layout_marginTop="20dp"
android:text="Back" />
</LinearLayout>

Créer un autre fichier layout (list_row.xml) dans le dossier /res/layout pour visualiser les données
dans une listview, pour cela clic droit sur dossier layout sélectionner Layout resource file et lui
donner le nom de list_row.xml et y écrire le code ci-dessous

list_row.xml

<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout xmlns:android="[Link]
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="horizontal"
android:padding="5dip" >
<TextView
android:id="@+id/name"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textStyle="bold"
android:textSize="17dp" />
<TextView
android:id="@+id/designation"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@id/name"
android:layout_marginTop="7dp"
android:textColor="#343434"
android:textSize="14dp" />
<TextView
android:id="@+id/location"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignBaseline="@+id/designation"
Ecole Centrale Polytechnique d'Ingénieurs
android:layout_alignBottom="@+id/designation"
android:layout_alignParentRight="true"
android:textColor="#343434"
android:textSize="14dp" />
</RelativeLayout>

Maintenant ouvrir le fichier [Link] depuis le chemin \java \[Link] et

écrire le code suivant

[Link]

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class MainActivity extends AppCompatActivity {

EditText name, loc, desig;
Button saveBtn;
Intent intent;
@Override
protected void onCreate(Bundle savedInstanceState) {
[Link](savedInstanceState);
setContentView([Link].activity_main);
name = (EditText)findViewById([Link]);
loc = (EditText)findViewById([Link]);
desig = (EditText)findViewById([Link]);
saveBtn = (Button)findViewById([Link]);
[Link](new [Link]() {
@Override
public void onClick(View v) {
String username = [Link]().toString()+"\n";
String location = [Link]().toString();
String designation = [Link]().toString();
Ecole Centrale Polytechnique d'Ingénieurs
DbHandler dbHandler = new DbHandler([Link]);
[Link](username,location,designation);
intent = new Intent([Link],[Link]);
startActivity(intent);
[Link](getApplicationContext(), "Details Inserted
Successfully",Toast.LENGTH_SHORT).show();
}
});
}
}

Si vous observez le code ci-dessus, nous prenons les détails de l'utilisateur saisis et les insérons dans
la base de données SQLite et nous redirigeons l'utilisateur vers une autre activité.
Maintenant, nous allons créer une autre activité [Link] depuis le package \java
\[Link].

Une fois que nous avons créé un nouveau fichier d'activité [Link], ouvrez-le et écrivez le
code comme indiqué ci-dessous.

[Link]

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

/**
* Created by Thiame on 08-15-2020.
*/
Ecole Centrale Polytechnique d'Ingénieurs

public class DetailsActivity extends AppCompatActivity {

Intent intent;
@Override
protected void onCreate(Bundle savedInstanceState) {
[Link](savedInstanceState);
setContentView([Link]);
DbHandler db = new DbHandler(this);
ArrayList<HashMap<String, String>> userList = [Link]();
ListView lv = (ListView) findViewById([Link].user_list);
ListAdapter adapter = new SimpleAdapter([Link], userList,
[Link].list_row,new String[]{"name","designation","location"}, new int[]{[Link],
[Link], [Link]});
[Link](adapter);
Button back = (Button)findViewById([Link]);
[Link](new [Link]() {
@Override
public void onClick(View v) {
intent = new Intent([Link],[Link]);
startActivity(intent);
}
});
}
}

Si vous observez le code ci-dessus, nous obtenons les détails de la base de données SQLite et les
lions à la liste Android. Nous devons maintenant ajouter cette activité nouvellement créée dans le
fichier [Link] comme indiqué ci-dessous.

[Link]
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="[Link]
package="[Link]">
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
Ecole Centrale Polytechnique d'Ingénieurs
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="[Link]" />
<category android:name="[Link]" />
</intent-filter>
</activity>
<activity android:name=".DetailsActivity" android:label="SQLite Example -
Details"></activity>
</application>
</manifest>

Si vous observez l'exemple ci-dessus, nous enregistrons les détails saisis dans la base de données
SQLite et redirigeons l'utilisateur vers un autre fichier d'activité ([Link]) pour afficher
les détails des utilisateurs et avons ajouté toutes les activités dans le fichier [Link].

Lorsque nous exécutons l'exemple ci-dessus dans l'émulateur Android, nous obtiendrons un résultat
comme indiqué ci-dessous.