3-Développement Des Applications Natives PDF

Ecole Nationale d’Ingénieurs de Sfax
Partie II : DÉVELOPPEMENT DES APPLICATIONS NATIVES
Enseignante: Dr. Amal BEN HAMIDA (amal.benhamida@enis.tn)
Année Universitaire 2019-2020

Plan
oIntroduction à la plateforme Android
oEnvironnement de développement Android
oFondements des applications Android
oActivité (Classe Activity)
oInterface graphique
oServices (Classe Service)
oPersistance des données
o…
DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 2

Pré requis
Programmation Orientée Objet
Langage JAVA
Technologie XML

Introduction à la plateforme Android
DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE

Système Android
o Android est un système d’exploitation Open Source pour les terminaux mobiles (Smartphones,
Tablet ,….)
o Conçu à la base par une startup (Android Incorporated, créée en 2003 ) rachetée par Google en
2005
o Pour la promotion de ce système Google a fédéré autour de lui une trentaine de partenaires
réunis au sein de l’Open Handset Alliance (OHA), en 2007
o Depuis 2010, Android devient le système d'exploitation mobile le plus utilisé au monde
o Le logo d’Android est un personnage nommé Bugdroid

Système Android
o Android est basé sur un kernel Linux et possède une licence Apache ce qui permet la redistribution du code sous forme
libre ou non et d'en faire un usage commercial
o Android désigne à la fois:
 Un environnement de développement (API : Application Programming Interface)
 Un environnement d’exécution (un émulateur pour tester ses applications)
oLe développement sous Android s'appuie sur deux piliers:

 Le langage Java
 Le SDK (Software Development Kit) qui permet d'avoir un environnement de développement facilitant la tâche du développeur
o Les développeurs ont accès au SDK, tout le code source de la plateforme, des exemples, de la documentation
o Avec ces outils il est possible de créer des versions personnalisées de l’OS Android et de développer des applications

Versions

Architecture du système Android

o La couche "Applications" regroupe l’ensemble des applications fournies avec

l’ensemble le système d’exploitation Android (navigateur, gestion des
contacts, application de téléphonie...)

o La couche "Application Framework" : cette couche permet au programmeur de construire de

nouvelles applications. Elle fournit la gestion :
 des Views (IHM)
 des ContentProviders (fournisseurs de contenus) qui permettent l'accessibilité aux données des
autres applications (ex : les contacts) et donc les partages de données
 des ressources qui sont les fichiers non codés comme les images, les écrans (Resource Manager)
 des notifications (affichage d'alerte dans la barre de titre)
 des Activities pour l'enchaînement des écrans

o La couche "Libraries" (bibliothèques) qui représente la couche logicielle basse pour utiliser :
 les formats multimédia : images, audio et vidéo enregistrement comme rendu
 OpenGL : les dessins 2D et 3D, bitmap et vectoriel,
 une base de données SQL (SQLite)
 SSL (The Secure Sockets Layer )

o L'environnement d'exécution Android Runtime (à

partir de lollilop) qui contient des machines
virtuelles compilant le bytecode vers le natif
o Toute application est exécutée dans son propre
processus, dans sa propre Dalvik Virtual Machine
(avant lollilop), donc plusieurs instances de la DVM
peuvent être lancées efficacement.
o A partir de Lollipop (5.0), Android dispose d'ART comme JVM pour Android. Elle compile
l'application au moment du déploiement (Ahead-oftime compilation: compilation à l’installation).

o Le noyau Linux sur lequel la Dalvik virtual machine s'appuie pour gérer le
multithreading, la mémoire. Le noyau Linux apporte les services de sécurité, la gestion
des processus, etc.
o Une couche d'abstraction pour l'accès aux capteurs

Environnement de développement Android

Android et les langages de programmation
oAndroid n’est pas un langage de programmation
oPour développer sous Android, il existe deux possibilités :
◦ Développement native (Java, C/C++, C#, Kotlin)
◦ Développement hybride

Workflow de développement

Pour ce cours
Framework et langage
◦ Android SDK (Software Development Kit) : les outils nécessaires pour créer une application Android
◦ Java
◦ XML
Outils
◦ IDE (Integrated Development Environment) Android Studio

Android Studio
oDisponible gratuitement sur:
o http://developer.android.com/tools/studio/index.html
o Basé sur IntelliJ IDEA, un IDE Java concurrent de Eclipse
oDepuis fin 2014, c’est l’environnement de développement Android recommandé par Google
o Remplace ADT (Eclipse)
oNécessite JDK 7 ou plus
oLors de la première exécution, télécharge certains composants nécessaire pour son bon fonctionnement
o Émulateur, SDK…
oPour les utilisateurs de LINUX 64 bits
o apt-get install lib32z1 lib32stdc++6
oPour une installation hors ligne
o Téléchargement manuel selon la plateforme
o http://developer.android.com/sdk/index.html

Installation de l’environnement de
développement
o Les étapes à suivre
1. Installer Android Studio
2. Ajouter/télécharger certains packages nécessaires
3. Créer une première application: ‘’Hello World’’
4. Exécuter l’application ‘’Hello World’’

1. Installer Android Studio
Sous Windows
oInstaller JDK sur la machine
oLancer le setup fournis (android-studio-ide-191.5791312-windows.exe) et suivre les étapes de
l’installation
oAccepter les chemins proposés par défaut

2. Ajouter/télécharger certains packages
nécessaires
oDans l’interface de bienvenue,
Sélectionner Configure -> SDK Manager

nécessaires
Vérifier la sélection des packages suivants :
oDans le menu Android SDK, sous l’onglet SDK Tools, sélectionnez
o Android SDK Build-tools
o Android Emulator
o Android SDK Platform-tools
o Android SDK tools

nécessaires
oDans le menu Android SDK, sous l’onglet SDK Platforms, sélectionnez
o Android 4.0.3
o Android 6.0 : les images système pour l’émulateur ARM EABI v7a System Image/ Intel x86 Atom System Image

nécessaires
o Cliquez Ok pour télécharger et installer les packages

3. Créer une première application: ‘’Hello
World’’

World’’

World’’

World’’

World’’

World’’
oStructure d’un projet sous Android Studio
Décrit les caractéristiques
fondamentales et les composants de
l’application
Classes Java de l’application
Les ressources de l’application :

Fichiers images, interfaces
graphiques, variables statiques (string)
Gère la compilation de l’application

World’’

World’’

World’’

World’’

World’’
oExécuter l’application
oUtiliser l’émulateur natif fournis avec Android Studio
o Créer un AVD (Android Virtual Device)
o Utiliser un vrai appareil connecté par un câble USB
oUtiliser l’émulateur Genymotion
oUtiliser l’émulateur Qemu

World’’
oUtiliser l’émulateur natif fournis avec Android Studio
oLancer AVD Manager
oCliquer ‘’ Create Virtual Device.’’
oSélectionner une configuration d’un l'appareil

World’’

World’’

oExécuter sur l’émulateur

oExécuter sur un appareil connecté par un câble USB
oConnecter l’appareil avec un câble USB
oInstaller les pilotes USB (nécessaires pour Windows seulement)
oActiver le mode de déboggage USB dans l’appareil
oExécuter l’application
(https://developer.android.com/training/basics/firstapp/running-app)

Fondements des applications Android

Processus de production

Types d’application Android
oApplication de premier plan : Application utilisable que lorsqu’elle est visible
et n’effectuant aucune tache de fond
oService : Application s’exécutant en tâche de fonds et ne présentant pas
d’interfaces utilisateurs
oIntermittente : Application exécutant à la fois des tâches des fonds et permet
l’interaction avec l’utilisateur; la communication entre les tâches de fonds et
l’utilisateurs se fait par des notifications
oWidgets: Application (utilitaires) pouvant être placé directement sur un écran
du téléphone

Composants d’une application
oActivité (android.app.Activity ) : Programme qui gère une interface graphique
oService (android.app.Service) : Programme qui fonctionne en tâche de fond sans interface
oFournisseur de contenu (android.content.ContentProvider) : Partage d’informations entre
applications
oIntentions (android.content.Intent) : Communication inter et intra-application
oRécepteurs d’informations (android.content.BroadcastReceiver) : Permet à une application de
récupérer des informations générales (réception d’un SMS, batterie faible, …)
oWidgets (android.appwidget.*) : Bibliothèque de composants visuels accrochée au bureau
d'Android
oNotifications (android.app.Notifications) : permet de notifier l'utilisateur de la survenue
d'événements
oManifest: Fichier de configuration de l’application

Composants d’une application
oLes applications sont constituées de composants
• Le système Android instancie et exécute ces composants selon la demande
– De l’utilisateur
– Des autres composants
• Chaque composant possède sa raison d’être et une API permettant d’interagir avec lui

Les activités (Activity)
oLa classe Activity est la classe principale permettant l’interaction de l’application avec l’utilisateur
oImplante généralement une seule tâche que l’utilisateur peut effectuer
oUne activité peut être avec ou sans interface utilisateur
oUne activité gère l'affichage et les interactions utilisateurs sur un écran . Les activités sont indépendantes
les unes des autres.
oUne application peut contenir plusieurs activités permettant d’offrir des vues différents pour l’utilisateur
afin d’effectuer des tâches différentes
oUne activité n’est pas linéaire, elle est soumise à plusieurs évènements. Chaque événement est représenté
dans une méthode

Les services (Service)
oUn service est un composant qui est exécuté en tâche de fond
oSans interaction requise ni interface graphique avec l’utilisateur
oPermet d’implanter l’interaction inter-processus
oExemple de service : jouer de la musique, rechercher des données sur le réseau

Fournisseur de contenu
(ContentProvider)
oUn fournisseur de contenu gère des données partageables. C'est le seul moyen d'accéder à des
données partagées entre applications
oExemple de fournisseur de contenu : les informations de contacts de l'utilisateur du
smartphone
oSimilaire à un gestionnaire de base de donnée
oOn peut créer un fournisseur de contenus pour des données qu'on veut partager
oOn récupère un fournisseur de contenu pour des données partageables en demandant au
ContentResolver du système à travers les requêtes

Intentions (Intent)
oUn événement (intent) est une "intention" à faire quelque chose contenant des informations
destinées à un composant Android
oLes activités, services et récepteurs d'informations utilisent les Intent pour communiquer entre
eux
oUn Intent implicite ne contient pas obligatoirement explicitement le composant qui va le gérer
o Si l'Intent indique explicitement la classe du composant qui va le gérer c'est un Intent explicite

Récepteurs d’informations
(BroadcastReceiver)
oUn récepteur d'informations est un composant à l'écoute d'informations qui lui sont destinées.
oUn tel récepteur indique le type d'informations qui l'intéressent et pour lesquelles il se mettra
en écoute.
oExemple : appel téléphonique entrant, réception d'un SMS, réseau Wi-Fi connecté, informations
diffusées par des applications.
oL'application réceptrice d'informations (c’est-à-dire possédant un récepteur d'informations) n'a
pas besoin d'être lancée. Si elle ne l'est pas, Android la démarre automatiquement
oLes instances de la classe BroadcastReceiver reçoivent et répondent à des évènement de type
Broadcast

Le fichier Manifest
oConfiguration de l’application
oDécrit les composantes de l’application: activités, services, fournisseurs de contenus…., en
nommant les classes implémentant chacun de ces composants
oDétermine quel processus répond à une action donnée
oDéclare les permissions de l’application nécessaires à l'application (accès internet, accès en
lecture/écriture aux données partagées)
oDécrit le numéro minimum de la version API utilisée, des logiciels et matériels utilisés par
l'application (caméra) et des bibliothèques supplémentaires à l'API de base (Google maps
library)

Le fichier Manifest
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="enis.rnu.tn" android:versionCode="1" android:versionName="1.0">
<uses-permission android:name="android.permission.INTERNET"/>
<application android:label="HelloWorld" android:icon="@drawable/ic_launcher">
<activity android:name=".MainActivity">
<intent-filter> <action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter> </activity>
<service>...</service>
<receiver>...</receiver>
<provider>...</provider>
</application> </manifest>

Création d’une application Android

Création d’une application Android
1. Définition des ressources
– Images, icônes, chaines de caractère….
2. Implantation des classes de l’application
– Principalement en Java
3. Compilation et empaquetage
– Possible avec l’IDE ou encore en ligne de commande
4. Installation sur un appareil et exécution
– Virtuel ou réel

oLes ressources sont des éléments constituant l’application autre que le code source (Layout,
String, Images, Menus, Animation, etc...)
oLes ressources sont disposées dans des sous-répertoires de « res » en fonction de leur type
oPermettent de personnaliser l’application sans modifier directement le code source
oCes ressources sont référencées dans la classe Java spéciale R pour permettre l’interaction avec
ces ressources depuis le code
oToutes les ressources sont accessibles au travers de R.java, dès qu'elles sont déclarées dans le
fichier XML associé est déposé dans le répertoire adéquat (images, chaine de caractères...)

o Les ressources sont utilisées depuis le code source de la manière suivante :
R.type_ressource.nom_ressource
o Tout projet Android a un dossier de ressources (res/) contenant les ressources du projet (bitmap, xml,…)
o /res/drawable  images (R.drawable.nom_de_la_ressources)
o /res/layout  Design des vues (R.layout.nom_de_la_vue)
o /res/values/strings  Chaînes de caractères, tableaux, valeurs numériques … (R.string.nom_chaine,
R.array.nom)
o /res/anim description d’animations (R.anim.nom_animation_)
o /res/menus  Menus pour l’application (R.menu.nom_menu)
o /res/values/color  Code de couleurs (R.color.nom_couleur)
o…

oExemple : res/values/strings.xml
<resources>
<string name="app_name">Mon application</string>
<string name=“Hello">HelloWorld!</string>
<integer-array name=“codes_postaux“>
<item>3052</item>
<item>3064</item>
</integer-array>
<string-array name= “villes“>
<item>Tunis</item>
<item>Bizerte</item>
</string-array>
<dimen name=“taille“>55px</dimen>
</resources>

oL’ensemble ressources sont modélisés par la classe « R.java » et les sous dossiers par des
classes internes à R
oChaque ressource est un attribut de la classe représentant le sous dossier dans lequel il est
déclaré
R.layout.accueil

<resources>
<string name="app_name">Mon application</string>
……
</resources> R.string.app_name

oDans le code (java), on obtient une instance de cette classe par getResources()
oPrincipales méthodes de la classe Resources (le paramètre est un identifiant défini dans R de la forme
R.type.nom) :
o boolean getBoolean(int)
o int getInteger(int)
o int[] getArray(int)
o String getString(int)
o String[] getStringArray(int)
o int getColor(int)
o float getDimension(int)
o Drawable getDrawable(int)
oExemple : Resources res=context.getResources(); String titre =res.getString(R.string.ma_chaine);
oMais dans une activité on peut faire plus simplement :
String titre = getString(R.string.ma_chaine);

oAccéder aux vues :
o getResources().getLayout(R.layout.nom_layout);
oAccéder aux valeurs :

o String chaine = getResources().getString (R.string.nom_string);
o String[] tableau= getResources(). getStringArray(R.string.nom_array);
oAccéder aux images :

o Drawable monImage = getResources().getDrawable(R.drawable.nom_image)

Les ressources sont référencées dans une autre ressource de la manière suivante :
"@type/identificateur"
<TextView
android:id="@+id/lblUsername"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_weight="0.00"
android:text="@string/lblUsername"
android:textColor="@android:color/holo_blue_dark"
android:textAppearance="?android:attr/textAppearanceMedium"
/>

oA la compilation, l’ensemble des ressources donne lieu à la génération du
fichier R.java
o Contient les identificateurs des ressources de l’application (des entiers)
o Ne jamais modifier ce fichier à la main
o Ne jamais utiliser directement les valeurs entières pour accéder à une ressource
oCes valeurs peuvent être modifiées à chaque génération du fichier R.java

2. Implantation des classes de
l’application
oIl faut développer au moins une activité
oPrincipalement la méthode onCreate ()
oWorkflow de onCreate
oRestorer l’état de l’activité
oPréciser la « vue » (fenêtre) à afficher
-Méthode setContentView
o Initialise les éléments de l’interface utilisateur (UI)
-En accédant au différents identifiants du paquetage R
oLie les éléments de l’UI à des actions implantées dans le code sources
-Programmation par évènements

3. Compilation et empaquetage
oLe système Gradle gère la compilation de l’application
o Construction d’une archive apk contenant les binaires et les ressources
oCertaines informations requises sont fournies dans le fichier AndroidManifest.xml

o Nom de l’application
o Composants de l’application (Activités, services, etc)
o Activité principale
o Permissions
o Fonctionnalités
o Version minimales de l’API
o Etc

4. Installation sur un appareil et
exécution
oLancer “Run” pour une exécution sur
o Un appareil réel
o Un appareil virtuel

Activité (Classe Activity)

Activité
oUne activité est la composante principale pour une application Android. Elle représente
l’implémentation métier dans une application Android, permettant de gérer l’ensemble des vues
et ressources
oUne activité fournit l’interface graphique pour l’utilisateur
oLe conteneur qui contient les objets graphiques et établit les liens entre l'interface graphique et
la logique programmatique
oIl est possible d’avoir plusieurs activités dans le même programme. Elle doit toujours être
déclarée dans le fichier Manifest.xml

Activité
Création d’une activité
oObligatoirement, redéfinir la méthode onCreate et y invoquer le plus souvent setContentView
oAjouter une section dans le fichier AndroidManifest.xml
<manifest...>
<application...>
<activity android:name=".ExempleActivity"/>...
</application...> </manifest>
oExemple d’activité principale

<manifest ...>
<application...>
<activity android:name=".MainActivity" android:icon = "@drawable/app_icon" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
Activité
oAndroid supporte la navigation entre les activités
oTâches : Collection d’activités permettant à l’utilisateur d’effectuer une travail (une tâche) bien
déterminée
o Les activités d’une tâche peuvent ne pas appartenir à une même application Android
oBackstack : les activités sont stockées dans une pile

o La tête de la pile est l’activité courante
o Quand l’activité courante est détruite (bouton arrière), cette activité est enlevée de la pile (pop) et
l’activité suivante devient l’activité courante
o Quand une nouvelle activité est créée elle est poussée (push) à la tête de la pile et devient l’activité
courante

Activité
oLes activités sont créées, suspendues, restaurées ou détruites selon les actions:
o De l’utilisateur (Arrière, Home, bouton)
o Du système (pour libérer la mémoire)
oQuand elle existe, une activité est soit :

o En cours d’exécution (running) : en avant plan et possédant le focus
o En pause (on pause) : partiellement visible mais le focus est donné à une autre activité
Le système peut la détruire
o En arrêt d’exécution (stopped) : complètement cachée par une autre activité
oLors du passage entre ces états, des méthodes de callback sont automatiquement appelées
o Ce qui permet au développeur d’effectuer des actions avant le passage effectif: sauvegarde,
restauration, déconnexions, etc.

Activité
Cycle de vie d'une activité
72
Activité

Activité
Existence d’une activité
oEntre l'appel à onCreate() et l'appel à onDestroy()
o L’activité devrait procéder à la configuration de l'Etat « global » (tels que la mise en page la
définition) dans onCreate(), et libérer toutes les ressources restantes dans onDestroy()
o Par exemple, si l’activité possède un thread en arrière plan qui télécharge des données à
partir du réseau, il faudrait créer ce thread dans onCreate() et ensuite le détruire dans
onDestroy()

Activité
Visibilité d’une activité
oEntre l'appel à onStart() et l'appel à onStop()
o Pendant ce temps, l'utilisateur peut voir l'activité sur l'écran et interagir avec elle
o Par exemple, onStop() est appelée lorsqu'une nouvelle activité commence et celle-ci n’est
plus visible. Entre ces deux méthodes, vous pouvez maintenir les ressources qui sont
nécessaires pour montrer l'activité de l'utilisateur
o Par exemple, on peut enregistrer un BroadcastReceiver dans onStart() pour surveiller les
changements qui influent sur l’interface utilisateur, et annuler l'enregistrement dans onStop()
lorsque l'utilisateur ne peut plus voir ce que vous affichez
o Le système pourrait appeler onStart() et onStop() plusieurs fois pendant toute la durée de
l'activité, comme l’activité alterne entre être visible et caché à l'utilisateur

Activité
Vie en avant-plan d’une activité
oEntre l'appel à onResume() et l'appel à onPause()
o Pendant ce temps, l'activité est devant toutes les autres activités sur écran possède le focus
o Une activité peut souvent passer dans et hors de l’avant plan, par exemple onPause() est
appelée lorsque l'appareil se met en veille ou quand une boîte de dialogue apparaît
o Comme cette transition est assez fréquente, le code de ces deux méthodes doit être assez
léger pour éviter les transitions lentes qui font attendre l'utilisateur

Activité
oLorsque le système détruit une activité afin de récupérer la mémoire, l'objet de l'activité est détruit, de sorte que le
système ne peut pas tout simplement le reprendre avec son état initial
oLe système doit recréer l'objet d'activité si l'utilisateur navigue pour y revenir
oL'utilisateur n’est pas conscient que le système a détruit et a recréé l’activité et, par conséquent, s’attend
probablement l'activité soit exactement comme elle était. Dans cette situation, on peut assurer que les informations
importantes sur l'état de l'activité soient préservées par la mise en œuvre d'une méthode de callback
supplémentaire permettant d'enregistrer les informations sur l'état de votre activité: onSaveInstanceState()
oLe système appelle onSaveInstanceState() avant la destruction de l’activité. Le système passe cette méthode, un
Bundle dans lequel peuvent être insérées des informations d'état sur l'activité sous forme de paires (nom, valeur),
en utilisant des méthodes telles que putString() et putInt()
oQuand l’activité est recréée, le Bundle est passé à onCreate() et onRestoreInstanceState(). En utilisant une de ces
méthodes, on peut extraire l’état sauvé du Bundle et restaurer l'état de l'activité. Si il n'y a pas d'informations d'état
à restaurer, le Bundle transmis vaut null (ce qui est le cas lorsque l'activité est créé pour la première fois)

Activité

Activité
oCréer un objet de type Intent qui spécifie l’activité à lancer
oPasser l’intent créé à une de ces méthodes:
ostartActivity
Si on ne s’attend pas à un résultat de l’activité lancé
ostartActivityForResult
Si on s’attend à un résultat de l’activité lancée
– Résultat fixé avec la méthode setResult
– Résultat récupéré par une méthode de callback onActivityResult

Activité
StartActivity
oActivité spécifique par sa classe
oActivité spécifique par son travail

Activité
startActivityForResult
oL’activité créée par startActivityForResult peut préciser son résultat à l’activité
créatrice:
o public final void setResult (int resultCode)
o public final void setResult (int resultCode, Intent data)
o L’objet Intent data peut être « rempli » par des méthodes putExtra
o resultCode peut être :
o RESULT_OK
o RESULT_CANCELED
o RESULT_FIRST_USER
o Autre résultat fournit par l’utilisateur (relatif à RESULT_FIRST_USER)

Activité

Intention
oUn Intent est un objet de messagerie permettant de demander une action à un autre composant de
l'application et facilitant la communication entre les composants de plusieurs façons
oTrois cas d'utilisation :
o Créer une activité
o startActivity ou startActivityForResult
o Possibilité d’embarquer des données pour l’activité
o Réception des résultats dans un autre Intent
o Créer un service
o startService avec possibilité d’embarquer des données
o bindService pour communiquer avec un service existant
o Livrer un Broadcast
o sendBroadcast, sendOrderedBroadcast, sendSlickyBroadcast
oDeux types
o Intent explicites
o Intent implicites

Intention
Intent Explicite
Précisent le composant (activité, service…) à créer par son nom de classe entièrement qualifié
• Utilisées généralement une un composant dans la même application
– On connait parfaitement les noms des classes dans son application
• Exemples
– Démarrer une nouvelle activité en réponse à une action de l'utilisateur
– Démarrer un service pour télécharger un fichier en arrière-plan
• Quand un Intent explicite essaie de démarrer une activité ou un service, le système retrouve
immédiatement le composant spécifié dans l’Intent

Intention
oIntent Implicite
oNe nomme pas un composant spécifique mais renseigne d'autres champs pour laisser Android
déterminer qui est capable de réceptionner cet intent (Action, Data, Type, Category)
oDéclare une action générale à exécuter, qui permet à un composant à partir d'une autre
application de gérer cette action (Prendre une photo, Envoyer un SMS, Montrer à l'utilisateur un
emplacement sur une carte)
oLa résolution d’Intent :
o Quand un Intent implicite essaie de démarrer un composant,le système Android trouve le
composant approprié en comparant le contenu de l'intention aux intent-filters déclarés dans
les fichiers manifest des autres applications sur l'appareil
o Si l’Intent correspondant à un intent-filter d’un composant, le système démarre ce composant
et le livre à l'objet Intent
o Si plusieurs intent-filters sont compatibles, le système affiche une boîte de dialogue afin que
l'utilisateur puisse choisir quelle application utiliser

Intention
Intent Implicite

Intention
Attention
oPour garantir la sécurité de l’application, toujours utiliser des Intents explicites
lors du démarrage d'un Service
oUtiliser un Intent implicite pour démarrer un service est un risque de sécurité
parce qu’on ne peut pas être certain de l’identité du service répondant à
l'intention
o L'utilisateur ne peut pas “voir” le service démarré

Intention
Attention
oIl est possible que l’appareil de l’utilisateur ne contienne pas d'applications qui gèrent l’Intent
implicite envoyé startActivity ()
oSi cela se produit, l'appel échouera et l’application va se planter
oPour vérifier qu'une activité recevra l'intention, appeler resolveActivity () sur l’objet intention
o Si le résultat est non nul, alors il y a au moins une application qui peut gérer l'intention
o Si le résultat est nul, il ne faut pas utiliser l'intention et, si possible, il faut désactiver la fonction de
l’application qui émet l’Intent

Intention
oUn objet Intent contient les information (champs) suivantes:
o le nom du composant ciblé (Champ ComponentName, facultatif)
o l'action à réaliser, sous forme de chaine de caractères (Champ Action)
o les données: contenu MIME et URI (Champ Data, Champ Type)
o une catégorie pour cibler un type d'application (Champ Category )
o des drapeaux (Champ Flags)
o des données supplémentaires (extra) sous forme de paires clef/valeur (Champ Extras)

Intention
ComponentName
oDésigne le nom du composant qui recevra l’objet Intent
o Utilisé dans le cas d’un Intent explicite
oSpécifié par plusieurs manière:

– Intent(Context packageContext, Class<?> cls)
– setComponent (ComponentName component)
– setClass (Context packageContext, Class<?> cls)
– setClassName (Context packageContext, String className)

Intention
Action
oChaine de caractères représentant l’opération à effectuer
oExemples:
– ACTION_DIAL – Composer un numéro
– ACTION_VIEW – Afficher des informations (image, etc)
– ACTION_EDIT – Afficher et modifier des données
– ACTION_SEND – Envoyer un message
– ACTION_MAIN – Démarrer l’activité initiale de l’application
oDeux manières pour préciser ce champ
– Intent newInt = new Intent(Intent.ACTION_DIAL);
– Intent newInt = new Intent();
newInt.setAction(Intent.ACTION_DIAL);

Intention
Data/Type
oDonnée associée à l’Intent sous la form d’un URI (Uniform Resource Identifier)
oGénéralement associée à une action qui utilise une donnée (ACTION_EDIT, ACTION_VIEW, etc)
oExemples:
– Donnée qui sera affichée sur une carte : Uri.parse(“geo:0,0?q=1600+Pennsylvania +Ave+Washington+DC”)
– Numéro de téléphone à composer : Uri.parse(“tel:+15555555555”)
oDeux manières de préciser la donnée:
– Intent newInt = new Intent(Intent.ACTION_DIAL,Uri.parse("tel:+15555555555"));
– Intent newInt = new Intent(Intent.ACTION_DIAL); newInt.setData(Uri.parse("tel:+15555555555"));
oUne donnée possède généralement un MIME Type qui lui associé (champ Type)
– image/*, image/png, image/jpg text/plain, text/html
o Deux manière de préciser le type
– Intent.setType(String type);
– Intent.setDataAndType(Uri data, String type);
o Attention: setData et setType se nullifient mutuellement. Utiliser setDataAndType pour les préciser tous les deux

Intention
Category
oInformation supplémentaire sur le composant qui sera démarré grâce à l’objet Intent
oCATEGORY_BROWSABLE
o Peut être invoqué par un navigateur pour affiché une donnée référencée par son URI
oCATEGORY_LAUNCHER
o Peut être l’activité initiale d’une tâche
o Listée par le système Android dans le lanceur d’applications
oPeut être spécifiée par la méthode addCategory

Intention
oFlags
oChamps définis dans la classe Intent
o Jouent le rôle de méta-données pour l’Intent et influent sur la manière don’t il sera traité
Manière de lancer une activité (à quelle tâche elle appartient, etc)
Manière de traiter une activité après son lancement (sera mise ou non dans la liste des dernière activités, etc)
oExemples:
o FLAG_ACTIVITY_NO_HISTORY
o Ne pas mettre cette activité dans la pile de l’historique des activités lancées
o FLAG_DEBUG_LOG_RESOLUTION
o Affiche des informations supplémentaire quand cet Intent est traité
oMéthode pour préciser ce champ:

– Intent newInt = new Intent(Intent.ACTION_SEND);
newInt.setFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);

Intention
Extras
oEnsemble de couples (clef, valeurs) qui seront utilisés avec l’objet Intent
o Exemple, avec l’action ACTION_SEND:
• (EXTRA_EMAIL, liste des destinataires)
• (EXTRA_CC, liste des destinataires en copie carbone)
• (EXTRA_BCC, liste des destinataires en copie carbone cachée)
• (EXTRA_SUBJECT, objet du message)
oMéthodes pour préciser ce champ

– putExtra (String name, String value);
– putExtra (String name, float[] value);
oPossibilité d’ajouter des clefs personnalisées et de les utiliser dans la méthode putExtra

Intention
Méthodes de la classe Intent
oConstruction oParamètres
– Intent(String) : avec action – putExtra(nom, valeur) ajoute un paramètre

associé à un nom
– Intent(String, Uri) :avec action et Uri
– getxxxExtra(nom) renvoie le paramètres
oAjout de catégorie correspondant au nom (xxx dépend du type de
paramètre : Int, String, StringArray …)
– addCategory(String) ajoute une catégorie
– setDataAndType(Uri, String) définit l’Uri et le
type mime des données

Intention
Démarrage explicite
Intent demarre = new Intent(context, NomDeLaClasseDeLActiviteALancer.class);
startActivity(demarre);
Démarrage implicite
– Exemple : lancer un navigateur web:
Uri chemin = Uri.parse("http://www.google.fr");
Intent naviguer = new Intent(Intent.ACTION_VIEW, chemin);
startActivity(naviguer);
– Exemple : appeler un n° de téléphone :

Uri numero = Uri.parse("tel:0123456789");
Intent appeler = new Intent(Intent.ACTION_CALL, numero);
startActivity(appeler);

Intention
Quelques valeurs prédéfinies
oActions
– android.intent.action.CALL appel téléphonique
– android.intent.action.EDIT affichage de données pour édition par l’utilisateur
– android.intent.action.MAIN activité principale d’une application
– android.intent.action.VIEW affichage de données
– android.intent.action.WEB_SEARCH recherche sur le WEB
oCatégories
– android.intent.category.DEFAULT activité pouvant être lancée explicitement
– android.intent.category.BROWSABLE peut afficher une information désignée par un lien
– android.intent.category.LAUNCHER activité proposée au lancement par Android
– android.intent.category.TAB activité associée dans un onglet d’interface (TabHost

Intention
oRecherche Google
Intent intent = new Intent
(Intent.ACTION_WEB_SEARCH );
intent.putExtra(SearchManager.QUERY,"papillons");
startActivity(intent);
oEnvoie D’un SMS

Intent intent = new Intent(
Intent.ACTION_SENDTO,
Uri.parse("sms:21314151"));
intent.putExtra("sms_body", "Vous allez à la réunion?");

Intention
oGeolocalisation par coordonnées long/lat
String geoCode ="geo:41.5020952,-81.6789717";
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(geoCode));
oIl ne faut pas oublier d’ajouter les permissions nécessaires dans le fichier manifeste :
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION " >

</uses-permission>

Filtre d’intention
oUn filtre d’Intent est une expression dans le fichier AndroidManifest.xml d’une application
oPermet de définir les intentions d’une activité
oSpécifie le type d’Intent qu’un composant (activité, service) accepte de recevoir

Exemples de Filtres d’Intent dans AndroidManifest.xml
oDéclaration de l'activité avec un filtre d’Intent afin de recevoir une intention de ACTION_SEND
lorsque le type de données est un texte
oRemarque: Afin de recevoir les Intents implicites, il est nécessaire d’inclure la catégorie de
CATEGORY_DEFAULT dans le filtre d’Intent
o Si cette catégorie n’est pas déclarée, aucun Intent implicite ne sera résolu à l’activité concernée.

Exemples de Filtres d’Intent dans AndroidManifest.xml

Interface graphique

Interface graphique
oLes activités affichent souvent une interface avec laquelle l’utilisateur peut interagir
oConstruire une IHM= mettre des composants graphiques les uns à l'intérieur des autres
Les ensembles de composants graphiques sont des classes (classe des boutons, la classe des
cases à cocher, etc)
oUn composant graphique particulier sera une instance particulière d'une classe
oExemple : le bouton "Quitter" et le bouton ''Sauvegarder" d'une IHM sont deux instances de la
classe des boutons

Interface graphique
oUn composant graphique a 3 parties :
o les données qu'il représente : le modèle (model)
o le dessin d'affichage : la vue (view)
o ce qui prend en charge les actions de l'utilisateur sur ce composant : le contrôleur

Interface graphique
oLes interfaces sont composées d’objets héritant des classes View et ViewGroup
oUne vue se dessine et permet les interactions avec l’utilisateur (boutton, textView…)
oUn groupe de vues contient d’autres vues (les gabarits conteneurs des vues)
o Un groupe de vues organise l’affichage des vues qu’il contient
o Un groupe de vues est une vue
oAndroid fournit une collection de vues et de groupes de vues qui offrent :

o les principales entrées (textes, champs de texte, listes, etc.)
o différents modèles d’organisation (linéaire, etc.)
oUne classe est associée à chaque type de vue ou groupe de vue

Interface graphique

Interface graphique
Quelques exemples de View’s
oButton
o View qui peut être cliquer pour effectuer une action
oToggleButton
o Un bouton à 2 états (coché/non coché) avec un indicateur lumineux (vert/grisé)
oCheckBox
o Un autre type de bouton à 2 états (coché/non coché) avec un indicateur classique
oRatingBar
o Une View contenant une colonne d’étoiles que l’utilisateur peut sélectionner pour exprimer généralement un avis
o EditText
o Un champ de text éditable
oAutoCompleteTextView
o Un champ de text éditable qui fournit des suggestion au fur et à mesure qu’un texte est sais

Interface graphique
oPour construire l’IHM, on peut tout coder en Java dans l'activité
oMais, en général, on utilise plutôt les fichiers XML
oExemple :
o Créer une nouvelle application Android
o Ouvrir le fichier activity_main.xml (dans res/layout/activity_main.xml)
o Construire l'IHM en glissant déposant à partir d’une palette graphique
o L’IHM est alors générée en XML

Interface graphique
oOn peut changer la largeur et la hauteur d'un composant à l'aide de ses propriétés
oExemple : Les valeurs des propriétés layout:width et layout:height peuvent être
o match_parent indique que le composant graphique sera aussi grand en largeur ou hauteur que son
conteneur le lui autorise
o wrap_content indiquant que le composant prend seulement la taille qui lui faut en largeur ou hauteur
pour s'afficher correctement

Interface graphique
oPour positionner une propriété d'un composant graphique on peut le faire
o soit en XML
o soit par appel d'une méthode appropriée en java
oDans le fichier XML, on positionne une propriété d'un composant graphique à l'aide d'une
valeur d'attribut de sa balise XML
oIl y a une correspondance entre les noms d'attribut d'une balise XML et une méthode, pour
positionner une propriété d'un composant graphique

Interface graphique
Opérations classiques sur les Vues
o SetVisibility: montre ou cache la vue
o SetChecked: état d’un bouton
o SetListeners: Code qui doit être exécuté lorsqu’un évènement spécifique survient
o SetProperties: opacité, couleur de l’arrière plan…

Interface graphique
oUne fois l’IHM est totalement définie dans le fichier activity_main.xml on peut juste invoquer
les composants dans le code java et les utiliser
oLes vues déclarées dans les fichiers xml sont automatiquement instanciées par Android
oPour récupérer l’instance d’une vue associée à une interface, Android propose la méthode
findViewById() prenant en paramètre l’identifiant de la vue dans le fichier xml
oLe fichier activity_main.xml repère les composants par android:id
oLe composant est manipulé par cet identifiant dans le programme Java à l'aide de la méthode
findViewById(R.id.nomIdentifiant);

Interface graphique
Exemple de code activity_main.xml d’une IHM
<LinearLayout
android:layout_height="match_parent"
android:orientation="vertical">
<TextView android:id="@+id/aller"
android:text="Reservation Ticket"
android:layout_height="wrap_content" />
</ LinearLayout>
Connaissant le type de la vue

TextView texte = (TextView)findViewById(R.id.aller);
Les vues peuvent être créés dynamiquement :
TextView texte = new TextView(this); texte.setId(1485);

Évènements pour les vues
oLes sources des évènements permettent de gérer les actions utilisateurs sur les vues:
o Interaction utilisateur (Touch, clavier…)
o Système (Gestion du cycle de vie)
oPour gérer les évènements sur les vues, il suffit d’ajouter un écouteur “listener”
o OnClickListener.onClick(View vue) : La vue vient d’être cliquée
o OnLongClickListener.onLongClick(View vue) : La vue vient d’être cliquée longuement
o OnTouchListener.onTouch(View vue, MotionEvent inforEvent ) : Une simple touche s'effectue sur
l'élément
o OnKeyListener.onKey(View vue, int codeTouche, KeyEvent inforEvent ) : La vue vient de recevoir une
touche du clavier

Exemple: Créer un auditeur d'événements
private OnClickListener lAuditeurDuBouton = new OnClickListener() {
public void onClick(View v) {
// code lancé lorsque le bouton est cliqué
}
};
protected void onCreate(Bundle savedValues) {
...
// Récupération du Button à partir de l'IHM en XML
Button button = (Button)findViewById(R.id.leBeauBouton);
// Enregistrer l'auditeur auprès du bouton
button.setOnClickListener(lAuditeurDuBouton);
...
}

Exemple: Créer un auditeur d'événements
public class Main extends Activity implements View.OnTouchListener, View.OnClickListener {
Button b = null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
b = (Button) findViewById(R.id.boutton);
b.setOnTouchListener(this);
b.setOnClickListener(this);
}
@Override
public boolean onTouch(View v, MotionEvent event) {
/* réagir au toucher */
return true; }
@Override public void onClick(View v) {
/* réagir au clic */
}}
oOn peut indiquer dans le fichier .xml de description d'IHM, la méthode qui sera lancée sous une
certaine action sur un composant graphique
oPar exemple, l'attribut android:onClick d'un composant graphique indique le nom de la méthode qui
sera lancée si on clique sur cette View
oPar exemple, dans le fichier de description de l'IHM, on écrit
<Button
android:id="@+id/push"
...
android:onClick="onClickEmpiler">
</Button>
oDans l'activité chargeant l'IHM contenant ce Button, on pourra écrire :

public void onClickEmpiler(View v){
// traitement lancé lorsque l'utilisateur clique sur le Button d'id push
}

Groupes de Vues (ViewGroups)
oUne vue invisible qui contient d’autres vues
oUtilisé pour grouper, organiser et contrôler un ensemble de vue
oClasse mère des conteneurs de vues et des layouts

Groupes de Vues (ViewGroups)
Les principaux ViewGroup’s prédéfinis sont :
oRadioGroup : Contient un ensemble de RadioButtons
oTimePicker : Permet de sélectionner un horaire
oDatePicker: Permet de sélectionner une date
oWebView : Permet d’afficher une page Web
oMapView : Permet d’afficher une carte Google
oSpinner et SpinnerAdapter : Permettent de sélectionner une donnée à partir d’un ensemble spécifié
sous la forme d’une liste déroulante

Layouts
oDes ViewGroup particuliers qui proposent une prédisposition des objets
graphiques
oLes principaux Layout Android sont :
o LinearLayout
o RelativeLayout
o TableLayout
o ScrollView
o Autres (ListView, GridView, WebView, MapView, ...)

Layouts
oDeux manières pour construire les layouts :
o Instancier éléments de présentation à l'exécution de l’application
o Déclarer les éléments d'interface en XML
oAvantages de la manière XML

o Séparation entre le comportement de l’application et l’apparence
o Gestion automatique de la disposition des Widgets selon l’orientation de l’appareil (portrait,
paysage…)
o Possibilité d’avoir un aperçu dans l’environnement de développement

Layout
oExemple :
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:gravity="center"
android:id="@+id/acceuil" >
</LinearLayout>
public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);
setContentView(R.layout.acceuil);
}

Layout
oUn layout peut contenir des éléments graphiques, ou d'autres layouts
oLe layout reste modifiable au travers du code, comme tous les autres objets graphiques. Pour
cela, il est important de spécifier un id dans la définition XML (android:id="@+id/acceuil")
oon peut accéder à un layout par son id et agir dessus à travers du code Java :
LinearLayout l = (LinearLayout)findViewById(R.id.acceuil);
l.setBackgroundColor(Color.BLACK);

LinearLayout

RelativeLayout

Autres Layout
TableLayout
ListViewLayout
MapWiewLayout
WebViewLayout
ScrollViewLayout

Widget
oLes composants graphiques non conteneurs
oLeur disposition dans l’interface est défini par son contenant (Viewgroup)
oLes classes de composants non conteneurs sont rangées dans l'arbre d'héritage suivante:

Widget
<TextView android:id="@+id/my_text"
android:layout_height="wrap_content"
android:layout_weight="0.00"
android:text="@string/Hello"
android:textColor="@android:color/holo_blue_dark"
android:textAppearance="?android:attr/textAppearanceMedium" />
<Button android:id="@+id/my_button"
android:layout_width="wrap_content" android:layout_height="wrap_content"
android:text="@string/my_button_text"/>
<ImageView android:id="@+id/imageView1"
android:layout_width="fill_parent" android:layout_height="wrap_content"
android:contentDescription="@string/image_description"
android:src="@drawable/login" />

Menu
oUn menu est un endroit privilégié pour placer certaines fonctions tout en économisant
l’espace dans une fenêtre
oLes activités peuvent avoir des menus, ajouter des éléments à un menu, réagir quand
un élément de menu est cliqué
oTypes de menus :
o Le menu d'options : ouvrir avec le bouton Menu sur le téléphone. Si le téléphone est
dépourvu de cette touche, Android fournit un bouton dans son interface graphique pour y
accéder
o Le menu contextuel s’affiche lors qu'on effectue un long clic sur un élément de l'interface
graphique
Ces deux menus peuvent contenir des sous-menus, qui peuvent contenir des sous-menus,
etc.

Menu
Création de menu d’options
oDéfinir une ressource Menu dans un fichier XML, dans res/menu/menu_fichier.xml par exemple
oDérouler la ressource menu en utilisant MenuInflater et une des méthodes onCreate*Menu()
oGérer le clic sur les élément du menu dans une des méthodes on*ItemsSelected()

Menu
Création de menu d’options

Menu
Création de menu contextuel
oPas tous les objets ont un menu contextuel, il faut déclarer quels widgets en possèdent par la
méthode de la classe Activity void registerForContextMenu (View v)
oDéfinir le menu dans la méthode suivante : void onCreateContextMenu (ContextMenu m, View
v,ContextMenu.ContextMenuInfo menuInfo)
oGérer le clic sur les élément du menu dans une des méthodes onContextItemsSelected()

Menu
Création de menu contextuel

ActionBar
1. Fournit un espace dédié pour donner votre application une identité et indiquant
l'emplacement de l'utilisateur dans l'application.
2. Affiche en permanence les actions importantes et ce quelle que soit l’activité en cours.
3. Permet la navigation cohérente et le basculement entre les applications (avec des onglets ou
des listes déroulantes).
oLes activités doivent hériter de la classe ActionBarActivity
1 2 3

Services (Classe Service)

Service
oUn service est un composant d'application qui peut effectuer des opérations de longue durée
en arrière-plan. Il ne fournit pas d'interface utilisateur
oUne icône (optionnelle) indique la présence d’un service et permet d’offrir quelques moyens
d’interagir avec ce service

Service
Trois types de services:
oForeground : effectue une opération qui est perceptible par l'utilisateur. Les services de premier
plan doivent afficher une notification. Les services de premier plan continuent de s'exécuter
même lorsque l'utilisateur n'interagit pas avec l'application.
oBackground : effectue une opération qui n'est pas directement remarquée par l'utilisateur.
oBound : offre une interface client-serveur qui permet aux composants d'interagir avec le
service, d'envoyer des demandes, de recevoir des résultats, Un service lié ne s'exécute que tant
qu'un autre composant d'application est lié à celui-ci. Plusieurs composants peuvent se lier au
service en même temps, mais lorsqu'ils sont tous dissociés, le service est détruit.

Service
Démarrage d’un service
oUn service est démarré quand un composant d'application invoque la méthode startService ()
oUne fois démarré, un service peut s’exécuter en arrière-plan indéfiniment, même si le
composant qui l’a démarré est détruit
oHabituellement, un service démarré effectue une seule opération et ne retourne pas de résultat
à l'appelant
oLorsque l'opération est terminée, le service devrait s’arrêter

Service
La méthode onStartCommand ()
oLe système appelle cette méthode lorsqu'un autre composant (tel qu'une activité) demande le
démarrage du service en appelant startService ()
oLorsque cette méthode est exécutée, le service est démarré et peut être exécuté en arrière-plan
indéfiniment
oSi vous implémentez cela, il est de votre responsabilité d'arrêter le service une fois son travail
terminé en appelant stopSelf () ou stopService ()
oSi vous souhaitez uniquement fournir une liaison, vous n'avez pas besoin d'implémenter cette
méthode

Service
La méthode onBind ()
oLe système appelle cette méthode lorsqu'un autre composant souhaite établir une liaison avec
le service en appelant bindService ()
oDans votre implémentation de cette méthode, vous devez fournir une interface que les clients
utilisent pour communiquer avec le service en renvoyant un Ibinder
oVous devez toujours implémenter cette méthode, même si vous ne souhaitez pas autoriser la
liaison, vous devez renvoyer null

Service
La méthode onCreate ()
oLe système appelle cette méthode pour exécuter des procédures d'installation lors de la
création initiale du service (avant d'appeler onStartCommand () ou onBind ())
oSi le service est déjà en cours d'exécution, cette méthode n'est pas appelée
La méthode onDestroy ()
oLe système appelle cette méthode lorsque le service n'est plus utilisé et qu'il est en cours de
destruction
oVotre service doit implémenter cette méthode pour nettoyer toutes les ressources telles que les
threads, les écouteurs enregistrés ou les destinataires
oC’est le dernier appel reçu par le service

Service
oSi un composant démarre le service en appelant startService ()
(qui se traduit par un appel à onStartCommand ()), alors le
service reste actif jusqu'à ce qu'il se arrête avec stopSelf () ou un
autre composant l'arrête en appelant stopService()
oSi un composant appelle bindService () pour créer le service (et
onStartCommand () n’est pas appelée), le service ne fonctionne
que tant que le composant lui est lié. Une fois que le service n’est
à aucun de ses clients, le système le détruit

Service
Déclaration d’un service dans manifest.xml

Service
oLes composants peuvent démarrer un service en invoquant la méthode:
Context.startService (Intent service)

Service
oLes composant peuvent se lier (Binding) à un service en appelant la méthode:
Context.bindService (Intent service, ServiceConnection c, int flags);
oLe binding permet à un composant d’envoyer des requêtes et de recevoir des réponses d’un
service local ou distant
oSi, au moment du binding, le service n’existe pas, il sera démarré

Persistance des données

Stockage des données
Dans une application Android il existe plusieurs manières de stocker des informations:
o Les préférences partagées : SharedPreferences
o Le système de fichiers du smartphone, vu comme un ordinateur sous Linux (soit directement
sur l’appareil, soit sur la carte externe )
o Les Bases de Données relationnelles (traitement par SQL) : Technologie SQLite

Préférences partagées (SharedPreferences)
oLes données sont stockées de manière persistante
oLes données stockées resteront même lorsque l'application est fermée ou supprimée de
l'arrière-plan
oLes données seront effacées si l'application est désinstallée ou si l'utilisateur efface
manuellement le cache de l'application des paramètres
oLes données sont stockées dans une paire clé-valeur

oLa classe SharedPreferences permet la manipulation des préférences partagées
oElle possède des méthodes pour enregistrer et récupérer des paires clé-valeur
oLa clé est le nom de la donnée, toujours de classe String
oLes valeurs sont toujours des types primitifs (boolean, int, long, float, String)
oLes préférences sont accessibles depuis plusieurs composants au sein d'une
même application

Trois APIs pour accéder aux préférences :
oLes préférences du système : SharedPreferences
PreferenceManager.getDefaultSharedPreferences(Context cxt)
oLes préférences de l’activité : SharedPreferences getPreferences(int mode)
oLes préférences de l’application : SharedPreferences getSharedPreferences (String name, int
mode)
Avec :
* name sera le nom du fichier
* mode, peut prendre trois valeurs :
-Context.MODE_PRIVATE, pour que le fichier créé ne soit accessible que par l'application qui l'a créé
-Context.MODE_WORLD_READABLE, pour que le fichier créé puisse être lu par n'importe quelle
application
-Context.MODE_WORLD_WRITEABLE, pour que le fichier créé puisse être lu et modifié par n'importe
quelle application

Initialisation des préférences partagées
private static final String NOM_PREFS = "MesPrefs";
SharedPreferences sharedPref = context.getSharedPreferences("MyPrefs", Context.MODE_PRIVATE);
oLe fichier de préférences (repéré par MesPRefs) est un fichier XML rangé dans :
/data/data/NOM_PACKAGE_APPLI/shared_prefs/ MesPRefs.xml

Lecture des préférences partagées
oPour récupérer une valeur, on peut utiliser la méthode X getX(String key, X defValue) avec
*X le type de l'objet désiré, key l'identifiant de votre valeur. X peut valoir boolean, int,
long, float, String ,...
*defValue une valeur que vous souhaitez voir retournée au cas où il n'y ait pas de valeur
associée à key
ogetBoolean(), getFloat(), getInt(), getLong()et getString() sont utilisés pour récupérer
respectivement les valeurs booléenne, float, int, long et string
SharedPreferences pref = getSharedPreferences("MyPrefs", Context.MODE_PRIVATE);

String username = pref.getString("username", "");
int count = pref.getInt("count", 0);

Ecriture/Mise à jour des préférences partagées
oAfin d'ajouter ou de modifier des couples dans un SharedPreferences, il faut utiliser un objet de
type SharedPreference.Editor récupérable en utilisant la méthode SharedPreferences.Editor
edit() sur un SharedPreferences
oPour ajouter des informations, utilisez une méthode putX(String key, X value) avec X le type de
l'objet, key l'identifiant et value la valeur associée
oValider impérativement les changements avec la méthode boolean commit()
SharedPreferences.Editor edit = pref.edit();
edit.putString("username", "gadgetsaint");
edit.putBoolean("logged_in", true);
edit.commit();

Suppression des préférences partagées
pref.remove("username");
pref.commit();
Suppression de toutes les préférences partagées stockées dans «MyPrefs»

pref.clear();
Vérification si la préférence partagée existe ou non
boolean check = pref.contains("username");

Bases de Données relationnelles (SQLite)
oSGBDR intégré (https://www.sqlite.org/index.html)
oSQLite est efficace en terme de mémoire que le moteur d’exécution d’Android peut l’inclure dans son
intégralité (Taille : environ 257 Ko)
oSQLite ne nécessite pas de serveur pour fonctionner
oLes bases de données sont privées à l'application qui les a créées
oSQLite a été inclus dans le cœur même d'Android, c'est pourquoi chaque application peut avoir
sa/ses propres bases
oDe manière générale, les bases de données sont stockées dans les répertoires de la forme
/data/data/<package>/databases

oPour construire une base de données, il faut créer une classe qui gère toutes les relations avec
cette BD
oCette classe dérive de SQLiteOpenHelper et il faut redéfinir les méthodes
o public void SQLiteDatabase onCreate(SQLiteDatabase db) : est appelée si la base de
données est accessible, mais pas encore créé. On y lance les instructions pour créer les
différentes tables et les remplir avec des données initiales
o public void SQLiteDatabase onUpgrade (SQLiteDatabase db, int odlVersion, int newVersion)
: est appelé, si la version de la base de données est augmentée dans votre code d'application.
Cette méthode vous permet de mettre à jour un schéma de base de données existante ou de
déposer la base de données existante et recréer par la méthode onCreate ()
Avec db est la base de donnée manipulée, oldVersion est la version précédente de la base et
newVersion la nouvelle version de la base

Cinq types de données pour SQLite
oNULL : données Nulles
oINTEGER : entiers signés, stockés dans 1, 2, 3, 4, 6 ou 8 octets selon la grandeur de la valeur
oREAL : nombres réels (à virgule flottante)
oTEXT : chaînes de caractères
oBLOB : données brutes (exemple : enregistrer une image dans votre base de données)

oAfin 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)
oOn utilise execSQL(String) dès qu'il ne s'agit pas de faire un SELECT, UPDATE, INSERT ou DELETE

public class DictionaryOpenHelper extends SQLiteOpenHelper {
private static final int DATABASE_VERSION = 2;
private static final String DICTIONARY_TABLE_NAME = "dictionary";
private static final String DICTIONARY_TABLE_CREATE = "CREATE TABLE " + DICTIONARY_TABLE_NAME + "
(" +KEY_WORD + " TEXT, " + KEY_DEFINITION + " TEXT);";
DictionaryOpenHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(DICTIONARY_TABLE_CREATE);}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS " + DICTIONARY_TABLE_NAME );
onCreate(db);}
}

Système de fichiers
oSimilaire à Java « standard »
oMéthodes de Context
o openFileOutput() → FileOutputStream
méthodes write(...)/ close()
o openFileInput() → FileInputStream
méthodes read(...)/ close()
o deleteFile() supprimer le fichier
oLe stockage peut être interne à l'appareil ou externe

Système de fichiers
public void ecrireFichier(View v){
byte[] datas = {1,2,3,4,5,6,7,8,9,10};
try{
FileOutputStream out = this.openFileOutput("fichierInterne.dat",
MODE_APPEND);
out.write(datas);
out.close();
} catch(Exception e) {
Log.e("FichierInterneActivity","Erreur sur fichier",e);}}
public void lireFichier(View v){

try{
FileInputStream in = this.openFileInput("fichierInterne.dat");
int b;
do{
b=in.read();
Log.i("FichierInterneActivity","Octet lu : "+b);
}while(b!=-1);
in.close();
} catch(Exception e) { DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 163
Log.e("FichierInterneActivity","Erreur sur fichier",e);}}
Bien plus encore!

Bien plus encore à découvrir!
oMaterial Design
oGéolocalisation et cartographie
oMultimédia : Vidéo, musique
oConnectivité : Bluetooth, NFC, WIFI
oNotifications, BroadCast
oetc.

Soumission d’une application dans
Google Play Store
1. Créer un compte développeur Google
Play
o Les frais d’inscription sont un paiement unique de €25.
2. Compiler et testez votre application

o Configurer, compiler la version Release
o Tester (différents utilisateurs, différents terminaux) pour
vérifier la qualité et la performance
3. Publier votre application

o Télécharger votre fichier APK

Références
o Android developer : http://developer.android.com/index.html
o Android guide : https://developer.android.com/guide
oOpenclassroom : https://openclassrooms.com/fr/courses/2023346-creez-des-applications-
pour-android
oCours "Développement sous Android" de JeanFrançois Lalande, INSA, Institut National des
Sciences Appliquées, Centre VAL DE LOIRE

Merci pour votre attention
Suivant,
Partie III : Développement des applications hybrides

3-Développement Des Applications Natives PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

3-Développement Des Applications Natives PDF

Încărcat de

Drepturi de autor:

Formate disponibile

Ecole Nationale d’Ingénieurs de Sfax

Partie II : DÉVELOPPEMENT DES APPLICATIONS NATIVES

Enseignante: Dr. Amal BEN HAMIDA (amal.benhamida@enis.tn)

Année Universitaire 2019-2020

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 2

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 3

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 5

oLe développement sous Android s'appuie sur deux piliers:

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 6

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 7

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 8

o La couche "Applications" regroupe l’ensemble des applications fournies avec

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 9

o La couche "Application Framework" : cette couche permet au programmeur de construire de

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 10

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 11

o L'environnement d'exécution Android Runtime (à

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 12

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 13

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 15

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 16

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 18

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 19

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 20

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 21

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 22

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 23

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 24

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 25

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 26

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 27

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 28

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 29

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 30

Classes Java de l’application

Les ressources de l’application :

Gère la compilation de l’application

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 31

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 32

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 33

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 34

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 35

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 36

oSélectionner une configuration d’un l'appareil

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 37

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 38

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 39

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 40

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 41

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 43

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 44

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 45

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 46

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 47

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 48

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 49

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 50

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 51

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 52

DÉVELOPPEMENT DES APPLICATIONS MOBILES – 2ÈME ANNÉE GÉNIE INFORMATIQUE 53