cours.pdf

19/01/2021 Adil JEGHAL 1
Programmation Mobile:
Android
Pr. Adil JEGHAL
adil.jeghal@usmba.ac.ma

Introduction
Objectif du Cours
Comprendre l’architecture du système Android
Comprendre l’organisation d’une application Android
Développer et déployer des applications natives Android

Introduction
Pré requis
Programmation Orienté Objet
JAVA
XML

Introduction
Un périphérique mobile c'est quoi ?
Un écran très petit
Pas de clavier/souris
Pas de disque dur
Fonctionne sur batterie
Moyens de communication variés
 L’interface graphique devra être la
plus simple possible
 Mémoire allouée à une application
est de l’ordre de quelques mégabytes
 une seule application peut être
visible à la fois

Introduction
Android: c’est quoi?
Un système d'exploitation open source pour Smartphones, et terminaux
mobiles
Conçu par Android, une startup rachetée par Google, et annoncé
officiellement le 5 novembre 2007
C’est aujourd’hui le système d’exploitation mobile le plus utilisé à travers le
monde

Introduction
Historique des versions

Plateforme Android
Le système d’exploitation Android est basé sur Linux. Au plus bas niveau de ce
système se trouve un noyau Linux destiné à la gestion du matériel comme :
Drivers de ces terminaux,
La gestion de la mémoire,
La gestion des processus
L’accès au réseau
…

Plateforme Android
Architecture de la plateforme
Produit final, ce que
l’utilisateur voit, ce qui
lui permet d’interagir
avec le système
Interface permettant
aux développeurs de
dialoguer avec les
librairies basiques
d’Android
Middleware ecrit en
C++, Librairies natives
de Android manipulant
le materiel
La machine virtuelle
d’Android
Ensemble de classe
utilisés par la machine
virtuelle
Noyau Linux pour la
gestion et la
configuration du
materiel

Le kit de développement Android
Les kits de développement
 Google fournit, en plus du système d’exploitation, un kit de développement Java (SDK) comprenant:
• des API (interfaces de programmation) ;
• des exemples de code ;
• de la documentation ;
• des outils – parmi lesquels un émulateur – permettant de couvrir quasiment toutes les étapes du
cycle de développement d’une application.
 Google fournit le NDK (Native Developper Kit) pour développer des applications en C/C++
 L'ADK (Accessory Development Kit) permet de développer des applications pour des extensions
électroniques
 Le SDK Android est disponible gratuitement sur le site de Google

Les Applications Android
Composants d’une application
 Activités
 Services
 Fournisseurs de contenus
 Gadgets
 Objets Intent
 Récepteurs d’Intents
 Notifications

Quelques concepts importants
 Les vues:
• Ce sont des éléments de l’interface graphique que l’utilisateur voit et sur lesquels il pourra agir.
• Les vues contiennent des composants, organisés selon diverses mises en page (les uns à la suite des autres, en
grille…)
 Les contrôles:
• Représentent un sous-ensembles de vues, par exemple: boutons, champs de saisie, case à cocher, etc.
• Ils ont besoin d’accéder aux textes et aux images qu’ils affichent (à partir des fichiers ressources de l’application)
 Les activités:
• Ce sont des écrans structurés par un ensemble de vues et de contrôles composant leur interface de façon logique.
• Une activité est composée d’une hiérarchie de vues contenant elles-mêmes d’autres vues.
• Une application comportant plusieurs écrans, possédera donc autant d’activités.

Quelques concepts importants
 Le fichier de configuration - AndroidManifest.xml :
C’est un fichier indispensable à chaque application qui décrit entre autres :
• le point d’entrée de votre application (quel code doit être exécuté au démarrage de l’application) ;
• quels composants constituent ce programme ;
• les permissions nécessaires à l’exécution du programme (accès à Internet, accès à l’appareil photo...).

Composants applicatifs
Activité
•Standard de
l'application sous
Android
•Possède une IHM
•Toutes les activités
dérivent de la classe
mère Activity
Service
•Composant qui fonctionne en
tâche de fond, de manière
invisible.
•Principales utilisations: tâches
de fond, répétitives, qui n'ont
pas besoin d'interaction directe
avec l'utilisateur
(téléchargement, mise à jour,
Web service, etc.)
Broadcast Receiver
•Réagit en fonction des
messages diffusés par le
système Android
•Le système de gestion de
l'énergie diffuse l'état de la
batterie
•Les classes d'application
héritent de la classe
BroadcastReceiver
Fournisseur de contenus
•Propose des contenus à
l'ensemble des activités et
services
•Demande le plus de lignes de
code, permet le partage des
données entre toutes les
applications

Eléments d’interaction
Objet Intent
•Permet aux
applications de
fournir ou demander
des services ou des
données.
•La transmission se fait
à travers tout le
système et peut cibler
précisément une
activité ou un
service.
Récepteur d’intentions
•Permet à une application
d’être à l’écoute des autres afin
de répondre aux objets Intent
qui lui sont destinés et qui sont
envoyés par d’autres
composants applicatifs.
Filtre d’intentions
•Lorsqu'un objet Intent ne
mentionne pas explicitement
un composant cible, les filtres
des applications
cibles sont comparés à l’objet
Intent.
Notifications
•Signale une
information à
l’utilisateur sans
interrompre ses
actions en cours.

Permissions
 Certaines opérations sont réalisables à condition d’en obtenir la permission.
 Ces actions sont de plusieurs formes :
• Opérations pouvant entraîner un surcoût (connexion, échange de données, envoi de SMS parexemple)
• Utilisation de données personnelles (accès à vos contacts, à votre compte Google…)
• Accès au matériel du téléphone (écriture sur la carte mémoire...).
 L’utilisation de permissions doit être déclarée dans le fichier de configuration de l’application.
 À l’installation de l’application, l’utilisateur disposera d’un récapitulatif de toutes les permissions demandées

Cycle de vie d’une application
 Les applications Android réagissent à des changements d’états imposés par le système (démarrage, pause, reprise, arrêt).
• Elles n’ont aucun contrôle direct sur leur propre cycle de vie.
• C’est le système qui peut mettre en pause ou arrêter une activité, si nécessaire.
 Chaque application fonctionne dans son propre processus.
• Le système Android est responsable de la création et de la destruction des processus et gère ses ressources avec
comme objectifs: la sécurité, la disponibilité et la réactivité de l’appareil.
• Un processus peut être tué à n’importe quel moment, sans son consentement, pour libérer des ressources nécessaires
à d’autres applications.
 La priorité du processus donnée par le système détermine leur ordre d’arrêt
• La priorité de l’application est déterminée par son composant le plus prioritaire (une application possédant un
fournisseur de contenu a par exemple plus de priorité qu’une application qui en est dépourvue).
• Deux applications de même priorité seront départagées par le temps qu’elles auront passé à une priorité plus faible.

Les Activités Android
Définition
 Une activité peut être assimilée à un écran qu’une application propose à son utilisateur.
• Pour chaque écran de votre application, vous devrez donc créer une activité.
 La transition entre deux écrans correspond au lancement d’une activité ou au retour vers une activité placée en arrière-
plan.
 Une activité comprend 2 volets :
• La logique de l’activité et la gestion du cycle de vie de l’activité qui sont implémentés en Java, dans une classe héritant
de Activity;
• L’interface utilisateur, qui pourra être définie soit dans le code de l’activité, soit, de façon plus générale, dans un fichier
XML placé dans les ressources de l’application.

Code minimal pour créer une activité
import android.app.Activity;
import android.os.Bundle;
public class ActiviteSimple extends Activity {
/**
* Méthode appelée à la création de l’activité
* @param savedInstanceState permet de restaurer l’état
* de l’interface utilisateur
*/
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
}

Cycle de vie d’une activité

Squelette d’une activité
import android.app.Activity;
import android.os.Bundle;
public final class TemplateActivity extends Activity {
/*Appelée lorsque l’activité est créée. Permet de restaurer l’état de l’interface
utilisateur *grâce au paramètre savedInstanceState.*/
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Placez votre code ici
}
/*Appelée lorsque que l’activité a fini son cycle de vie. C’est ici que nous placerons
notre *code de libération de mémoire, fermeture de fichiers et autres opérations de
"nettoyage".*/
@Override
public void onDestroy(){
super.onDestroy();
}

/*Appelée lorsque l’activité démarre. Permet d’initialiser les contrôles.*/
@Override
public void onStart(){
super.onStart();
}
/*Appelée lorsque l’activité passe en arrière plan. Libérez les écouteurs, arrêtez les
*threads, votre activité peut disparaître de la mémoire.*/
@Override
public void onStop(){
super.onStop(); }
/*Appelée lorsque l’activité sort de son état de veille.*/
@Override
public void onRestart(){
super.onRestart();
//Placez votre code ici}

/*Appelée lorsque que l’activité est suspendue. Stoppez les actions qui consomment des
*ressources. L’activité va passer en arrière-plan.*/
@Override
public void onPause(){
//Placez votre code ici
super.onPause();
}
/*Appelée après le démarrage ou une pause. Relancez les opérations arrêtées (threads).
*Mettez à jour l’application et vérifiez vos écouteurs.*/
@Override
public void onResume(){
super.onResume();
}

/*Appelée lorsque l’ activité termine son cycle visible. Sauvez les données importantes.*/
@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
//Placez votre code ici, sans quoi l’activité aura perdu son état lors de son
réveil
super.onSaveInstanceState(savedInstanceState);
}
/*Appelée après onCreate. Les données sont rechargées et l’interface utilisateur est
*restaurée dans le bon état.*/
@Override
public void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
//Placez votre code ici
}
}

Méthodes correspondant au cycle de vie
Les méthodes onXxx sont appelées au cours du cycle de vie. Si elles sont surchargées elles doivent faire appel à leur
homologue de la classe supérieure (super.onXxx).
 onCreate(Bundle) appelée à la création. Le paramètre permet de récupérer un état sauvegardé lors de l'arrêt de l'activité
(si on a fait une sauvegarde)
 onPause() appelée quand l'activité n'est plus en premier plan
 onDestroy() appelée quand l'activité se termine
 onStart() appelée quand l'activité démarre
 onRestart() appelée quand l'activité redémarre
 onStop() appelée quand l'activité n'est plus visible
 onResume() appelée quand l'activité vient en premier plan
 finish() permet de terminer une activité

Méthodes relatives à l'interface
 setContentView(int) permet de créer l'interface depuis un fichier XML, le paramètre désigne ce fichier par son identifiant
 findViewById(int) récupération d'un élément d'interface (renvoie un objet de classe View) , le paramètre désigne cet
élément par son identifiant (normalement défini dans la classe R)
 showDialog(int) ouverture d'une fenêtre de dialogue. Le paramètre désigne la fenêtre de dialogue par son identifiant
 showDialog(int, Bundle) ouverture d'une fenêtre de dialogue. Le 1er paramètre désigne la fenêtre de dialogue par son
identifiant, le second permet de lui passer des paramètres
 dismissDialog(int) fermeture d'une fenêtre de dialogue désignée par son identifiant
 onCreateDialog(int, Bundle) appelée lors de l'ouverture d'une fenêtre de dialogue. Le 1er paramètre est l'identifiant de la
fenêtre de dialogue, le second est celui qui avait été passé lors de l'appel de showDialog
 onPrepareDialog(int, Bundle) appelée lors de l'activation d'une fenêtre de dialogue déjà ouverte. Le 1er paramètre est
l'identifiant de la fenêtre de dialogue, le second est celui qui avait été passé lors de l'appel de showDialog
 getCurrentFocus() renvoie l'élément de l'interface (objet de classe View) ayant actuellement le focus

Méthodes relatives aux menus et menus contextuels
 onCreateOptionsMenu(Menu) appelée lorsqu'un menu de l'activité est affiché. Le paramètre est le menu affiché.
 onOptionsItemSelected(MenuItem) appelée lors d'un choix dans un menu de l'activité. Le paramètre est le choix
effectué.
 onOptionsMenuClosed(Menu) appelée lors de la fermeture d'un menu de l'activité. Le paramètre est le menu fermé.
 registerForContextMenu(View) associe un menu contextuel à l'élément passé en paramètre
 unregisterForContextMenu(View) supprime l'association du menu contextuel à l'élément passé en paramètre
 onCreateContextMenu(ContextMenu, View, ContextMenu.ContextMenuInfo) appelée lorsqu'un menu contextuel est
affiché. Le 1er paramètre est ce menu contextuel, le 2ème est l'élément d'interface auquel il est associé, le dernier donne
des informations sur le contenu de l'élément d'interface qui a causé l'apparition du menu contextuel
 onContextItemSelected(MenuItem) appelée lors d'un choix dans un menu contextuel. Le paramètre est le choix effectué.
 onContextMenuClosed(ContextMenu) appelée lors de la fermeture d'un menu contextuel. Le paramètre est le menu
fermé.

Méthodes relatives à l'environnement et aux ressources
 getResources() renvoie un objet de classe Resources permettant l'accès aux ressources de l'application (voir plus loin la
classe Resources)
 onUserInteraction() appelée à chaque interaction de l'utilisateur (clavier, trackball, touché)
 onBackPressed() appelée lorsque l'utilisateur appuie la touche de retour arrière du téléphone
 onLowMemory() appelée lorsque le niveau de batterie devient faible
 getFilesDir() renvoie un objet de classe File représentant le chemin où sont placés les fichiers propres à l'application
 openFileInput(String) renvoie un objet de classe FileInputStream correspondant à un flux de lecture connecté au fichier
dont le nom est passé en paramètre.
 openFileOutput(String, int) renvoie un objet de classe FileOutputStream correspondant à un flux d'écriture connecté au
fichier dont le nom est passé en premier paramètre. Le second paramètre est le mode d'ouverture qui peut être :
MODE_PRIVATE (mode normal), MODE_APPEND (ajout à un fichier existant), MODE_WORLD_READABLE et
MODE_WORLD_WRITEABLE (pour les droits d'accès). On peut cumuler plusieurs attributs par |

Méthodes de lancement d'activités et de services
 startActivity(Intent) Lance une autre activité, le paramètre désigne l'activité ou les propriétés permettant à Android de
l'identifier.
 startActivityForResult(Intent, int) Lance une autre activité dont on attend un retour, le 1er paramètre désigne l'activité
ou les propriétés permettant à Android de l'identifier, le second paramètre est un numéro associé à cette activité qui
permettra d'en identifier la réponse.
 startNextMatchingActivity(Intent) Utilisé pour demander à Android de lancer une autre activité lorsque celle proposée
précédemment n'a pas donné satisfaction. Le paramètre correspond à celui qui a donné un résultat infructueux.
 finishActivity(int) Termine une activité dont on attendait un retour, le paramètre est le numéro associé à cette activité
lors de son lancement

Méthodes de lancement d'activités et de services
 startService(Intent) Lance un service, le paramètre désigne le service ou les propriétés permettant à Android de
l'identifier
 stopService(Intent) Arrête un service, le paramètre désigne le service ou les propriétés permettant à Android de
l'identifier
 getIntent() renvoie l'objet de classe Intent associé à l'activité lors de son lancement
 setResult(int) Utilisé par l'activitée appelée pour renvoyer un code de résultat à l'activité appelante
 setResult(int, Intent) comme la précédente, le paramètre supplémentaire est un Intent contenant les valeurs de retour
qui sera également renvoyé.
 onActivityResult(int, int, Intent) cette méthode de l'activité appelante est exécutée lorsqu'une activité lancée se termine,
le 1er paramètre est le numéro associé à cette activité lors de son lancement, le deuxième est le code de retour de cette
activité, le dernier est l'Intent de retour de cette activité

Manifeste
Une application est décrite par un fichier XML appelé AndroidManifest. Ce fichier permet d'indiquer :
 Le SDK utilisé par une balise uses-sdk
 Les permissions : une balise uses-permission par autorisation demandée
 Les activités de l'application : une balise activity pour chaque activité contenant chacune une ou plusieurs balises
intent-filter
 Les services de l'application : une balise service pour chaque service contenant chacune une ou plusieurs balises
intent-filter
 les écouteurs d'intentions diffusées : une balise receiver pour chaque écouteur contenant chacune une ou plusieurs
balises intent-filter
 Les fournisseurs de contenu : une balise provider pour chaque activité
 Les bibliothèques utilisées : une balise uses-library pour chaque bibliothèque

Manifeste
Chaque activité constituant une application doit être décrite par une balise <activity>. La balise minimale de l'activité
principale est de la forme :
Activités
 name qui désigne la classe de l'activité
 label qui désigne le nom sous lequel elle apparaîtra sur le terminal
 icon qui désigne l'icône à afficher sur le terminal

Manifeste
La balise <intent-filter> permet d'indiquer ce que fait l'activité (on parle d'intension). Elle sera utilisée par Android pour
rechercher une activité pouvant répondre à une spécification donnée (cette spécification lui sera fournie dans un objet de
classe Intent). La forme générale de la balise <intent-filter> est la suivante:
Activités
 Action qui indique le type d’action effectuée par l'activité (par exemple affichage, édition …)
 Category qui indique la catégorie d’action (par exemple CATEGORY_BROWSABLE indique une activité qui peut être
appelée par un navigateur)
 Data qui indique le type de données transmises à l’activité lancée ou le type de réponse attendu ainsi que le protocole
(http, content, file …)
<intent-filter>
<action android:name=“nom_d_action_1“ />
<category android:name=“nom_de_categorie_1“ />
<data android:mimeType=“nom_de_type_mime“
android:scheme=“protocole://hote:port/chemin“ />
</intent-filter>

Manifeste
Activités
 Actions
• android.intent.action.VIEW affichage de données
• 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.CALL appel téléphonique
• android.intent.action.WEB_SEARCH recherche sur le WEB
 Catégories
• android.intent.category.LAUNCHER activité proposée au lancement par Android
• 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.TAB activité associée dans un onglet d’interface (TabHost)

Manifeste
Permissions
Pour autoriser une application à accéder à certaines ressources il faut lui en donner l'autorisation par une balise <uses-
permission>. Les principales permissions sont :
Géolocalisation (GPS)
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_MOCK_LOCATION" />
Accès aux données personnelles
<uses-permission android:name="android.permission.READ_CONTACTS" />
<uses-permission android:name="android.permission.WRITE_CONTACTS" />
<uses-permission android:name="android.permission.READ_CALENDAR" />
<uses-permission android:name="android.permission.WRITE_CALENDAR" />
<uses-permission android:name="android.permission.READ_HISTORY_BOOKMARKS" />
<uses-permission android:name="android.permission.WRITE_HISTORY_BOOKMARKS" />

Manifeste
Permissions
Modification de paramètres
<uses-permission android:name="android.permission.SET_ORIENTATION" />
<uses-permission android:name="android.permission.SET_TIME_ZONE" />
<uses-permission android:name="android.permission.SET_WALLPAPER" />
Téléphonie
<uses-permission android:name="android.permission.CALL_PHONE" />
<uses-permission android:name="android.permission.CALL_PRIVILEGED" />
<uses-permission android:name="android.permission.MODIFY_PHONE_STATE" />
Audio
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />

Manifeste
Permissions
Envoi et réception de SMS/MMS
<uses-permission android:name="android.permission.READ_SMS" />
<uses-permission android:name="android.permission.RECEIVE_MMS" />
<uses-permission android:name="android.permission.RECEIVE_SMS" />
<uses-permission android:name="android.permission.RECEIVE_WAP_PUSH" />
<uses-permission android:name="android.permission.SEND_SMS" />
<uses-permission android:name="android.permission.WRITE_SMS" />

Manifeste
Permissions
Réseau
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
<uses-permission android:name="android.permission.INTERNET" />
Access au matériel
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.FLASHLIGHT" />
<uses-permission android:name="android.permission.VIBRATE" />
<uses-permission android:name="android.permission.BATTERY_STATS" />

Exercice 1
Ecrire une application pour découvrir manuellement le cycle de vie d’une activité

Ressources
Le répertoire res contient toutes les ressources qui seront mises dans le fichier application (apk). Il est constitué de sous
répertoires :
 drawable-hdpi (images en haute définition)
 drawable-ldpi (images en basse définition)
 drawable-mdpi (images en moyenne définition)
 layout (description en XML des interfaces)
 values (définitions en XML de valeurs : chaînes, tableaux, valeurs numériques …)
 anim (description en XML d’animations)
 menu (description en XML de menus pour l’application)
 xml (fichiers XML utilisés directement par l’application)
 raw (tous les autres types de ressources : fichiers texte, vidéo, son …)
Répertoires des ressources

Ressources
Classe de référencement des ressources:
Android Studio (Eclipse) explore les fichiers contenus dans les sous-répertoires de res et génère une classe (appelée R)
dans laquelle un identifiant est créé pour chacun des éléments trouvés :
• Fichiers (images, textes ..) placés dans drawable-xxxx , raw et xml
• Eléments d'interface définis dans les fichiers placés dans layout et menu
• Valeurs définies dans les fichiers placés dans values
• Animations définies dans les fichiers placés dans anim
On pourra ensuite, dans la plupart des méthodes, désigner ces ressources par leur identifiant dans cette classe R sous la
forme : R.type.nom.
Classe R

Ressources
Référencement d’une ressource dans un fichier XML
On référence une resource dans un fichier XML par :
"@[paquetage:]type/identificateur"
Par exemple : @string/machaine fait référence à une chaîne décrite dans un fichier XML placé dans le répertoire
res/values (le nom de ce fichier n'a aucune importance) et définie par :
<string name="machaine">contenu de cette chaine</string>
Utilisation de ressources

Ressources
Récupération d’une ressource dans le code (la classe Resources)
Dans le code les ressources sont désignées par leur identifiant dans la classe R de la forme : R.type.nom. Certaines
méthodes acceptent cette désignation comme paramètre pour accéder à la ressource.
On obtient une instance de la classe Resources par la méthode getResources() de l’activité. On accède ensuite aux
ressources grâce aux méthodes de cet objet qui acceptent en paramètre un identifiant de la forme R.type.nom, ces
méthodes sont :
• boolean getBoolean(int) renvoie le booléen désigné
• int getInteger(int) renvoie l'entier désigné
• int[] getIntArray(int) renvoie le tableau d'entiers désigné
• etc.
Par exemple : String titre = getResources().getString(R.string.texte_titre); permet de récupérer la chaîne définie dans un
fichier XML par : <string name="texte_titre">…..</string>
Utilisation de ressources

Uri
Pour créer une Uri faisant référence à une ressource sur Internet :
Uri ressource = Uri.parse("http://domaine.sous_doamine/chemin/nom_du_fichier");
Ressource sur Internet
Les Uri sont un moyen utilisé pour désigner des ressources que ce soit sur Internet ou localement
Pour créer une Uri faisant référence à une ressource embarquée :
Uri ressource = Uri.parse("android.resource://nom_du_paquetage_de_l_activité/" + R.chemin.app1);
Ressource locale

Interfaces
La mise en place d’une interface peut se faire de deux façons:
• Par description de l’interface dans un fichiers XML
• Par programme
Les fichiers XML qui décrivent une interface sont placés dans le répertoire res/layout.
Ils sont référencés par R.layout.nom_du_fichierXML.
Les activités peuvent utiliser la méthode setContentView(R.layout.nom_du_fichierXML) pour
mettre en place l'interface décrite par un tel fichier.

Interfaces
Propriétés des interfaces
Lorsque l'on indique des unités dans les fichiers XML elles peuvent l'être de plusieurs façons :
 en pixels (faire suivre la valeur de px)
 relativement à la taille de la fonte de caractères (faire suivre la valeur de sp)
 en millimètres (faire suivre la valeur de mm)
 en pouces (faire suivre la valeur de in)
 en points = 1/72 pouce (faire suivre la valeur de pt)
 en pixels à densité indépendante valent 1 pixel pour un écran de 160 dpi (faire suivre la valeur de dp)
Les unités

Interfaces
Elles sont définies par un code hexadécimal indiquant la transparence et les composantes (RVB) sous la forme
"#AARRVVBB" où :
 AA est la transparence (00 totalement transparent). Si le code de couleur ne comporte que 3 composantes
AA est considéré comme FF c'est-à-dire que #44FA8B est équivalent à #FF44FA8B
 RR VV et BB sont, respectivement, les composantes rouge, verte et bleue
Les couleurs
Propriétés des interfaces

Interfaces
Propriétés positionnables en XLM
Un identifiant peut être associé à chaque élément décrit dans un fichier XML, cet identifiant permet d'accéder à
l'objet créé dans le code. Les éléments ne devant pas être accédés dans le code peuvent ne pas avoir d'identifiant.
android:id="@+id/monident" permettra de retrouver cet élément par findViewById(R.id.monident).
Identifiant
android:clickable="b" (où b vaut true ou false).
android:longClickable="b" (où b vaut true ou false)
Evénements

Interfaces
android:visibility="x" (les valeurs possibles pour x sont : visible, invisible ou gone)
Avec invisible la place est conservée, avec gone la place n'est pas conservée.
Visibilité
android:background="couleur" pour définir une couleur
android:background="@drawable/monimage" pour utiliser une image. L'image est placée dans res/drawable-
xxxx/ et s'appelle monimage.t (où t est png, jpg, ou gif).
Fond

Interfaces
android:minHeight="unité" définit la hauteur minimale si possible
android:minWidth="unité" définit la largeur minimale si possible
android:paddingBottom="unité" marge interne en bas
android:paddingLeft="unité" marge interne à gauche
android:paddingRight="unité" marge interne à droite
android:paddingTop="unité" marge interne en haut
Taille et marges internes

Interfaces
android:fadeScrollbars="b" où b vaut true ou false selon que l'on souhaite que les ascenseurs disparaissent ou pas
lorsqu'ils ne sont pas utilisés.
android:scrollbarDefaultDelayBeforeFade="x" où x est un entier qui définit le délai (en ms) avant que les
ascenseurs non utilisés ne disparaissent
android:scrollbarFadeDuration="x" où x est un entier qui définit la durée d'effacement des ascenseurs (en ms)
Ascenseurs

Interfaces
Méthodes de la classe View
View(Context) le paramètre est généralement l'activité elle-même
Construction
setLayoutParams(ViewGroup.LayoutParams) permet de définir le placement des objets dans la vue. Le paramètre
de cette méthode est généralement new ViewGroup.LayoutParams(l, h) où l définit la largeur et h la hauteur. Les
valeurs pour l et h peuvent être exprimées en pixels ou prendre les valeurs :
ViewGroup.LayoutParams.WRAP_CONTENT pour adapter la taille au contenu
ViewGroup.LayoutParams.FILL_PARENT pour adapter la taille à la place disponible.
Placement

Interfaces
bringToFront() met la vue en premier plan
getLeft() renvoie la position en pixels de la gauche de la vue
getTop() renvoie la position en pixels du haut de la vue
getRight() renvoie la position en pixels de la droite de la vue
getBottom() renvoie la position en pixels du bas de la vue
Position

Interfaces
getWidth()renvoie la largeur de la vue en pixels
getHeight()renvoie la hauteur de la vue en pixels
setPadding(int, int, int, int) définit les marges (en pixels). Les paramètres sont, dans l'ordre : gauche, haut, droite, bas.
getPaddingLeft()renvoie la marge gauche (en pixels).
getPaddingTop()renvoie la marge haute (en pixels).
getPaddingRight()renvoie la marge droite (en pixels).
getPaddingBottom()renvoie la marge basse (en pixels)
Taille et marges internes

Interfaces
setBackgroundColor(int) définit la couleur du fond
setBackgroundDrawable(Drawable) définit une image de fond
setBackgroundResource(int) définit le fond à partir d'un identificateur de ressource
Fond
requestLayout() provoque un rafraichissement des positions des éléments de la vue
invalidate() provoque un rafraichissement de la vue
Rafraichissement

Interfaces
setOnClickListener(OnClickListener) associe un écouteur d'événements aux clics sur la vue
setOnLongClickListener(OnLongClickListener) associe un écouteur d'événements aux clics longs sur la vue
setOnKeyListener(OnKeyListener) associe un écouteur d'événements aux actions clavier sur la vue
setOnTouchListener(OnTouchListener) associe un écouteur d'événements aux touchés sur la vue
Evenements
isFocusable() renvoie true si la vue peut prendre le focus
setFocusable(boolean) fait ou pas prendre le focus à la vue
isFocusableInTouchMode()renvoie true si la vue peut prendre le focus lorsqu'elle est touchée
setFocusableInTouchMode(boolean) autorise ou non la vue a prendre le focus lorsqu'elle est touchée
Focus

Interfaces
Méthodes de la classe ViewGroup
ViewGroup(Context) le paramètre est généralement l'activité elle-même
Construction
addView(View) ajoute un élément au groupe
getChildCount() renvoie le nombre d'éléments du groupe
getFocusedChild() renvoie l'élément qui a actuellement le focus (objet de classe View)
removeView(View) enlève un élément du groupe
removeAllViews() enlève tous les éléments du groupe
Eléments du groupe
setPadding(int, int, int, int) définit les marges (en pixels). Les paramètres sont, dans l'ordre : gauche, haut, droite,
bas.
Marges

TP 2

Intents
Les Intents permettent de gérer l'envoi et la réception de messages afin de faire coopérer les
applications. Le but des Intents est de déléguer une action à un autre composant, une autre application
ou une autre activité de l'application courante.
Un objet Intent contient les information suivantes:
• le nom du composant ciblé (facultatif)
• l'action à réaliser, sous forme de chaine de caractères
• les données: contenu MIME et URI
• des données supplémentaires sous forme de paires clef/valeur
• une catégorie pour cibler un type d'application
• des drapeaux (informations supplémentaires)
On peut envoyer des Intents informatifs pour faire passer des messages. Mais on peut aussi envoyer des
Intents servant à lancer une nouvelle activité

Intents
Intent login = new Intent(getApplicationContext(), GiveLogin.class);
startActivity(login);
Intents pour une nouvelle activité
S'il s'agit de passer la main à une autre application, on donne au constructeur de l'Intent les données et
l'URI cible: l'OS est chargé de trouver une application pouvant répondre à l'Intent.
Button b = (Button)findViewById(R.id.Button01);
b.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
Uri telnumber = Uri.parse("tel:0666145265");
Intent call = new Intent(Intent.ACTION_DIAL, telnumber);
startActivity(call);
}});

Intents
Intent callactivity2 = new Intent(getApplicationContext(), Activity2.class);
callactivity2.putExtra("login", "jfl");
startActivity(callactivity2);
Ajouter des informations
Les Intent permettent de transporter des informations à destination de l'activité cible. On appelle ces
informations des Extra: les méthodes permettant de les manipuler sont getExtra et putExtra. Lorsqu'on
prépare un Intent et que l'on souhaite ajouter une information de type "clef -> valeur" on procède ainsi:
Bundle extras = getIntent().getExtras();
String s = new String(extras.getString("login"));
Du côté de l'activité recevant l'Intent, on récupère l'information de la manière suivante:

Intents
Intent broadcast = new Intent("andro.jf.broadcast");
broadcast.putExtra("extra", "test");
sendBroadcast(broadcast);
Broadcaster des informations
Il est aussi possible d'utiliser un objet Intent pour broadcaster un message à but informatif. Ainsi, toutes
les applications pourront capturer ce message et récupérer l'information.
Bundle extra = intent.getExtras();
String val = extra.getString("extra");
La méthode putExtra permet d'enregistrer une paire clef/valeur dans l'Intent. On peut récupérer les
données à l'aide de la méthode getExtras dans l'objet Bundle qui est dans l'Intent:

Persistance des données
Android fournit plusieurs méthodes pour faire persister les données applicatives:
 la persistance des données de l'activité (cf Le SDK Android)
La persistance des données des activités est géré par l'objet Bundle qui permet de restaurer les View qui possède un
id.
 un mécanisme de sauvegarde clé/valeur, utilisé pour les fichiers de préférences (appelé préférences
partagées)
 des entrées sorties de type fichier
 une base de donnée basé sur SQLite
Différentes persistances

La classe SharedPreferences permet de gérer des paires de clé/valeurs associées à une activité. On
récupère un tel objet par l'appel à getPreferences:
Préférences partagées
SharedPreferences prefs = getPreferences(Context.MODE_PRIVATE);
String nom = prefs.getString("login", null);
Long nom = prefs.getLong("taille", null);
La méthode getPreferences(int) appelle en fait getPreferences(String, int) à partir du nom de la classe de
l'activité courante. Le mode MODE_PRIVATE restreint l'accès au fichier créé à l'application. Les modes
d'accès MODE_WORLD_READABLE et MODE_WORLD_WRITABLE permettent aux autres applications de
lire/écrire ce fichier.

Une activité spécifique a été programmée pour réaliser un écran d'édition de préférences. Il s'agit de
PreferenceActivity. A partir d'une description XML des préférences, la classe permet d'afficher un écran
composé de modificateurs pour chaque type de préférences déclarées.
Voici un exemple de déclarations de préférences XML, à stocker dans res/xml/preferences.xml
Préférences partagées: Représentation XML d'un menu de préférences

Pour afficher l'écran d'édition des préférences correspondant à sa description XML, il faut créer une
nouvelle activité qui hérite de PreferenceActivity et simplement appeler la méthode
addPreferencesFromResource en donnant l'id de la description XML.
Pour lancer cette activité, on crée un bouton et un Intent correspondant.
Préférences partagées: Activité d'édition de préférences

Les attributs suivants sont utiles:
 android:title: La string apparaissant comme nom de la préférence
 android:summary: Une phrase permettant d'expliciter la préférence
 android:key: La clef pour l'enregistrement de la préférence
Pour accéder aux valeurs des préférences, on utiliser la méthode getDefaultSharedPreferences sur la
classe PreferenceManager. C'est la clef spécifiée par l'attribut android:key qui est utilisée pour récupérer
la valeur choisie par l'utilisateur.
Préférences partagées: Attributs des préférences

Une case à cocher se fait à l'aide de CheckBoxPreference:
Un champs texte est saisi via EditTextPreference:
Préférences partagées: toggle et texte

Il est aussi possible d'écraser des préférences par le code, par exemple si une action fait changer le paramétrage de
l'application ou si l'on reçoit le paramétrage par le réseau.
L'écriture de préférences est plus complexe: elle passe au travers d'un éditeur qui doit réaliser un commit des
modifications
Préférences partagées: Ecriture de préférences
SharedPreferences prefs = getPreferences(Context.MODE_PRIVATE);
Editor editor = prefs.edit();
editor.putString("login", "jf");
editor.commit();

Lecture/écriture de données dans un fichier, dans l’espace de stockage interne associé à l’application
 API pour création/écriture/lecture
 Données privées
 Non visible par l’utilisateur
 Destruction à la suppression de l’application
Stockage interne

Création et écriture dans un fichier
• L’appel à openFileOutput sur l’activité ou le contexte retourne une référence sur le flux d’écriture dans le fichier
(créé si inexistant)
cf. FileOutputStream
Lecture dans un fichier
• L’appel à openFileInput sur l’activité ou le contexte retourne une référence sur le flux de lecture dans le fichier
cf. FileInputStream
• L’appel à openRawInput(resId sur l’activité ou le contexte retourne une référence sur le flux de lecture dans le
fichier en lecture seule
Stockage interne

Stockage interne
OutputStreamWriter out = new OutputStreamWriter(
openFileOutput(FIILE_NAME, MODE));
InputStream inputStream = openFileInput(FIILE_NAME);
BufferedReader reader = new BufferedReader(new
InputStreamReader(inputStream));

SQLite
 Exercice 1: (Gestion des utilisateurs )
 Exercice 2 (Gestion de bibliothèque )

Connectivité
Téléphonie
Réseau
Bluetooth
Localisation
Capteurs
Caméra

Connectivité
Téléphonie
Les fonctions de téléphonie sont relativement simples à utiliser. Elles permettent de récupérer l'état de la
fonction de téléphonie (appel en cours, appel entrant, ...), d'être notifié lors d'un changement d'état, de passer
des appels et de gérer l'envoi et réception de SMS.
L'état de la téléphonie est géré par la classe TelephonyManager qui permet de récupérer le nom de
l'opérateur, du téléphone, et l'état du téléphone. Pour lire ces informations, il est nécessaire de disposer de la
permission android.permission.CALL_PHONE.
TelephonyManager tel = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
int etat = tel.getCallState();
if (etat == TelephonyManager.CALL_STATE_IDLE)
// RAS
if (etat == TelephonyManager.CALL_STATE_RINGING)
// Le téléphone sonne

Connectivité
Téléphonie
Il est aussi possible d'être notifié d'un changement d'état en utilisant un écouteur:
public class Ecouteur extends PhoneStateListener {
public void onCallStateChanged(int etat, String numero) {
super.onCallStateChanaged(etat, numero)
if (etat == TelephonyManager.CALL_STATE_OFFHOOK)
// Le téléphone est utilisé
}

Connectivité
Téléphonie: Passer un appel
Cette action étant réalisée avec un Intent (attention aux permission)
Uri telnumber = Uri.parse("tel:0666666666");
Intent call = new Intent(Intent.ACTION_CALL, telnumber);
startActivity(call);
Les applications qui peuvent passer des appels doivent filtrer ce type d'Intent pour pouvoir être invoquée
lorsque l'Intent est lancé
<receiver android:name=".ClasseGerantLAppel">
<intent-filter>
<action android:name="Intent.ACTION_CALL"/>
</intent-filter>
</receiver>

Connectivité
Téléphonie: Envoyer et recevoir des SMS
Si la permission android.permission.SEND_SMS est disponible, il est possible d'envoyer des SMS au travers de
SmsManager:
SmsManager manager = SmsManager.getDeault();
manager.sendTextMessage(" 0666666666 ", null, “Salut !", null, null);
Inversement, il est possible de créer un filtre d'Intent pour recevoir un SMS qui sera géré par un broadcast
receiver. L'action à préciser dans le filtre d'Intent du receveur est android.provider.Telephony.SMS_RECEIVED:
<receiver android:name=".SMSBroadcastReceiver">
<intent-filter>
<action android:name="android.provider.Telephony.SMS_RECEIVED"/>
</intent-filter>
</receiver>

Connectivité
Téléphonie: Envoyer et recevoir des SMS
public final class MyBroadcastReceiver extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
if
(intent.getAction().equals(android.provider.Telephony.SMS_RECEIVED))
{
String val = extra.getString("extra");
Object[] pdus = (Object[]) intent.getExtras().get("pdus");
SmsMessage[] messages = new SmsMessage[pdus.length];
for (int i=0; i < pdus.length; i++)
messages[i] = SmsMessage.createFromPdu((byte[]) pdus[i]);
}}}

Connectivité
Réseau
Le réseau peut être disponible ou indisponible, suivant que le téléphone utilise une connexion Wifi, 3G,
bluetooth, etc. Si la permission android.permission;ACCESS_NETWORK_STATE est déclarée, la classe NetworkInfo
(depuis ConnectivityManager) permet de lire l'état de la connexion réseau parmi les constantes de la classe
State: CONNECTING, CONNECTED, DISCONNECTING, DISCONNECTED, SUSPENDED, UNKNOWN.
ConnectivityManager manager =
(ConnectivityManager)getSystemService(CONNECTIVITY_SERVICE);
NetworkInfo net = manager.getActiveNetworkInfo();
if (net.getState().compareTo(State.CONNECTED)
// Connecté
• ConnectivityManager.TYPE_MOBILE: connexion mobile
• ConnectivityManager.TYPE_WIFI: wifi

Connectivité
Réseau
Le basculement entre les types de connexion est possible si la permission WRITE_SECURE_SETTINGS est
disponible. On utilise alors la méthode setNetworkPreference sur l'objet ConnectivityManager pour lui donner
l'entier correspondant au type de connexion voulu. Par exemple:
manager.setNetworkPreference(ConnectivityManager.TYPE_WIFI);
L'accès au réseau wifi est gérable depuis une application, ce qui permet d'allumer ou de couper le wifi. L'objet
WifiManager permet de réaliser cela.
WifiManager wifi = (WifiManager)getSystemService(Context.WIFI_SERVICE);
if (!wifi.isWifiEnabled())
wifi.setWifiEnabled(true);

Connectivité
Bluetooth
Le bluetooth se gère au travers de principalement 3 classes:
• BluetoothAdapter: similaire au WifiManager, cette classe permet de gérer les autres appareils bluetooth et
d'initier les communications avec ceux-ci.
• BluetoothDevice: objet représentant l'appareil distant.
• BluetoothSocket et BluetoothServerSocket: gère une connexion établie.
Pour pouvoir utiliser les fonctionnalités bluetooth, il faut activer les permissions android.permission.BLUETOOTH
et android.permission.BLUETOOTH_ADMIN pour pouvoir chercher des appareils ou changer la configuration
bluetooth du téléphone.
BluetoothAdapter bluetooth = BluetoothAdapter.getDefaultAdapter();
if (!bluetooth.isEnabled())
{Intent launchBluetooth = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivity(launchBluetooth);}

Connectivité
Bluetooth: S'associer en bluetooth
Pour pouvoir associer deux appareils en bluetooth, il faut que l'un d'eux soit accessible aux autres appareils. Pour
cela, l'utilisateur doit autoriser le mode "découverte". L'application doit donc le demander explicitement via un
Intent:
Intent discoveryMode = new
Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoveryMode.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 60);
startActivity(discoveryMode);

Connectivité
A l'inverse, si un appareil externe diffuse une annonce de découverte, il faut capturer les intents recus en
broadcast dans le mobile:
public final class BluetoothBroadcastReceiver extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
BluetoothDevice appareil = null;
if (action.equals(BluetoothDevice.ACTION_FOUND))
appareil = (BluetoothDevice)intent.getParcelableExtra(
BluetoothDevice.EXTRA_DEVICE);
}
}

Connectivité
Enfin les appareils associés se parcourent à l'aide d'un Set<BluetoothDevice>:
Set<BluetoothDevice> s = bluetooth.getBondedDevices();
for (BluetoothDevice ap : s)
Toast.makeText(getApplicationContext(), "" + ap.getName(),
Toast.LENGTH_LONG).show();

cours.pdf

Recommandé

Recommandé

Contenu connexe

Similaire à cours.pdf

Similaire à cours.pdf (20)

Plus de merazgaammar2

Plus de merazgaammar2 (7)

cours.pdf