Module (M17) :

Programmation mobile
Pr. Yassine SADQI

Department of Maths and Computer

Science
Laboratoire d’Innovation en
Mathématiques, Applications &
Technologies de l’Information (LIMATI)
y.sadqi@usms.ma
 Chapitre 6: Initiation aux
communications réseau sous
Android

Pr. Yassine SADQI 2

Plan

1. Introduction
2. Processus et Threads
3. AsyncTask
4. Communications réseau basées sur
HTTP

Pr. Yassine SADQI 3

I. Introduction

4
Introduction

• La grande majorité des applications Android sont

basées sur le modèle de communication
Client/Server (Client/Server).
• Dans ce modèle de communication, les
informations sont localisées sur des ordinateurs
ayant le rôle de serveur et accessible par les
ordinateurs client en utilisant un réseau local (LAN) Réseau
ou bien distant (WAN) .
o Client: Emetteur de requêtes vers le serveur en
sollicitant un service (ex: page web).
o Serveur: Ordinateur de grande capacité dédié
aux logiciels serveur, et ayant pour objectif de
répondre au requêtes client (ex: un serveur
Web)
Pr. Yassine SADQI 5
Introduction

• Les développeurs qui se chargent de la partie client

d’une application (Interface utilisateur et ergonomie)
sont connus en tant que développeurs front-end
(Front-end developer).
• Les développeurs qui se chargent de la partie serveur
d’une application (Aspect techniques et fonctionnelle:
base de données, configuration, maintenance du
serveur, ... ) sont connus en tant que développeurs back-
end
• Les développeurs qui se chargent de toute l’application (
client & serveur) sont connus en tant que développeurs
Full-stack.
• Une excellente application Android doit avoir un front- Front-end Back-end servers
end interactif et de puissantes fonctionnalités back-end.

Pr. Yassine SADQI 6

Introduction

https://www.clementine.jobs/
Pr. Yassine SADQI 7
Introduction

• Questions: Dans une application Android

o comment peut-on récupérer et afficher des données
distantes?
o comment peut-on interagir avec la partie back-end?
• Réponse: Sous Android les communications réseau doivent
se réaliser en utilisant des opérations ou bien traitement en
arrière-plan (Android background processing/operations)
• Il existe plusieurs façons d'effectuer le traitement en arrière-
plan sous Android:
o le traitement en arrière-plan directement à l'aide de la
classe AsyncTask.

Pr. Yassine SADQI 8

Introduction

ole traitement en arrière-plan indirectement, à l'aide du Framework

Loader, puis de la classe AsyncTaskLoader.
o…
• A bien noter: Les loader sont obsolètes depuis Android Pie 9.x (API
28). L'option recommandée pour gérer le chargement des données
lors de la gestion des cycles de vie Activité et Fragment consiste à
utiliser une combinaison de ViewModels et LiveData.
o https://developer.android.com/reference/androidx/lifecycle/ViewModel
o https://developer.android.com/reference/androidx/lifecycle/LiveData

Pr. Yassine SADQI 9

II. Procesus et
Threads

10
Notions de processus et de thread

• Un processus est une instance d'un

programme en cours d'exécution (les
instructions chargé en mémoire). Il
contient non seulement le code du
programme, mais aussi des variables
qui représentent son état courant.
• un thread (appelée aussi processus
léger) est un ensemble d’instruction à
exécuter à l'intérieur d'un processus.

Pr. Yassine SADQI 11

Pourquoi utiliser les threads?

• Les threads sont des exécutions que l'on

sépare de l'exécution principale
(processus) pour les raisons suivantes :
oTâches exigeantes (gros calculs,
gros traitements, etc)
oTâches bloquantes (ex:
communications réseau, …)
oTâches détachées (impression,
recherche, etc)

Pr. Yassine SADQI 12

Thread Vs Processus

• Un processus peut contenir un ou plusieurs threads.

• Les threads d’un même processus partage la même
mémoire virtuel.
• Chaque processus possède sa propre mémoire virtuel.
• Les threads d’un même processus communiquent
beaucoup plus facilement que deux processus.

Pr. Yassine SADQI 13

III. Les threads sous
Android

14
Main thread

• Lorsqu'une application Android démarre, elle crée le

thread principal « Main Thread », souvent appelé « UI
thread »
odessine l'interface utilisateur sur l'écran
orépond aux actions de l'utilisateur en gérant les
événements de l'interface utilisateur
• C’est dans ce thread que toutes les opérations
sont exécutées par défaut, les unes à la suite des
autres.
Pr. Yassine SADQI 15
Main thread

• Il faut noter que UI thread doit être rapide:

oAndroid mis à jour l’écran toutes les 16 millisecondes
oLe « UI thread » a 16 ms pour faire tout son travail
oSi cela prend trop de temps, l'application se bloque

Pr. Yassine SADQI 16

Main thread

• Si UI thread attend trop

longtemps pour qu'une
opération se termine, elle ne
répond plus
• Android affiche une boîte de
dialogue ANR (Application Not
Responding)

Les utilisateurs désinstallent les applications qui ne répondent

pas rapidement ou bien qui se bloquent souvent!!
Pr. Yassine SADQI 17
Qu'est-ce qu'une tâche de longue durée?

• Parmi les opérations ou tâches de longue durée :

o Opérations réseau
o Calculs longs
o Téléchargement / upload de fichiers
o Traitement des images
o …
• Question: Imaginez maintenant qu'une requête réseau (qui dure plus de
10 secondes) est lancée, donc par défaut dans le Main Thread, et
qu'avant la fin des 10 secondes, un utilisateur appuie sur un autre
bouton. Que va-t-il arriver ?

Pr. Yassine SADQI 18

Background threads

• Pour résoudre ce problème, nous allons appliquer dans notre développement les deux
règles suivantes :
1. Le Thread Principal (UI Thread) sera dédié aux opérations extrêmement courtes et dès
que nous souhaitons mettre à jour un élément de notre interface graphique (UI).
2. Nous créons des nouveaux Threads (Backgrounds threads / Worker threads) dès que l'on
veut effectuer des tâches longues, afin de ne jamais bloquer notre interface
graphique.
Main Thread (UI Thread)
Update UI

Worker Thread Do some work

Pr. Yassine SADQI 19

IV. AsyncTask

20
Tâche asynchrone Vs Tâche synchrone

• Tâche synchrone: Quand une tâche est exécutée

de manière synchrone, vous attendez la fin de
cette tâche avant de passer à une autre.
• Tâche asynchrone: Quand une tâche est
exécutée de manière asynchrone, vous pouvez
directement passer à une autre tâche avant
qu’elle ne soit terminée.
• Jusqu’à présent, nous avons effectué
uniquement des tâches synchrones, et celles-ci
s'exécutent les unes à la suite des autres.
• Dans le cas des tâches asynchrones, celles-
ci peuvent s'effectuer en parallèle !
A bien noter: Quant on réalise un traitement ou une opération longue dans une tâche
synchrone, nous allons faire freezer l’application.
Pr. Yassine SADQI 21
Qu'est-ce que AsyncTask?

• On utilise la classe abstraite « AsyncTask » pour implémenter les tâches d'arrière-

plan de base .
• AsyncTask permet aussi de publier les résultats sur le thread principal « thread
UI » sans manipuler les threads ou les handlers.
• Lorsque AsyncTask est exécuté, il passe par quatre étapes:
1) onPreExecute(),
2) doInBackground,
3) onProgressUpdate,
4) onPostExecute

Diagramme de l’ordre d'appel des méthodes AsyncTask

Pr. Yassine SADQI 22
Méthodes AsyncTask

1. OnPreExecute ()
o est appelé sur le thread UI avant que la tâche soit exécutée.
o cette étape est normalement utilisée pour configurer la tâche, par exemple en
affichant une barre de progression dans l'interface utilisateur.
2. doInBackground (Params ...)
o est appelée sur le thread d'arrière-plan immédiatement après la fin de
onPreExecute ().
o cette étape effectue un calcul en arrière-plan, renvoie un résultat et passe le
résultat à onPostExecute ().
o elle peut également appeler publishProgress (Progress ...) pour publier une ou
plusieurs unités de progression.

Pr. Yassine SADQI 23

Méthodes AsyncTask

3. onProgressUpdate (Progress ...)

o s'exécute sur le thread UI après que publishProgress (Progress ...) est appelé.
o Utiliser onProgressUpdate () pour signaler toute forme de progression au
thread UI pendant l'exécution du calcul en arrière-plan.
o Par exemple, vous pouvez l'utiliser pour transmettre les données afin d'animer
une barre de progression ou afficher des journaux dans un champ de texte.
4. OnPostExecute (Result) s'exécute sur le thread UI après que le calcul d'arrière-
plan a terminé. Le résultat du calcul en arrière-plan est passé à cette méthode
en tant que paramètre.
• Pour plus de détails sur ces méthodes, consulter la documentation de AsyncTask.

Pr. Yassine SADQI 24

Utilisation de la classe AsyncTask

• Pour utiliser la classe AsyncTask, on doit créer une classe qui hérite de la classe
AsyncTask et qui redéfinit la méthode doInBackground (Params ...), et généralement
aussi la méthode onPostExecute (Result).
• Dans la sous-classe crée de AsyncTask, on doit fournir les types de données pour trois
types de paramètres, ou « void » si le type de paramètre n'est pas utilisé:
AsyncTask <Params, progress, result> {}
o "Params" spécifie le type de paramètres passés à doInBackground ().
o "Progress" spécifie le type de paramètres transmis à publishProgress () sur le thread
d'arrière-plan. Ces paramètres sont ensuite transmis à la méthode onProgressUpdate
() sur le thread principal.
o "Result" spécifie le type de paramètre renvoyé par doInBackground (). Ce paramètre est
automatiquement transmis à onPostExecute () sur le thread principal.

Pr. Yassine SADQI 25

Exemple d'une AsyncTask
private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
protected Long doInBackground(URL... urls) {
int count = urls.length;
long totalSize = 0;
for (int i = 0; i < count; i++) {
totalSize += Downloader.downloadFile(urls[i]);
publishProgress((int) ((i / (float) count) * 100));
// Escape early if cancel() is called
if (isCancelled()) break;
}
return totalSize;
}
protected void onProgressUpdate(Integer... progress) {
setProgressPercent(progress[0]);
}

protected void onPostExecute(Long result) {

showDialog("Downloaded " + result + " bytes");
}
}
Pr. Yassine SADQI 26
Exemple d'une AsyncTask

• Dans cette exemple, DownloadFilesTask passe par trois des quatre étapes de
base AsyncTask:
1. doInBackground () télécharge du contenu. Il calcule le pourcentage de
fichiers téléchargés depuis l'index de la boucle for et le transmet à
publishProgress (). La vérification de isCancelled () à l'intérieur de la boucle
for garantit que si la tâche a été annulée, le système n'attend pas la fin de la
boucle.
2. onProgressUpdate () met à jour le pourcentage de progression. Elle est
appelée chaque fois que la méthode publishProgress () est appelée dans
doInBackground (), qui met à jour le pourcentage de progression.
3. doInBackground () calcule le nombre total d'octets téléchargés et le renvoie.
onPostExecute () reçoit le résultat retourné et le transmet à onPostExecute (),
où il est affiché dans une boîte de dialogue.

Pr. Yassine SADQI 27

Exécution d'une AsyncTask

• Après avoir défini une sous-classe d'AsyncTask, il faut

1. l'instancier sur le thread d'interface utilisateur (UI thread).
2. appeler ensuite execute () sur l'instance, en passant n'importe quel nombre
de paramètres. (Ces paramètres correspondent au type de paramètre
"Params" ).
• Par exemple, pour exécuter la tâche DownloadFilesTask, on utilise la ligne de code
suivante:

new DownloadFilesTask().execute(url1, url2, url3);

Pr. Yassine SADQI 28

Annulation d'une AsyncTask

• Il est possible d’annuler une tâche à tout moment, à partir de n'importe quel thread, en
appelant la méthode cancel () :
public final boolean cancel (boolean mayInterruptIfRunning)
o La méthode cancel () renvoie false si la tâche n'a pas pu être annulée, généralement
parce qu'elle s'est déjà terminée normalement. Sinon, cancel () renvoie true.
o Pour savoir si une tâche a été annulée, vérifiez périodiquement la valeur de retour de
isCancelled () depuis doInBackground (Object []), par exemple depuis l'intérieur d'une
boucle comme indiqué dans l'exemple précédent. La méthode isCancelled () renvoie
true si la tâche a été annulée avant de se terminer normalement.
o Après l'annulation d'une tâche AsyncTask, onPostExecute () ne sera pas appelé après
le retour de doInBackground (). Au lieu de cela, onCancelled (Object) est appelé.
L'implémentation par défaut de onCancelled (Object) appelle onCancelled () et ignore
le résultat.
o Pour permettre à cancel () d'interrompre le thread qui exécute la tâche, transmettez
true pour la valeur de mayInterruptIfRunning.

Pr. Yassine SADQI 29

Limitations de AsyncTask

• AsyncTask n'est pas pratique pour certains cas d'utilisation:

o Les modifications apportées à la configuration de l'appareil posent des
problèmes à AsyncTask
 En effet, lorsque la configuration de l'appareil change, l'activité est détruite
et AsyncTask ne peut plus accéder à l'activité nouvellement créée et ces
résultats ne sont pas publiés.
o Les anciens objets AsyncTask restent et votre application peut manquer de
mémoire ou se bloquer.
 Si l'activité qui a créé l'AsyncTask est détruite, l'AsyncTask n'est pas
détruite avec elle. Par exemple, si l'utilisateur quitte l'application après le
démarrage de l'AsyncTask, celle-ci continue à utiliser des ressources à
moins que vous n'appeliez cancel ().

Pr. Yassine SADQI 30

Quand utiliser AsyncTask?

• Tâches courtes ou interruptibles

• Tâches qui n'ont pas besoin de communiquer avec l'interface
utilisateur ou avec l'utilisateur
• Tâches moins prioritaires qui peuvent être laissées
inachevées
• Pour plus d’information, consulter :
ohttps://developer.android.com/reference/android/os/AsyncTask

Pr. Yassine SADQI 31

V. HTTP-based
communication

32
Introduction

• La plupart des applications Android engagent l'utilisateur

avec des donnéesqui peuvent être des articles de presse, des
informations météorologiques, des contacts, des statistiques
de jeu, etc. Souvent, les données sont fournies sur le réseau
par une API Web.
• HTTP et HTTPS sont les deux protocoles de communication
réseau les plus utilisés par les applications Android.
• Dans cette partie, , nous allons découvrir comment passer
des appels réseau HTTP (S).

Pr. Yassine SADQI 33

Qu’est ce que HTTP?

• HyperText Transfer Protocol a vu le jour en

Mai 1996 dans la RFC 1945 et devient le
standard international en 1997.
• HTTP est un Protocol de communication
réseau.
• HTTP est basé sur le paradigme:
orequête / réponse
• Protocole sans état (stateless )
ole serveur ne conserve aucune
information sur les requêtes passées
des clients
Pr. Yassine SADQI 34
Communication réseau à base du protocole HTTP(s)

• En général, il faut suivre les étapes suivantes:

1. Ajouter des autorisations de communication réseau dans le fichier
AndroidManifest.xml.
2. Etablir une connexion client HTTP/HTTPS sur un thread séparé
(Worker Thread) du UI thread.
3. Analyser les résultats, qui sont généralement au format JSON.
4. Vérifier l'état du réseau.

Pr. Yassine SADQI 35

Ajout des autorisations/permissions

• Avant toute chose, il faut dire à Android que notre application va devoir utiliser une connexion
internet lors de son fonctionnement. Cette fonctionnalité nécessite une permission spéciale,
INTERNET.
• Une permission ou bien autorisation se configure via la balise <uses-permission> suivie de la
permission en question, ici INTERNET. Vous pouvez retrouver la liste complète des
permissions sur le site d'Android.
• Dans le fichier AndroidManifest, Ajouter la balise suivante à l'intérieur de la balise <manifest>:

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

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
…>

<uses-permission android:name="android.permission.INTERNET" />

....
</manifest>

Pr. Yassine SADQI 36

Ajout des autorisations/permissions

• Lors de l'utilisation des communications réseau, il est recommandé de

surveiller l'état du réseau de l'appareil afin de ne pas tenter de passer
des appels réseau lorsque le réseau n'est pas disponible.
• Pour accéder à l'état du réseau de l'appareil, votre application a besoin
d'une autorisation supplémentaire:

<uses-permission
android:name="android.permission.ACCESS_NETWORK_STATE" />

Pr. Yassine SADQI 37

Etablir une connexion client HTTP/HTTPS

• Il existe plusieurs mécanismes permettant d’établir une connexion client

HTTP ou bien HTTPS:
ola classe HttpURLConnection
olibrairie Volley
oCronet: la pile réseau Chromium mise à disposition des applications
Android en tant que bibliothèque
olibrairie OkHttp
o…
• A bien noter: Si on exécute des opérations réseau sur le thread principal
plutôt que sur un worker thread, Android lèvera une exception
NetworkOnMainThreadException et l’application se fermera.

Pr. Yassine SADQI 38

HttpURLConnection

• La classe HttpURLConnection est utilisé afin de créer une nouvelle

connexion client HTTP.
• Pour utiliser HttpURLConnection, il faut:
1. créer un URI (la destination de la requête HTTP ).
2. obtenir une connexion en appelant la méthode openConnection ()
et en convertissant le résultat en HttpURLConnection.
3. envoyer la requête et les en-têtes de requête,
4. télécharger et lire la réponse et tous les en-têtes de réponse,
5. et finalement fermer la connexion.

Pr. Yassine SADQI 39

 HttpURLConnection

• Par exemple, pour récupérer la page Web à l'adresse http://www.android.com/:

URL url = new URL("http://www.android.com/");

HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
try {
InputStream in = new BufferedInputStream(urlConnection.getInputStream());
readStream(in);
} finally {
urlConnection.disconnect();
}

Pr. Yassine SADQI 40

The END

41