Développement

Mobile avancé
Dr Rima BENELMIR
[Link]@[Link]

Département d’informatique – Université d’Alger 1

L'année universitaire : 2024/2025
 Introduction aux
Applications Mobiles
L’histoire du téléphone portable
Les premiers téléphones mobiles :
● 1947 : Bell Labs crée le premier téléphone mobile, Mobile Telephone
Service (MTS).
○ Encombrant (40 kg) et couverture limitée.
○ Première étape vers le développement de la téléphonie mobile
moderne.
L’histoire du téléphone portable
Les avancées clés :
1973 : Motorola DynaTAC 8000 X – Premier téléphone
commercial.

● Plus léger et portable.

1987 : GSM (Global System for Mobile Communications) en

Europe.

● Permet le roaming international et améliore la qualité des

appels.
L’histoire du téléphone portable
L'ère des smartphones

● 1992 : IBM Simon – Premier smartphone avec écran tactile.

○ fonctionnalités : fax, e-mails.
● 2007 : Apple iPhone – Révolution avec interface tactile, navigateur
complet et applications tierces.

Technologies modernes :

● 2019 : Smartphones pliables introduits.

○ Nouvelle forme d’innovation malgré leur coût élevé.
Les téléphones portables Aujourd'hui
Aujourd'hui, les smartphones sont bien plus que des dispositifs pour
passer des appels ou envoyer des messages.

Pourquoi ?!!!!!
Ce sont des ordinateurs portables puissants qui nous permettent de
naviguer sur Internet, de jouer, de travailler, et plus encore.

Facteur clé de cette transformation : les applications mobiles.

C’est quoi une application mobile ?
Les applications sont des logiciels qui exploitent pleinement les
capacités des smartphones.
Elles offrent des fonctionnalités variées :
● Communication (WhatsApp, Messenger)
● Divertissement (Netflix, Spotify)
● Productivité (Google Docs, Zoom)
● Etc.
Les trois types d'applications mobiles
Les trois types d'applications mobiles
1. Applications natives :
● Développées pour un système d’exploitation spécifique (ex :
Android ou iOS).
● Langages natifs : Java/Kotlin (Android), Swift/Objective-C (iOS).
● Accès complet aux fonctionnalités matérielles (caméra, GPS,
capteurs, etc.).
● Performances optimales, mais chaque plateforme nécessite une
version spécifique.
Les trois types d'applications mobiles

2. Applications Web

● Accédées via un navigateur mobile (ex. : Chrome, Safari).

● Fonctionnent avec les technologies HTML, CSS, JavaScript.
● Pas d'installation requise, compatible avec toutes les
plateformes.
● Limitations : accès restreint aux ressources du téléphone
(comme les capteurs ou la caméra).
Les trois types d'applications mobiles
3. Applications hybrides :

● Combinaison d'une application Web et de fonctionnalités

natives.
● Développées avec des frameworks comme React Native ou
Flutter.
● Code partagé entre plusieurs plateformes, mais permet d’accéder
à certaines fonctions natives.
● Moins performant que les apps natives, mais développement plus
rapide et moins coûteux.
Les systèmes d'exploitation mobiles

1. Android
● Développé par Google, basé sur un noyau Linux.
● Open source, ce qui permet une large
personnalisation.
● Langages principaux : Java, Kotlin.
● Part de marché dominante (environ 70 % mondial).
● Présent sur une large gamme d’appareils :
smartphones, tablettes, montres connectées.
Les systèmes d'exploitation mobiles

2. IOS

● Développé par Apple, réservé aux appareils Apple

(iPhone, iPad, etc.).
● Système fermé, très sécurisé avec une stricte
réglementation des applications.
● Langage principal : Swift (anciennement Objective-C).
● Optimisé pour les performances et une intégration
fluide entre les différents appareils Apple.
Les systèmes d'exploitation mobiles
Comparaison des parts de marché mondiales
Platforme Android
L'histoire d'Android
● 2003 : création de la société Android Inc.
● 2005 : Acquisition par Google
● 2008 : Lancement du premier smartphone Android (HTC Dream)

Principales étapes :

● 2009-2011 : montée en puissance avec les versions Eclair, Froyo et

Gingerbread
● 2013 : Introduction de KitKat, avec un design plus moderne
● 2014 : Android Lollipop, marquant une nouvelle ère de design avec Material
Design
● Aujourd'hui : Android 15, optimisation des performances et amélioration des
fonctionnalités de confidentialité.
L'architecture du système Android
 L'architecture du système Android
● Niveau 1 : noyau Linux
○ Android s’appuie sur le noyau Linux 2.6 qui agit également comme
une couche d’abstraction entre le matériel et le reste de la pile
logicielle pour accéder aux périphériques tels que : caméra, audio,
Bluetooth… Il apporte aussi le service de sécurité et le gestionnaire
de la mémoire.
 L'architecture du système Android
● Niveau 2 : les librairies
○ Android utilise des bibliothèques natives en C/C++. Elles fournissent
un accès direct aux ressources du système. C’est en quelque sorte la
base de l’ensemble du système au niveau supérieur.
L'architecture du système Android
● Niveau 2 : les librairies (suite)
○ SQLite : base de données relationnelle
○ FreeType : moteur de rendu des polices de caractère
○ WebKit : moteur de rendu HTML
○ Media Framework : cette bibliothèque gère tout ce qui se
rapporte aux données multimédia.
○ SGL : gère le graphisme en 2D
L'architecture du système Android
● Niveau 2 : les librairies (suite)
○ Surface Manager : ensemble de fonctions permettant la gestion
du dispositif d’affichage. Il permet de s’assurer que les pixels
s’affichent bien à l’écran.
○ OpenSSL : algorithme de cryptage des données
○ OpenGL/ES : gère le graphisme en 3D
 L'architecture du système Android
● Niveau adjacent : Android Runtime (L’environnement d’exécution)
○ Dalvik Virtual Machine (DVM)

Pour qu’un programme fonctionne, il doit d’abord passer par une étape de
compilation, qui consiste à traduire votre code Java en bytecode. Dans le
cas d’Android, ce bytecode sera ensuite lu par un logiciel qui s’appelle la
machine virtuelle Dalvik.
L'architecture du système Android
● Niveau adjacent : Android Runtime (L’environnement d’exécution)…
Suite
○ La plus grosse caractéristique de Dalvik réside dans le fait qu’elle
permet d’instancier un nombre très important d’occurrences
d’elle-même.
■ Chaque programme a sa propre occurrence de Dalvik.
■ Les différentes occurrences ne se perturbent pas les unes avec
les autres.
 L'architecture du système Android
● Machine virtuelle Dalvik (suite)
 L'architecture du système Android
● Niveau 3 : Le module de développement d’applications
Cette couche permet au programmeur de construire de nouvelles applications.

● Activity Manager : gestion du cycle de vie d’une application.

● Content Providers : le partage de données entre les applications.
● Resource Manager : gestion des fichiers non codés (images, vidéos…)
● Notifications Manager : affichage d’alertes dans la barre de titre.
● Views System : IHM
 L'architecture du système Android
● Niveau 4 : applications
○ Englobe toutes les applications natives d’un smartphone :
caméra, calculatrice, programme pour envoyer un SMS,
agenda, navigateur Web…
Les composants d’une
application mobile
Introduction
Une application mobile est composée des éléments suivants :
● Activité : couche de présentation de l’application ;
● Services : les composants qui tournent en arrière-plan ;
● Fournisseurs de contenu (Content providers) : partage de contenus
entre applications ;
● Intents : Framework de communication inter applications ;
● Récepteurs de diffusion (broadcast receivers) : consommateurs de
messages diffusés par les intents.
Activité : définition
Une activité est le composant fondamental d'une application Android
qui représente une interface utilisateur.

Elle permet à l'utilisateur d'interagir avec l'application via une interface

spécifique.

Une application comportant plusieurs écrans possédera plus d’activités.

Chaque activité est dédiée à un objectif précis, tel que :

● Afficher des données (ex. : liste de contacts)

● Modifier des informations (ex. : profil utilisateur)
● Exécuter une action (ex. : lire une vidéo)
Activité : Exemple
Activité : Fichiers de base (1⁄2)
Chaque activité de votre
application est liée à 3
principaux fichiers :

● Le fichier XML
(Manifest) où elle est
déclarée.
● Un fichier xml dans
le répertoire
/res/layout/ qui décrit
son design
● Un fichier Java pour
la contrôler.
Activité : Fichiers de base (2⁄2)
● Pour déclarer une activité dans le fichier Manifest XML, on utilise la
balise <activity>.
● La balise <intent-filter> indique la première activité qui se lance au
démarrage de l’application.
Activité : définition
● Les activités des applications Android sont implémentées en Java
par des classes d’activités : ce sont des sous-classes de
[Link].
Pile d’activité
● Les activités dans une application sont gérées par une pile
d'activités.
● Quand une nouvelle activité se lance, elle se met tout en haut
de la pile et devient l’activité en exécution.
● L’activité précédente reste dessous de la pile.
● Elle ne revient au premier que si la nouvelle activité est fermée.
● Si l’utilisateur clique sur le bouton Retour, l’activité
suivante dans la pile devient active .
Pile d’activité
 Activité : État d’activité
● Une activité peut se trouver dans trois états qui se différencient surtout par
leur visibilité :
○ Active : l’activité est lancée par l’utilisateur, elle s’exécute en premier
plan ;
○ En pause : l’activité est en pause par l’utilisateur, elle s’exécute et est
partiellement visible à l’écran, mais elle n’est plus en premier plan. Une
notification ou une autre activité lui a volé le focus.
○ Stoppé : l’activité a été lancée par l’utilisateur, mais n’est plus au
premier plan et est invisible.
○ Morte : l’activité n’est pas lancée.

En général, le passage entre les états de cycle de vie d'une activité est assuré par
les méthodes de callback suivantes :
Activité : cycle de vie

OnCreate () :
● Méthode exécutée quand
l’activité est créée.
● Si l’activité est la première d’une
application, cette méthode est
donc appelée quand l’utilisateur
exécute l’application.
Activité : cycle de vie

OnStart () :
● Méthode exécutée après
onCreate() ou onRestart().
● À cette étape, l’activité devient
visible par l’utilisateur.
Activité : cycle de vie

OnResume () :
● Appelée juste avant que l’activité
ne commence à interagir avec
l’utilisateur .
● À cette étape, l’activité est en
haut de la pile.
● Toujours suivie de onPause().
Activité : cycle de vie
OnPause () :
● Méthode exécutée à chaque fois
que :
○ L’utilisateur passe à une autre
activité.
○ L’utilisateur demande un
finish() sur cette activité.
○ Le système a besoin de libérer
de la mémoire.
● La méthode est exécutée
systématiquement avant la
méthode onResume() et onStop().
Activité : cycle de vie
OnStop() :
● Appelée quand l’activité n’est plus
visible par l’utilisateur.
● Peut arriver si :
○ L’activité est détruite.
○ Une autre activité a repris son
exécution.
● Suivie par onRestart() ou
onDestroy() si l’activité va
disparaître.
Activité : cycle de vie OnDestroy() :
● Appelée quand l’activité est détruite.
● Dernier appel que l’activité va
recevoir.
● Peut intervenir si :
○ L’activité se termine (appel de
finish ).
○ Le système détruit
temporairement cette instance
de l’activité pour gagner de
l’espace.
● On distingue entre les deux
scénarios par isFInishing().
Service
● Un service s’exécute en arrière-plan pour effectuer des
opérations de longue durée ou pour exécuter des tâches
pour des processeurs distants.
● Sert à effectuer des opérations ou des calculs en dehors
● de l’interaction utilisateur
● Contrairement à une activité, un service ne propose pas
d’interface utilisateur ; il exécute uniquement en
arrière-plan avec l’entrée de l’utilisateur .
● Un service ≈ une activité sans GUI
Service
Deux types de services :
Service Local :

1) S'exécute dans le même processus que l'application.

2) Idéal pour les tâches internes qui ne nécessitent pas de
communication avec d'autres applications.
3) Exemple : gestion des notifications, téléchargement en
arrière-plan.
Service
Deux types de services :
Service distant (Inter-Process Communication – IPC) :

1) S'exécute dans un processus indépendant de celui de

l'application.
2) Utilisé pour interagir avec d'autres applications ou pour
fournir un service à d'autres processus.
3) Exemple : Un service de musique qui peut être contrôlé par
plusieurs applications.
Tous les services héritent de la classe [Link].
Récepteur de diffusion (Broacdcast receivers)
● Gérer la communication entre le système d’exploitation Android et
les applications.
● Permettre la communication entre les composants des applications
Android à travers l’envoi des messages via l’objet : Intent
○ Ex : communication entre deux activités.
● Ne nécessite pas une interface graphique
● Un broadcast receiver est une classe qui étend Android. Content.
BroadcastReceiver
● Un récepteur s'abonne/desabonne via le fichier manifest ou par
programme.
Récepteur de diffusion (Broacdcast receivers)
Les récepteurs de diffusion réagissent aux annonces diffusées par le
système ou par d'autres applications.
● System-defined : Notifications émises par le système, comme :
○ Batterie faible
○ Réception d'un SMS
● User-defined : Notifications spécifiques aux besoins de
l’utilisateur, comme :
○ Solde bancaire négatif
Fournisseur de contenu (Content provider)
● Les Content Providers facilitent l'accès aux données stockées dans
une application, comme des bases de données SQLite ou des fichiers,
en les rendant accessibles à d'autres applications.
● Ils constituent le seul moyen sécurisé de partager des données entre
différentes applications Android.
● Lorsqu'une application souhaite accéder à des données, elle utilise la
classe ContentResolver, qui agit comme un intermédiaire pour gérer
les opérations de lecture, d'écriture et de mise à jour des données.
● Un content provider est une classe qui étend Android.
[Link]
 Intent
● Faciliter la communication entre les différentes applications et
composants, comme les Activités ou Services.
● Invoquer d'autres activités ou services.
● Partager des fonctionnalités pour réutiliser du code entre
applications.
● Exemple
○ Utiliser l’appareil photo pour prendre une photo.
○ Ouvrir une page Web avec le navigateur via une URL.
○ Envoyer un e-mail avec l’application Email.
Les ressources
 Motivation: Les ressources
● Un fichier contenant des informations statiques pour
l'application.
● Stocké en dehors du code Java, ne change pas pendant
l’exécution.
● Permet à l’application de s’adapter aux différents écrans,
densités et configurations matérielles.
● Adapte facilement l’application sans changer le code.
● Exemple d’adaptation : Préparer plusieurs versions d'images
pour différentes résolutions d'écran.
 Les ressources
● Les ressources sont des fichiers structurés d’une sorte qu’Android
ait la possibilité de choisir une ressource, parmi d’autres, qui va être
utilisée pour s’adapter au matériel sur lequel s’exécute
l’application.
● L’objectif est de faciliter l’exécution des applications pour toutes les
situations différentes.
● Le seul moyen qui permet aux ressources d’être adaptées aux
différents types de terminaux est l’utilisation du langage de
description XML.
 Les ressources
● Android, installé sur une variété de
terminaux, requiert une organisation
structurée des ressources pour offrir une
expérience d'affichage cohérente.
● Les ressources sont organisées dans des
répertoires spécifiques au sein d'un dossier
principal nommé res.
● Chaque type de ressource est associé à un
répertoire distinct, facilitant la gestion et
l'adaptation selon les terminaux.
La classe R
● Les ressources d'une application Android sont accessibles via la
classe statique R. Elle est générée automatiquement par Android
lors de la compilation de l'application.
● Elle référence chaque ressource (images, layouts, chaînes de texte,
etc.) dans le code.
● Grâce à R, les ressources peuvent être facilement appelées et
manipulées depuis le code, sans avoir besoin de chemin d'accès
spécifique.
La classe R
● Les ressources d'une application Android sont accessibles via la classe
statique R. Elle est générée automatiquement par Android lors de la
compilation de l'application.
● Elle référence chaque ressource (images, layouts, chaînes de texte, etc.) dans
le code.
● Grâce à R, les ressources peuvent être facilement appelées et manipulées
depuis le code, sans avoir besoin de chemin d'accès spécifique.
Structure des Répertoires de Ressources
Dessin et Image (res/drawable) :
● Contient des images aux formats PNG, JPEG, GIF, et des fichiers
XML pour les dessins vectoriels (scalables sans perte de qualité).
● Pour créer une ressource drawable:
○ Copier l’image dans le dossier drawable.
● Pour référencer une ressource drawable:
○ Utiliser la syntaxe « @drawable/nom de l’image »
● Exp: android:background="@drawable/My_Image”
● Pour référencer une ressource drawable dans un
● Programme Java : [Link].nom_de_l’image
Structure des Répertoires de Ressources
Icones de lancement (res/mipmap)
● Stocke les icônes d'application de différentes densités pour assurer
un rendu correct sur tous les écrans.
● Pour créer une ressource Mipmap, copier l’icône dans le dossier
mipmap.
● Pour référencer une ressource Mipmap :
○ Utiliser la syntaxe « @mipmap/nom de l’image »
● Exp: android:icon="@mipmap/My_Icon”
● Pour référencer une ressource mipmap dans un
● Programme Java : [Link].nom_de_l’icone;
Structure des Répertoires de Ressources
Variables diverses (res/values)
● Regroupe des ressources comme :
○ Chaînes de caractères ([Link]) pour gérer le texte de
l'application,
○ Dimensions ([Link]) pour les marges, espacements et tailles,
○ Couleurs ([Link]) pour définir les palettes de couleurs,
○ Styles ([Link]) pour uniformiser l'apparence visuelle de
l'interface.
● Simplifie la personnalisation et l'adaptation aux différents écrans et
langues.
Structure des Répertoires de Ressources
Création de la ressource COLOR :
res/values/[Link]
Structure des Répertoires de Ressources
Utilisation de la ressource COLOR :
Structure des Répertoires de Ressources
Création de la ressource Dimension :
res/values/[Link]
Structure des Répertoires de Ressources
Utilisation de la ressource dimensions :
Structure des Répertoires de Ressources
Création de la ressource String :
res/values/[Link]
Structure des Répertoires de Ressources
Utilisation de la ressource String :
● Affecter une ressource String à une vue (View) en Java :
○ EditText txt = (EditText) this.findViewById([Link].t);
○ [Link]([Link]);
● Pour spécifier un titre de label dans un [Link] :
○ @string/nom
●
Structure des Répertoires de Ressources
Ressource style:
● Les styles permettent de changer l’aspect général de
l’application, d’un élément ou d’une partie (l’apparence de tous
les textes de l’application).
● Un style est une collection de propriétés qui spécifie le design
d’une vue, d’un élément ou d’une application.
● Un style peut spécifier différentes propriétés : Padding, Margin,
Style de texte, Couleur du texte, Taille du texte, etc.
● Un style se définit dans un fichier ressource XML ([Link]).
Structure des Répertoires de Ressources
Création de la ressource style:
res/values/[Link]
Structure des Répertoires de Ressources
Utilisation de la ressource Style :
res/values/[Link]
La navigation entre les
composants
Intents
Introduction au Fichier Manifest
● Le fichier [Link] est le fichier central où chaque
activité est déclarée pour être reconnue par Android.

● Il permet de gérer la structure de navigation et de spécifier

quelles activités sont accessibles.

● Précise les paramètres essentiels des activités, comme les

orientations d’écran et les modes de lancement.

● Dans le fichier Manifest, vous trouverez un ensemble de nœuds

pour décrire votre projet.
Fichier Manifest
● la structure générale du fichier [Link]
Fichier Manifest
● Le nœud « application » décrit les attributs et les différents
composants qui caractérisent votre application.

● Par défaut, votre application n'a qu'un composant, l'activité

principale.

● Les composants: sont les éléments qui composeront vos

projets.

● Votre application sera au final un ensemble de composants qui

interagissent entre eux et avec le reste du système.
 <Activity>
● Le nœud <activity> permet de décrire chaque activité (ou écran) de
l’application.
● Attributs principaux :
○ android:name :
■ Indique la classe Java qui implémente l'activité.
■ Sert d’identifiant unique pour Android afin de repérer l’activité
parmi d’autres composants de l'application.
○ android:label :
■ Permet de définir un nom visible pour l’activité.
■ Ce nom s'affiche en haut de l’écran lorsque l’activité est ouverte.
●
 <intent-filter>

● Indique comment cette activité se lancera.

● L'activité qui sera lancée depuis le menu principal d'Android contiendra
toujours ces deux lignes dans son Manifest.
○ Action : MAIN indique que cette activité est le point d'entrée de
l'application.
○ Category : LAUNCHER spécifie que cette activité doit apparaître dans
le lanceur d'applications (l'écran principal).
Navigation entre les activités
La classe Intent
● Pour lancer une activité depuis une autre, Android utilise un
mécanisme puissant appelé Intent.
● Les Intents permettent d'exécuter des actions spécifiques et
de transmettre des informations au sein de l'application ou
entre différentes applications.
● Communication interne : permet de démarrer de nouvelles
activités au sein de la même application.
● Interaction externe : facilite la communication entre
différentes applications en lançant des activités externes.
Navigation entre les activités
La classe Intent
Exemple:
L'utilisateur clique sur un numéro de téléphone dans une application.
● Action déclenchée : un Intent est envoyé, informant le système
qu'un appel doit être passé.
● Résultat : Le système identifie et propose les applications
capables de gérer l'action (par exemple, l'application de
téléphone pour passer un appel).
 Intent
● Un intent est un objet qui encapsule plusieurs
champs, déterminant ainsi sa nature et ses
objectifs.
● Composant: définit le destinataire de l'intent
○ Explicite : si le champ est renseigné,
l'intent cible un composant spécifique.
○ Implicite : si non renseigné, Android
détermine le destinataire en fonction des
autres informations fournies.
 Intent
● Informations essentielles :
○ Action : décrit ce que le destinataire doit
faire (ex. "ACTION_VIEW" pour afficher une
page).
○ Données : précise les données sur
lesquelles l'action doit être effectuée (ex.
une URL ou un numéro de téléphone).

● Informations supplémentaires : D'autres

champs peuvent être inclus pour enrichir l'intent,
bien qu'ils ne soient pas obligatoires (ex.
catégories, options).
●
Intent
● Catégorie : fournit des détails supplémentaires sur l'action à exécuter et
aide à identifier le type de composant pouvant gérer l'intent (ex.
CATEGORY_LAUNCHER pour indiquer une activité de démarrage).
● Type : définit le type de données incluses dans l'intent, ce qui permet de
restreindre les données à un format spécifique (ex. image/jpeg pour une
image).
● Extras : utilisé pour ajouter du contenu supplémentaire aux intents,
facilitant le passage de données entre les composants (ex. putExtra("key",
valeur)).
● Flags : permettent de modifier le comportement de l'intent, influençant sa
gestion dans la pile des activités (ex. FLAG_ACTIVITY_NEW_TASK pour
démarrer une activité dans une nouvelle tâche).
●
Intent
● Il existe deux principaux types d’intent :
○ Intent explicite :
■ Spécifie directement la classe du composant cible (comme une
activité spécifique).
■ Utilisé principalement pour la communication entre composants
de la même application.
○ Intent implicite :
■ Déclenche une action sans spécifier de composant cible précis.
■ Utilisé pour des actions pouvant être gérées par d'autres
applications (envoyer un e-mail depuis votre application).
Intent explicite
● Un intent explicite cible directement un composant précis en spécifiant
son contexte et la classe de destination. Il est généralement utilisé pour
démarrer une activité ou un service interne à l’application.
Code Java:

● Pour lancer l’intent, il existe deux façons:

○ Sans Retour
○ Avec Retour ( le composant de destination nous renvoie une
réponse).
Intent explicite:
1) Démarrer une activité sans retour
Méthode utilisée : void startActivity(Intent intent)

● Cette méthode lance une nouvelle activité sans attendre de retour.

Exemple de code :
Intent intent = new intent(this, [Link]);
startActivity(Intent);
● Ici, un nouvel intent est créé pour lancer Activity2 depuis l'activité actuelle.
● Avant de démarrer une activité, il faut la déclarer dans le fichier
[Link]. Sans cette déclaration, une erreur
ActivityNotFoundException sera générée.
Intent explicite:
1) Démarrer une activité sans retour
● <application ...> <activity android:name=".Activity2"></activity>
</application>

Exemple: dans une première activité, vous allez mettre un bouton de sorte
qu’appuyer sur ce bouton lance une seconde activité.
Intent explicite:
2) Démarrer une activité avec retour
Méthode utilisée : void startActivityForResult(Intent intent, int requestCode)

● La méthode startActivityForResult permet de communiquer une valeur de

retour à l’activité parent.
● La sous-activité est identifiée avec un requestCode. I.e. identifier de
manière unique un intent.
● La méthode setResult dans la sous-activité est utilisée pour renvoyer des
informations à l’activité parent.
● Le retour peut inclure un code prédéfini comme RESULT_OK ou
RESULT_CANCELED, ou un code personnalisé pour des résultats
spécifiques.
Intent explicite:
2) Démarrer une activité avec retour
Exemple de code :
// Démarrage de l'activité avec retour
Intent intent = new Intent(this, [Link]);
startActivityForResult(intent, 1); // 1 est le requestCode

// Dans Activity2 pour renvoyer un résultat

setResult(RESULT_OK, resultIntent);
finish();
Exemple pratique :

● Une activité A peut lancer une activité B pour sélectionner une photo. Une fois la
photo choisie, l’activité B retourne à A avec un résultat (RESULT_OK) et l’image
sélectionnée en extra.
Intent implicite
● Un intent implicite permet de déléguer au système Android le choix de
l'application qui va traiter la requête.
● Exemple :
○ Par exemple, au lieu de spécifier une application particulière pour ouvrir
un lien, on laisse le système déterminer quelle application peut gérer
cette action.
● L’application émettrice envoie une requête sans connaître explicitement le
destinataire.
● Android examine toutes les applications installées sur l'appareil qui peuvent
gérer le type d'action demandé.
● Ces intents peuvent être gérés par des applications natives d’Android ou par
des applications téléchargées depuis le Play Store.
 Intent implicite : exemples
● Navigateur :
○ Permet d'ouvrir des liens URL. En envoyant un intent implicite avec une action
Intent.ACTION_VIEW et une URI de type URL, le système proposera d'ouvrir le
lien avec le navigateur installé.
● Appareil photo :
○ Peut être invoqué pour capturer une photo ou une vidéo via un intent implicite. Par
exemple, avec Intent.ACTION_IMAGE_CAPTURE, le système ouvre l'application
appareil photo par défaut.
● Contacts :
○ Pour visualiser ou choisir un contact, vous pouvez utiliser l'intent
Intent.ACTION_PICK avec l'URI [Link].CONTENT_URI, ce qui
ouvrira l'application Contacts native.
Intent implicite : exemples
● Messagerie SMS :
○ L'intent Intent.ACTION_SENDTO avec l'URI SMS :12345 permet d'ouvrir
l'application de messagerie pour envoyer un SMS au numéro spécifié.
● E-mail :
○ Utiliser Intent. ACTION_SEND avec des extras comme Intent.EXTRA_EMAIL,
Intent.EXTRA_SUBJECT et Intent.EXTRA_TEXT ouvre l'application de
messagerie pour envoyer un e-mail.
Intent implicite : actions natives
● Autres exemples d'actions d'intentions implicites

ACTION_EDIT Permet de modifier les données identifiées par l'intention.

ACTION_SEND Permet d'envoyer des données à une autre application, telle qu'une
application de messagerie ou de courrier électronique.

ACTION_PICK Permet de sélectionner un élément dans une liste, par exemple un

contact ou une photo.

ACTION_SEARCH Permet d'effectuer une recherche sur les données identifiées par
l'intention

ACTION_DIAL Permet de composer un numéro de téléphone.

ACTION_CALL Permet de lancer un appel téléphonique.

 Les Intents dans Android
● Exemple d’intent qui lance le navigateur Web

URI: Uniform Resource Identifier

est une courte chaîne de caractères identifiant une ressource.
 Les Intents dans Android
● Exemple d’intent qui lance le navigateur Web

URI: Uniform Resource Identifier

est une courte chaîne de caractères identifiant une ressource.
Bases de Données
SQLite
Introduction à SQLite

● SQLite est un moteur de base de

données relationnelle léger, autonome
et sans serveur.
● Créé en 2000, il est conçu pour être
embarqué directement dans les
applications.
● SQLite est écrit en C et est opensource,
ce qui le rend facilement accessible et
largement adopté.
Introduction à SQLite
Caractéristiques principales de SQLite :
● Léger et intégré : SQLite est très compact (moins de 500 Ko), ce qui
le rend idéal pour les appareils mobiles où les ressources sont
limitées.
● Aucune configuration de serveur : contrairement aux bases de
données classiques (MySQL, PostgreSQL), SQLite ne nécessite aucun
processus serveur distinct ; les opérations de base de données sont
directement intégrées dans l'application.
● Basé sur des fichiers : toutes les données sont stockées dans un seul
fichier plat, ce qui rend la gestion et le déploiement très simples
(fichier .sqlite ou .db).
Introduction à SQLite
Importance de SQLite dans les applications mobiles
● Gestion efficace des données : nécessité de stocker, organiser et
accéder à de grandes quantités de données de manière structurée.
● Performance : accélère les opérations de recherche, d'ajout, de
suppression et de mise à jour des données.
● Persistance des données : permet de conserver les informations
même après la fermeture de l'application.
● Exemples d'applications : Systèmes de gestion de contacts,
applications de notes, historiques de navigation.
Base de donnée
● Une base de données permet de stocker un ensemble d'informations
de manière structurée et organisée.
● Les données sont organisées suivant un schéma qui définit comment
les informations sont structurées et interconnectées.
● Ce modèle structuré facilite la récupération, la gestion et la
manipulation des données.
● La base de données est constituée d'entités appelées Tables.
● Chaque Table regroupe des ensembles d'informations similaires,
facilitant leur organisation et leur gestion.
Base de donnée
● Une table est composée de :
○ Tuples ou Enregistrements : Représentent les lignes de la table.
Chaque tuple correspond à un enregistrement unique dans la table.
○ Attributs : Caractérisent chaque tuple ; ils sont représentés par les
colonnes de la table. Chaque attribut représente un type spécifique
d'information pour chaque enregistrement.

Nom Âge Métier

Ahmed 45 Auteur
Khadidja 36 Étudiante
Type de donnée
1. INTEGER : Représente des nombres entiers. Exemples : 1, 42, -5.
2. REAL : Représente des nombres à virgule flottante pour les valeurs
décimales. Exemples : 3.14, -0.5, 100.0.
3. TEXT : représente des chaînes de caractères, idéal pour stocker des
noms, des adresses, des descriptions. Exemples : "Alice", "Paris".
4. BLOB : représente des données binaires brutes, pouvant inclure des
images, des fichiers audio, des documents, etc.
5. NULL : représente l'absence de valeur dans une colonne.
Type de donnée
● Contrairement à d'autres bases de données, SQLite utilise un
système de typage dynamique :
○ Cela signifie que les valeurs stockées ne sont pas strictement
limitées au type déclaré pour chaque colonne.
○ Par exemple, une colonne déclarée INTEGER peut contenir une
valeur TEXT si nécessaire, bien que ce soit déconseillé pour des
raisons de cohérence.
Création d'une table dans SQLite
● Une table est l’élément de base dans lequel les données sont organisées
dans une base de données.
● Avant d’ajouter des données, il est essentiel de définir la structure de la
table, spécifiant les attributs (colonnes) et leurs types de données.
● La syntaxe générale est la suivante :
CREATE TABLE nom_de_la_table (
nom_colonne1 TYPE_DONNEE,
nom_colonne2 TYPE_DONNEE,
...
);
Création d'une table dans SQLite
● Exemple de commande :
CREATE TABLE Utilisateur (

ID INTEGER PRIMARY KEY AUTOINCREMENT,

Nom TEXT NOT NULL,

Age INTEGER,

Metier TEXT

);
Opérations CRUD avec SQLite
● Les opérations CRUD (Create, Read, Update, Delete) sont les quatre
opérations fondamentales pour manipuler des données dans une base
de données.
● Elles permettent de gérer le cycle de vie des données : de leur insertion à
leur suppression.
● Create (Créer) :
○ Utilisée pour ajouter de nouvelles données dans une table.
○ Commande SQL : INSERT INTO.
INSERT INTO Utilisateur (Nom, Age, Metier) VALUES ('Rachid', 29,
'Développeur');
Opérations CRUD avec SQLite
● Read (Lire) :
○ Utilisée pour lire ou récupérer des données de la base.
○ Commande SQL : SELECT.

SELECT * FROM Utilisateur;

● Filtrer les résultats : On peut ajouter des conditions pour filtrer les
résultats, par exemple :

SELECT * FROM Utilisateur WHERE Age > 30;

Opérations CRUD avec SQLite
● Update (Mettre à jour) :
○ Utilisée pour modifier les données existantes dans une table.
○ Commande SQL : UPDATE.
○ Exemple : Modifier le métier de Karim dans la table Utilisateur

UPDATE Utilisateur SET Metier = 'Chirurgien' WHERE Nom =

'Karim';

● Delete (Supprimer) :
○ Utilisée pour supprimer des enregistrements de la base de données.
○ Commande SQL : DELETE.

DELETE FROM Utilisateur WHERE Nom = 'Asma';

Utilisation avancée des requêtes SQL
● Calcul de la moyenne d'âge
○ SELECT AVG(age) FROM Person GROUP BY Profession ;
● Comptage des personnes par nom
○ SELECT COUNT(*) FROM Person WHERE name = 'M';
● Suppression de livres par titre
○ DELETE FROM Book WHERE Title NOT LIKE '%DB%';
● Sélection et tri de produits par prix
○ SELECT * FROM Product WHERE Price > 5 ORDER BY Price ASC;
Gestion de base de données avec SQLiteDatabase
● La classe SQLiteDatabase est la classe principale en Android pour
créer, supprimer, exécuter des requêtes SQL et effectuer d'autres
tâches de gestion de base de données.
○ Méthodes clés : permettent d’exécuter une requête.
■ void execSQL(String sql)
■ Cursor rawQuery(String sql, String[] selectionArgs)
● La classe Cursor
○ Permet de parcourir le résultat d’une requête SELECT.
Méthodes de la classe SQLiteDatabase
● La méthode execSQL
○ Pour exécuter une requête SQL pour laquelle on ne souhaite pas de
réponse: telle que CREATE, DELETE, INSERT, UPDATE.
○ Void execSQL (String sql) : exécute une requête SQL sans
paramètres supplémentaires.
■ Exemple: [Link]("DROP TABLE Person");
○ Void execSQL (String sql, String[] args) : exécute une requête SQL
avec des arguments qui remplacent les placeholders.
■ Exemple: [Link] ("DELETE FROM Person WHERE
FirstName=? AND SecondName=?", new String[] { Ali, Ilyes });
Méthodes de la classe SQLiteDatabase
● La méthode rawQuery
○ rawQuery est utilisée pour exécuter des requêtes SQL de type
SELECT qui retournent un ensemble de résultats.
○ rawQuery retourne un objet de type Cursor qui permet de
parcourir les n-uplets un à un :
○ Exemple :
■ Cursor cursor = [Link]("SELECT * FROM Person
WHERE FirstName = ?", new String[]{"John"});
La classe Cursor
● Un Cursor est une interface qui fournit un accès en lecture aux résultats
retournés par rawQuery.

Fonctions Principales :

● moveToFirst(), moveToNext() : se déplacer à travers les lignes du résultat.

● getInt(i), getLong(i), getFloat(i), getString(i) : extraire les données de la
colonne actuelle.
● getColumnCount() : retourne le nombre total de colonnes de la table.
● getCount() : retourne le nombre total de lignes de la table.
● getPosition() : retourne la position actuelle du curseur dans la table
● isAfterLast() : retourne vrai si le parcours est fini.
● close() : Fermer le cursor pour libérer les ressources.
La classe Cursor
● Exemple de navigation

if ([Link]()) {

do {

String name = [Link]([Link]("FirstName"));

// Utiliser la variable 'name'

} while ([Link]());

[Link]();
La Classe SQLiteOpenHelper
● SQLiteOpenHelper est une classe abstraite fournie par Android pour
simplifier la gestion des bases de données.
● Gère la création de la base de données si elle n'existe pas.
● Gère la mise à jour de la base de données lors des changements de
version.
● Sa syntaxe est donnée ci-dessous:
 Les méthodes de la Classe SQLiteOpenHelper
● La méthode onCreate()
○ La méthode de callback void onCreate (SQLiteDatabase db) est
automatiquement appelée au moment de la création de la base de
données.
○ Le paramètre db représente la base.
○ Cette méthode est appelée quand la base de données n’existe pas
encore. C'est dans cette méthode que vous devrez lancer les
instructions pour créer les différentes tables et éventuellement les
remplir avec des données initiales.
public void onCreate(SQLiteDatabase db) { [Link]("CREATE TABLE
Contacts (ID INTEGER PRIMARY KEY, Name TEXT, Phone TEXT)"); }
Les méthodes de la Classe SQLiteOpenHelper
● La méthode onUpgrade()
○ La méthode de mise à jour, qui est déclenchée à chaque fois que
l'utilisateur met à jour son application.
○ Void onUpgrade (SQLiteDatabase db, int oldVersion, int newVersion)
○ Cette méthode est appelée quand la version de l’application est
supérieure à celle de la base.
○ Son rôle est de mettre à jour les tables de la base de données.
○ Paramètre :
■ db : la base de données manipulée
■ oldVersion : la version précédente de la base
■ newVersion : la nouvelle version de la base
La classe Cursor
● Un Cursor est une interface qui fournit un accès en lecture aux résultats
retournés par rawQuery.

Fonctions Principales :

● moveToFirst(), moveToNext() : se déplacer à travers les lignes du résultat.

● getString(index), getInt(index), etc. : Extraire les données de la colonne
actuelle.
● close() : Fermer le cursor pour libérer les ressources.
Développement
client-serveur
Introduction au développement client-serveur
● Une architecture client-serveur est un Client
modèle de conception de réseau où le client
(généralement une application mobile ou
web) fait des requêtes à un serveur, qui traite
ensuite ces requêtes et renvoie les réponses
appropriées.
● Le client initie des requêtes au serveur qui
peut être hébergé sur une infrastructure
cloud ou sur des serveurs dédiés.
● Le serveur exécute la logique métier, accède
aux bases de données ou aux services
externes, et renvoie les données au client.
Introduction au développement client-serveur

Avantages de l'architecture pour les applications mobiles.

● Centralisation de la logique métier

○ La logique métier est gérée sur le serveur, ce qui simplifie les
mises à jour et la maintenance.
○ Réduit la complexité sur le client.
○ Améliore la cohérence des données et des comportements à
travers différentes plateformes (iOS, Android).
Introduction au développement client-serveur

Avantages de l'architecture pour les applications mobiles.

● Scalabilité
○ La capacité de gérer une augmentation du volume d'utilisateurs et
de données sans perturber l'expérience utilisateur.
○ Les serveurs peuvent être mis à l'échelle indépendamment des
applications clientes.
○ Gestion plus efficace des ressources, adaptée à la demande.
Introduction au développement client-serveur

Avantages de l'architecture pour les applications mobiles.

● Performance et fiabilité
○ Distribuer la charge entre le client et le serveur peut améliorer la
performance de l'application et sa fiabilité.
○ Répartition des tâches intensives sur le serveur pour réduire la
charge sur le client.
○ Amélioration de l'expérience utilisateur grâce à des temps de
réponse plus rapides et une plus grande fiabilité.
Introduction au développement client-serveur

Avantages de l'architecture pour les applications mobiles.

● Facilité de maintenance et de mises à jour

○ Mises à jour et maintenance centralisées du côté serveur sans
nécessiter de mises à jour fréquentes de l'application cliente.
○ Les utilisateurs bénéficient des dernières fonctionnalités et des
correctifs sans interventions manuelles fréquentes.

L'architecture client-serveur offre une structure robuste pour le

développement d'applications mobiles, facilitant la gestion, la sécurité,
et l'adaptabilité des applications à grande échelle.
Composants d'une Architecture Client-Serveur
Composants d'une Architecture Client-Serveur:
CLIENT
Qu'est-ce qu'un client ?
● Dans une architecture client-serveur, le client est un dispositif, une application
ou un système qui accède aux services fournis par un ou plusieurs serveurs.
● Les clients initient des requêtes vers les serveurs pour obtenir des données,
des ressources ou pour effectuer des opérations.
● Le client est souvent l'interface avec laquelle les utilisateurs interagissent
directement, donc sa conception et sa performance affectent directement
l'expérience utilisateur.
● Les clients sont responsables de la demande de ressources ou de services au
serveur, qui traite ces requêtes et retourne les résultats nécessaires.
Composants d'une architecture client-serveur :
Types de client : Clients légers
● Un client léger ne possède aucun code applicatif
personnalisé et dépend entièrement du serveur
pour toutes ses fonctionnalités.
● Caractéristiques principales :
○ Dépendance au serveur : toute la logique
métier et le traitement des données sont gérés
par le serveur.
○ Indépendance du système d’exploitation :
Moins de dépendance au système
d’exploitation ou au type de dispositif mobile
comparé aux clients lourds.
Composants d'une Architecture Client-Serveur:
Types De CLIENT : CLients Légers
● Utilisation des Technologies Web :
○ Les clients légers utilisent couramment des navigateurs web standards et
des navigateurs WAP pour afficher le contenu des applications.
● Types de Contenus Affichés :
○ Web : Pages utilisant HTML, XML pour la structure et la présentation des
informations.
○ WAP : Pages utilisant WML, optimisées pour les dispositifs mobiles et
les communications sans fil.
Les différents éléments d'une architecture
client-serveur : Types De CLIENT : CLients Légers
● Avantages des clients légers :
○ Maintenance Simplifiée : Mises à jour et maintenance centralisées sur le
serveur, réduisant les coûts opérationnels.
○ Compatibilité étendue : fonctionne sur une large gamme de dispositifs
sans nécessiter des configurations matérielles spécifiques.
● Inconvénients des Clients Légers :
○ Dépendance à la connectivité : nécessite une connexion constante au
serveur pour fonctionner efficacement.
○ Limitations fonctionnelles : offre moins de fonctionnalités en mode hors
ligne ou dans des environnements à connectivité limitée.
Composants d'une Architecture Client-Serveur:
Types De CLIENT : Clients Lourds
● Un client lourd possède généralement entre une et trois couches de code
applicatif et peut fonctionner de manière autonome sans connexion
constante au serveur.
● Caractéristiques Principales :
○ Autonomie : Peuvent fonctionner indépendamment du serveur
pendant une certaine période grâce à la capacité de traiter des
données et d'exécuter la logique métier localement.
○ Stockage Local : Capables de stocker les données en local et de
continuer à fonctionner même en l'absence de connectivité.
Composants d'une Architecture Client-Serveur:
Types De CLIENT : CLients Lourds
● Avantages des Clients Légers :
○ Utilité en Absence de Connectivité :
■ Particulièrement utiles dans des environnements où la connexion
serveur-client n'est pas fiable ou garantie.
■ Permettent aux utilisateurs de continuer leur travail hors connexion,
en stockant les données localement jusqu'à ce que la connexion soit
rétablie.
● Inconvénients des Clients Légers :
○ Dépendance à la Connectivité : Nécessite une connexion constante au
serveur pour fonctionner efficacement.
○ Limitations Fonctionnelles : Offre moins de fonctionnalités en mode hors
ligne ou dans des environnements à connectivité limitée.
Composants d'une Architecture Client-Serveur:
Types De CLIENT : CLients Lourds
Défis des Clients Lourds :

● Dépendance Systémique :
○ Forte dépendance vis-à-vis du système d'exploitation et du type de
dispositif mobile, ce qui peut rendre la distribution et la mise à jour du
code applicatif complexes.
● Gestion des Versions :
○ Nécessité de gérer plusieurs versions du code sur différents dispositifs,
augmentant ainsi la complexité de maintenance.