Cours développement d’application mobile

native

Chapitre3: Vie d’une

Application

Hend Ben Ayed kharrat

2023-2024
 Ordre du Jour
• Vues, événements et écouteurs

• Applications et activités, manifeste

• Cycles de vie

2
Vues et activités

3
Obtention des vues
La méthode setContentView charge une mise en page (layout) sur l’écran. Ensuite
l’activité peut avoir besoin d’accéder aux vues:

Pour cela, il faut obtenir l’objet Java correspondant.

1. findViewById:

EditText nom = findViewById(R.id.edt_nom);

2. View Binding : Android Studio génère automatiquement une classe de liaison
pour chaque fichier de mise en page. Les layout views sont accessibles depuis le
code à l'aide de View Binding sans utiliser findViewById() .

4
Propriétés des vues

La plupart des vues ont des setters et getters Java pour leurs
propriétés XML. Par exemple TextView.
En XML :
<TextView android:id="@+id/titre"
android:lines="2"
android:text="@string/debut" />

En Java :
TextView tvTitre = findViewById(R.id.titre);
tvTitre.setLines(2);
tvTitre.setText(R.string.debut);

Consulter leur documentation pour les propriétés,

qui sont extrêmement nombreuses.
5
Actions de l’utilisateur
Prenons l’exemple de ce Button. Lorsque l’utilisateur appuie dessus,
cela déclenche un événement «onClick», et appelle
automatiquement la méthode Valider de l’activité.
<Button
android:id="@+id/btn_valider"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/valider"
android:onClick="Valider" />

Il faut définir la méthode Valider dans l’activité :

public void Valider(View btn) {
...
}

6
Définition d’un écouteur
Il y a une autre manière de définir une réponse à un clic : un
écouteur (listener).

C’est une instance de classe qui possède la méthode public

void onClick(View v) ainsi que spécifié par l’interface
View.OnClickListener.
Cela peut être :
• une classe privée anonyme,
• une classe privée ou public dans l’activité,
• l’activité elle-même.
Dans tous les cas, on fournit cette instance en paramètre à la
méthode setOnClickListener du bouton :
btn.setOnClickListener(ecouteur);

7
GESTION DES ÉVÈNEMENTS : LES « LISTENERS »

La gestion des évènements est assurée par des interfaces Java, dont
le scénario est:

1 Associer à l’objet sur lequel on veut

gérer un ou plusieurs évènements
l’interface adéquate,et on redéfinit
les méthodes de cette dernière avec
le code Java qui sera exécuté le
moment ou l’évènement se produit.
2. l’interface reste à l’écoute des
éventuels évènements.
3. un certain évènement compatible se
produit.
4. L’interface exécutera alors le code
contenu dans la méthode adéquate.

8
Écouteur privé anonyme
Il s’agit d’une classe qui est définie à la volée, lors de l’appel à
setOnClickListener. Elle ne contient qu’une seule méthode.

Button btn = findViewById(R.id.btn_valider);

btn.setOnClickListener(
new View.OnClickListener() {
public void onClick(View btn) {
// faire quelque chose
}
});

Dans la méthode onClick, il faut employer la syntaxe

MonActivity.this pour manipuler les variables et
méthodes de l’activité sous-jacente.

9
Écouteur privé
Cela consiste à définir une classe privée dans l’activité ; cette classe
implémente l’interface OnClickListener ; et à en fournir une
instance en tant qu’écouteur.

private class EcBtnValider implements OnClickListener {

public void onClick(View btn) {
// faire quelque chose
}
};
public void onCreate(...) {
...
Button btn = findViewById(R.id.btn_valider);
btn.setOnClickListener(new EcBtnValider());
}

10
L’activité elle-même en tant qu’écouteur
Il suffit de mentionner this comme écouteur et d’indiquer qu’elle
implémente l’interface OnClickListener.

public class EditActivity extends

AppCompatActivity implements
OnClickListener {
public void onCreate(...) { ...
Button btn = findViewById(R.id.btn_valider);
btn.setOnClickListener(this);
}
public void onClick(View btn) {
// faire quelque chose
}

Ici, par contre, tous les boutons appelleront la même méthode.

11
Distinction des émetteurs

Dans le cas où le même écouteur est employé pour plusieurs vues,

il faut les distinguer en se basant sur leur identitifiant

obtenu avec getId() :

public void onClick(View v) { switch (v.getId())

{ case R.id.btn_valider:
... //faire quelque chose
break;
case R.id.btn_effacer: ... // faire
quelque chose

break; }
}
12
Événements des vues courantes

Voici quelques exemples :

Button : onClick lorsqu’on appuie sur le bouton,

Spinner : OnItemSelected quand on choisit un élément,

RatingBar : OnRatingBarChange quand on modifie la note,

etc.

Heureusement, dans le cas de formulaires, les actions sont

majoritairement basées sur des boutons.

13
Liste certaines interfaces des Listener Graphiques

14
Vues et activités

15
Composition d’une Application

Une application est composée d’une ou plusieurs activités.

Chacune gère un écran d’interaction avec l’utilisateur et
est définie par une classe Java.
Une application complexe peut aussi contenir :
des services :
ce sont des processus qui tournent en arrière-
plan,
des fournisseurs de contenu : ils représentent
une sorte de base de données
des récepteurs d’annonces : pour gérer des
événements globaux envoyés par le système à
toutes les applications.
16
Déclaration d’une application
Le fichier AndroidManifest.xml déclare les éléments
d’une application, avec un ’.’ devant le nom de classe des
activités :

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

<manifest ... >
<application android:icon="@drawable/app_icon.png" ...>
<activity android:name=".MainActivity"
... />
<activity android:name=".EditActivity"
... />…
</application>
</manifest>

<application> est le seul élément sous la racine

<manifest> et ses filles sont des <activity>.
17
Pierre Nerzic
Sécurité des applications (pour info)
Chaque application est associée à un UID
(compte utilisateur Unix) unique dans le
système. Ce compte les protège les unes des
autres. Cet UID peut être défini dans le
fichier AndroidManifest.xml.

Définir l’attribut android:sharedUserId

avec une chaîne identique à une autre
application, et signer les deux applications
avec le même certificat, permet à l’une
d’accéder à l’autre.
18
Sécurité des applications (pour info)

Pour le même ID utilisateur, vous devez définir sharedUserLabel et

sharedUserId dans le fichier AndroidManifest.xml avec la même valeur
dans différentes applications.

19
Autorisations d’une application
Une application doit déclarer les autorisations dont elle a besoin :
accès à internet, caméra, carnet d’adresse, GPS, etc.
Cela se fait en rajoutant des élements dans le manifeste :
<manifest ... >
<uses-permission
android:name="android.permission.INTERNET" />
...
</manifest>

NB: les premières activités que vous créerez

n’auront besoin d’aucune permission.

20
 Démarrage d’une application
L’une des activités est marquée comme démarrable de l’extérieur :

<activity android:name=".MainActivity" ...>

<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category
android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>

Un <intent-filter> déclare les conditions de démarrage d’une activité, ici il

dit que c’est l’activité principale.
Définie dans le AndroidManifest.xml dans la balise
<activity>

21
Exemple

22
Activity

Une 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.
Une activité peut être avec ou sans interface utilisateur. Il est
possible d’avoir plusieurs activités dans le même programme.
Elle doit toujours être déclarée dans le fichier Manifest.xml.
<activity android:name=".AffichMessage"
android:label="@string/title_activity_affich_message"
android:parentActivityName=".MainActivity"
android:theme="@style/AppTheme">
</activity>
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity> 23
Activity
Une activité n’est pas linéaire, elle est soumise à plusieurs
événements. Chaque événement est représenté dans une méthode.

Une activité (Activity)= une IHM pour un cas d’utilisation (cf cours
UML).
Par exemple pour une application d’envoi de SMS :
Une activité pour choisir un contact dans le répertoire
Une activité pour la saisie de message
Une activité pour afficher le journal des envois
Du point de vue opérationnel :
Une activité doit hériter de la classe android.app.Activity
Une activité est indépendante des autres activités mais :

Il faut désigner une activité de départ (celle qui sera utilisé en 1er)
Il faut chainer les activités (une activité doit activer la suivante).

24
 Démarrage d’une activité et Intents
Les activités sont démarrées à l’aide d’Intents.
Pour faire communiquer les deux activés il faut
passer par un Intent. Ce dernier représente
l’intention de faire quelque chose, et permet à
l’activité principale de lancer une autre activité

Une application à la possibilité de lancer certaines activités d’une

autre application, celles qui ont un intent-filter.

La navigation entre les écrans peut se faire de deux

façons différentes : soit explicitement, soit implicitement.
Dans les deux cas, l’ordre de changement d’activité est
véhiculé par un objet de type Intent .
 Un Intent ne contient pas obligatoirement
explicitement le composant qui va le gérer. Dans ce cas
c'est un Intent implicite.
 Si l'Intent indique explicitement la classe du composant
qui va le gérer c'est un Intent explicite
25
Intents Explicites / Intents Implicites
Les intents explicites
Créer un intent explicite est très simple puisqu’il suffit de
donner un Context qui appartienne au package où se
trouve la classe de destination :
Intent intent = new Intent(Context context, Class<?> cls);
Il existe ensuite deux façons de lancer l’intent, selon qu’on veuille
que le composant de destination nous renvoie une réponse ou
pas.

Les intents implicites

Ici, on fera en sorte d’envoyer une requête à un

destinataire, sans savoir qui il est, et d’ailleurs on s’en fiche
tant que le travail qu’on lui demande de faire est effectué.
Ainsi, les applications destinataires sont soit fournies par
Android, soit par d’autres applications téléchargées sur le
Play Store par exemple

26
Structure d'un Intent
Un objet Intent contient les information (champs) suivantes:
 le nom du composant ciblé (facultatif)
 l'action à réaliser, sous forme de chaine de caractères
 une catégorie pour cibler un type d'application
 les données: contenu MIME et URI
 des données supplémentaires (extra) sous forme de
paires
clef/valeur
 des drapeaux (informations supplémentaires)
Exemples de méthodes utilisés par l’Intent
– addCategory(String category) ajout de catégories
– putExtra(String key,value)
– setFlags(flags) permission sur les données, relation activité/BackStack

Création d'un Intent

– Intent(Context, Class) pour l'appels explicite
– Intent(String action, URI) pour l'appel implicite 27
Actions d’Intent prédéfinies
ACTION_MAIN: action principale
ACTION_VIEW: visualiser une donnée
ACTION_ATTACH_DATA: attachement de donnée
ACTION_EDIT: Edition de donnée
ACTION_PICK: Choisir un répertoire de donnée
ACTION_CHOOSER: menu de choix pour l'utilisateur –
-EXTRA_INTENT contient l'Intent original,
-EXTRA_TITLE le titre du menu
ACTION_GET_CONTENT: obtenir un contenu suivant un type MIME
ACTION_SEND: envoyé un message (EXTRA_TEXT|EXTRA_STREAM) à un destinataire
non spécifié
-ACTION_SEND_TO: on spécifie le destinataire dans l'URI
ACTION_INSERT: on ajoute un élément vierge dans le répertoire spécifié par l'URI
ACTION_DELETE: on supprime l’élément désigné par l'URI
ACTION_PICK_ACTIVITY: menu de sélection selon l'EXTRA_INTENT mais ne lance pas
l'activité
ACTION_SEARCH: effectue une recherche etc...

28
Démarrage d’une activité et Intents
Exemple si l’activité principale demande de lancer l’activité
d’affichage par exemple.

1. Dans la méthode envoiMessage() de la classe Principale

créez une intention,
Intent intent = new Intent(this, AffichMessage.class);
deux arguments un objet de type Context qui fait référence à
l’application qui crée l’intention, le nom (de la classe) de
l’activité qui reçoit l’intention.
Comme le Intent peut être utilisé pour faire communiquer deux
applications, il ne suffit pas de préciser uniquement le
nom de l’activité qui le crée mais il faut également définir
l’application qui l’invoque.
2. Lancez l’activité
startActivity(intent);
29
Lancement d’une activité par programme

Soit une application contenant deux activités : Activ1 et

Activ2. La première lance la seconde par :

Intent intent = new Intent(this, Activ2.class);

startActivity(intent);

L’instruction startActivity démarre Activ2. Celle-ci se met

devant Activ1 qui se met alors en sommeil.
Ce bout de code est employé par exemple lorsqu’un bouton, un
menu, etc. est cliqué.
Seule contrainte : que ces deux activités soient déclarées
dans AndroidManifest.xml.
30
 Lancement d’une application Android
Un Intent est composé de trois attributs essentiels qui participent
à l’identification de l’activité à afficher :• Action | • Data/Type
|• Category
• action : spécifie ce que l’Intent demande: VIEW pour afficher
quelque chose, EDIT pour modifier une information,SEARCH.,CALL. .
• données : selon l’action, ça peut être un numéro de téléphone
(action_call), l’identifiant d’une information. . .
• catégorie : information supplémentaire sur l’action, par
exemple,...LAUNCHER pour lancer une application,HOME,MAIN.
Il n’est pas possible de montrer toutes les possibilités, mais par
exemple, voici comment ouvrir le navigateur sur un URL
String url = "https://perso.univ-rennes1.fr/pierre.nerzic/Android";
intent = new Intent(Intent.ACTION_VIEW,Uri.parse(url));
startActivity(intent);

L’action VIEW avec un URI (généralisation d’un URL) est interprétée

par Android, cela fait ouvrir automatiquement le navigateur. 31
Lancement d’une activité d’une autre application
Soit une seconde application dans le package tn.isetr.appli2.
Une activité peut la lancer ainsi :
intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_LAUNCHER);
intent.setClassName(
“tn.isetr.appli2",
"tn.isetr.appli2.MainActivity");
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);

Cela consiste à créer un Intent d’action MAIN et

de catégorie LAUNCHER pour la classe MainActivity
de l’autre application.
32
Application

33
Fonctionnement d’une application
Au début, le système Android lance l’activité qui est
marquée action=MAIN et catégorie=LAUNCHER dans
AndroidManifest.xml.

Ensuite, d’autres activités peuvent être démarrées. Chacune

se met «devant » les autres comme sur une pile. Deux cas
sont possibles :
La précédente activité se termine, on ne revient
pas dedans. Par exemple, une activité où on tape
son login et son mot de passe lance l’activité
principale et se termine.
La précédente activité attend la fin de la
nouvelle car elle lui demande un résultat en retour.
Exemple : une activité de type liste d’items lance une
activité pour éditer un item quand on clique
longuement dessus, mais attend la fin de l’édition
pour rafraîchir la liste. 34
Lancement sans attente

Rappel, pour lancer Activ2 à partir de Activ1 :

Intent intent = new Intent(this, Activ2.class);
startActivity(intent);

On peut demander la terminaison de this après lancement de

Activ2 ainsi :
Intent intent = new Intent(this, Activ2.class);
startActivity(intent);
finish();

finish() fait terminer l’activité courante. L’utilisateur

ne pourra pas faire back dessus, car elle disparaît de la
pile.
35
Transport d’informations dans un Intent
Les Intent servent aussi à transporter des informations d’une
activité à l’autre : les extras.
Voici comment placer des données dans un Intent :

Intent intent = new Intent(this, DeleteInfoActivity.class);

intent.putExtra("idInfo", idInfo);
intent.putExtra("hiddencopy", hiddencopy);
startActivity(intent);

putExtra(nom, valeur) rajoute un couple (nom,

valeur) dans l’intent.
La valeur doit être sérialisable : nombres, chaînes et
structures simples.

36
Extraction d’informations d’un Intent

Ces instructions récupèrent les données d’un Intent:

Intent intent = getIntent();
Integer idInfo = intent.getIntExtra("idInfo", -1);
bool hidden = intent.getBooleanExtra("hiddencopy", false);

getIntent() retourne l’Intent qui a démarré cette activité.

getTypeExtra(nom, valeur par défaut) retourne la valeur de ce
nom si elle en fait partie, la valeur par défaut sinon.

Il est très recommandé de placer les chaînes dans des constantes,

dans la classe appelée :
public static final String EXTRA_IDINFO = "idInfo";
public static final String EXTRA_HIDDEN = "hiddencopy";

22/ 47 37
Lancement avec attente de résultat
Pendant que les données sont transférées
vers SecondActivity, il n'y a aucun moyen
pour les données d'être transférées vers
SecondActivity d’être retourné à la première
activité (que nous appellerons
MainActivity).
Une activité est démarrée en tant que sous-activité en créant un
ActivityResultLauncher
Une instance ActivityResultLauncher est créée par un appel à la
méthode registerForActivityResult() et est passé à un gestionnaire de
rappel ActivityResultCallback sous la forme d'un lambda.

…..

38
Ce gestionnaire sera appelé et transmettra les données de retour
lorsque le retours de sous-activités.
Une fois qu'une instance ActivityResultLauncher a été créée, elle peut
être appelée avec une intention paramétré pour lancer la sous-activité.
Pour renvoyer des données à l'activité parent, la sous-
activité doit implémenter la méthode finish() dont le
but consiste à créer un nouvel objet d'intention
contenant les données à renvoyer, puis à appeler la
méthode setResult() de l’activité englobante, passant
par un code de résultat et l'intention contenant les
données de retour.
Le code résultat est généralement RESULT_OK ou
RESULT_CANCELED, mais il peut également s'agir d'une
valeur personnalisée soumise aux préférences du
développeur.Si une sous-activité plante, l'activité
parent recevra un code de résultat
RESULT_CANCELED: (dans SecondActivity)
 DIFFUSER UNE INFORMATION

Il est 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.

Intent broadcast = new Intent("demo.android.broadcast");

broadcast.putExtra("extra", "msgExtra");
sendBroadcast(broadcast);

On peut récupérer les données à l'aide de la méthode getExtras

dans l'objet Bundle qui est dans l'Intent:

Bundle extra = intent.getExtras();

String val = extra.getString("extra");

41
Contexte d’application

Pour finir sur les applications, il faut savoir qu’il y a un objet

global vivant pendant tout le fonctionnement d’une application :
le contexte d’application. Voici comment le récupérer :

Application context = this.getApplicationContext();

Par défaut, c’est un objet neutre ne contenant que des informations

Android.
Il est possible de le sous-classer afin de stocker des variables globales
de l’application.

42
Définition d’un contexte d’application
Pour commencer, dériver une sous-classe de Application :
public class MonApplication extends Application
{
// variable globale de l'application
private int varglob;

public int getVarGlob() { return varglob; }

// initialisation du contexte
@Override public void onCreate() {
super.onCreate();
varglob = 3;
}
}

43
Définition d’un contexte d’application, suite
Ensuite, la déclarer dans AndroidManifest.xml, dans l’attribut
android:name de l’élément <application>, mettre un point
devant :
<manifest xmlns:android="..." ...>
<application android:name=".MonApplication"
android:icon="@drawable/icon"
android:label="@string/app_name">
...

44
 Définition d’un contexte d’application, fin
Enfin, l’utiliser dans n’importe laquelle des activités :
// récupérer le contexte d'application
MonApplication context =
(MonApplication) this.getApplicationContext();

// utiliser la variable globale

... context.getVarGlob() ...

Remarquez la conversion de type du contexte.

26/ 47 45
Activité

46
Présentation

Voyons maintenant comment fonctionnent les activités.

• Démarrage (à cause d’un Intent)

• Apparition/masquage sur écran

• Terminaison
Une activité se trouve dans l’un de ces états :
•active (resumed) : elle est sur le devant, l’utilisateur
peut jouer avec,
•en pause (paused) : partiellement cachée et inactive,
car une autre activité est venue devant,
•stoppée (stopped) : totalement invisible et inactive,
ses variables sont préservées mais elle ne
tourne plus. 47
Cycle de vie d’une activité
Ce diagramme résume les changement d’états d’une activité :

48
Événements de changement d’état
La classe Activity reçoit des événements de la part du système
Android, ça appelle des fonctions appelées callbacks.
Exemples :

onCreate Un Intent arrive dans l’application, il déclenche

la création d’une activité, dont l’interface.

onPause Le système prévient l’activité qu’une autre activité est

passée devant, il faut enregistrer les informations au
cas où l’utilisateur ne revienne pas.

49
 onCreate()

Cette méthode est appelée à la création d’une activité.

Elle permet de l’initialiser .
C’est ici que l’interface graphique est spécifiée
Si c’est la première activité d’une application, cette
méthode est donc appelé quand l’utilisateur exécute
l’application
Méthode utilisé pour initialiser :
La vue XML
Si nécessaire, les fichiers/données temporaires.

50
 onStart()

Cette méthode est appelée quand l’application est

démarrée
Exécutée après chaque onCreate() ou onRestart()
si nécessaire, recharger les données sauvegardées
durant le dernier arrêt.

onRestart()

méthode exécutée lorsque on redémarre l’activité

après un arrêt (provoqué par appel de la méthode
stop())
Appelée quandl’applicationredevientvisible ou
repasse en premier plan après un arrêt prolongé.
51
onResume()

Méthode exécuté après chaque appel de la méthode

onStart()
Méthode exécutée à chaque passage en premier plan
de l’activité (si pasdestop())

onPause()

Méthode exécutée à chaque fois que :

L’utilisateur passeà une autre activité,
L’utilisateur demande un finish() sur cette activité
Le système a besoin de libérer de la mémoire.
Remarquer que la méthode est exécutée
systématiquement après chaque onStop().
Appelée quandl’applicationpasse enarriere--‐-plan et
qu’une autre application se met devant.
52
onStop()

Méthode exécutée avant chaque mise en sommeil

(l’application n’estplusvisible).
Méthode exécutée avant chaque onDestroy().
Libération des ressources.

onDestroy()

Méthode exécutée lors du kill/arrêt de l’activité

onCreate() devra à nouveau être exécuté pour obtenir à
nouveau l’activité.

53
Squelette d’activité

public class EditActivity extends Activity

{
@Override
public void onCreate(Bundle savedInstanceState) {
// obligatoire
super.onCreate(savedInstanceState);

// met en place les vues de cette activité

setContentView(R.layout.edit_activity);
}
}

@Override signifie que cette méthode remplace celle

héritée de la superclasse. Il faut quand même l’appeler sur
super en premier.
54
Terminaison d’une activité
Voici la prise en compte de la terminaison définitive d’une
activité, avec la fermeture d’une base de données :
@Override
public void onDestroy() {
// obligatoire
super.onDestroy();

// fermer la base
db.close();
}

55
Pause d’une activité
Cela arrive quand une nouvelle activité passe devant, exemple : un
appel téléphonique. Il faut libérer les ressources qui consomment de
l’énergie (animations, GPS. . . ).

@Override public void onPause() {

super.onPause();
// arrêter les animations sur l'écran
...
}
@Override public void onResume() {
super.onResume();
// démarrer les animations
...
}
56
Arrêt d’une activité

Cela se produit quand l’utilisateur change d’application

dans le sélecteur d’applications, ou qu’il change
d’activité dans votre application. Cette activité n’est
plus visible et doit enregistrer ses données.
Il y a deux méthodes concernées :
•protected void onStop() : l’application est
arrêtée, libérer les ressources,
•protected void onStart() : l’application
démarre, allouer les ressources.
Il faut comprendre que les utilisateurs peuvent changer
d’application à tout moment. La votre doit être capable
de résister à ça.

57
Récapitulatif cycle de vie

Vidéos explicatives (pour plus d’informations) :

•DEVELOPPER SOUS ANDROID - 21 - Activity Lifecycle par LES TEACHERS DU NET
•Comprendre le cycle de vie d'une activité android en 9m par Franck Mbeutcha 58
Enregistrement de valeurs d’une exécution à l’autre
Il est possible de sauver des informations d’un lancement à l’autre
de l’application (certains cas comme la rotation de l’écran ou une
interruption par une autre activité), dans un Bundle. C’est un
container de données quelconques, sous forme de couples (“nom”,
valeur).
static final String
ETAT_SCORE = "ScoreJoueur"; // nom
private int mScoreJoueur = 0; // valeur

@Override
public void onSaveInstanceState(Bundle etat)
{
// enregistrer l'état courant
etat.putInt(ETAT_SCORE, mScoreJoueur);
super.onSaveInstanceState(etat);
}

59
Restaurer l’état au lancement
La méthode onRestoreInstanceState reçoit un paramètre de
type Bundle (comme la méthode onCreate, mais dans cette
dernière, il peut être null). Il contient l’état précédemment
sauvé.

@Override
protected void onRestoreInstanceState(Bundle etat)
{ super.onRestoreInstanceState(etat);
// restaurer l'état précédent
mScoreJoueur = etat.getInt(ETAT_SCORE);
}

Ces deux méthodes sont appelées automatiquement

(sorte d’écouteurs), sauf si l’utilisateur tue
l’application. Cela permet de reprendre l’activité là où
elle en était.
60
Intent IMPLICITE

61
 INTENTS IMPLICITES_APPEL TELPH

 Pour passer d'une activité courante à une nouvelle activité, il

faut écrire le code :

Button b = (Button)findViewById(R.id.Button01);
b.setOnClickListener(new OnClickListener() { public void
onClick(View v) {
Uri telnumber = Uri.parse("tel:0248484000");
Intent call = new Intent(Intent.ACTION_DIAL, telnumber);
startActivity(call);
} });

 Il ne faut pas oublier d’ajouter les permissions nécessaire a u

fichier manifest.xml

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

62
 LES INTENTS IMPLICITES- ENVOIE DE MAIL

Intent emailIntent = new

Intent(android.content.Intent.ACTION_SEND);
String[] recipients = new String[]{"[email protected]", "",};
emailIntent.putExtra(android.content.Intent.EXTRA_EMAIL,
recipients);
emailIntent.putExtra(android.content.Intent.EXTRA_SUBJECT, "Test");
emailIntent.putExtra(android.content.Intent.EXTRA_TEXT,
"Message");
emailIntent.setType("text/plain");
startActivity(Intent.createChooser(emailIntent, "Send mail...")); finish();

63
LES INTENTS IMPLICITES- VOIR TOUS LES
CONTACTS

String myData = "content://contacts/people/"; Intent

myActivity2 = new
Intent(Intent.ACTION_VIEW,
Uri.parse(myData));
startActivity(myActivity2);

64
LES INTENTS IMPLICITES- VOIR UN CONTACT
PARTICULIER

String myData = "content://contacts/people/2"; Intent

myActivity2 = new
Intent(Intent.ACTION_VIEW,
Uri.parse(myData));
startActivity(myActivity2);

65
LES INTENTS IMPLICITES- EDITER UN CONTACT

String myData = "content://contacts/people/2"; Intent

myActivity2 = new
Intent(Intent.ACTION_EDIT,
Uri.parse(myData));
startActivity(myActivity2);

66
 LES INTENTS IMPLICITES- RECHERCHE GOOGLE

Intent intent = new Intent

(Intent.ACTION_WEB_SEARCH );
intent.putExtra(SearchManager.QUERY,
"papillons");
startActivity(intent);

67
 LES INTENTS IMPLICITES- ENVOIE D’UN SMS

Intent intent = new Intent(

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

68
 LES INTENTS IMPLICITES- AFFICHER PHOTOS

Intent myIntent = new Intent();

myIntent.setType("image/pictures/*");
myIntent.setAction(Intent.ACTION_GET_CONTENT);
startActivity(myIntent);

69
 LES INTENTS IMPLICITES- VOIR PAGE WEB

String myData = "http://www.youTube.com";

Intent myActivity2 = new
Intent(Intent.ACTION_VIEW,
Uri.parse(myData));
startActivity(myActivity2);

 Il ne faut pas oublier d’ajouter les permissions

nécessaires dans le fichier manifeste :
<uses-permission
android:name="android.permission.INTERNET " >
</uses-permission>

70
 LES INTENTS IMPLICITES- GEOLOCALISATION PAR
COORDONNÉES LONG/LAT

String geoCode ="geo:41.5020952,-81.6789717";

Intent intent = new Intent(Intent.ACTION_VIEW,
Uri.parse(geoCode));
startActivity(intent);

•Il ne faut pas oublier d’ajouter les permissions nécessaires

dans le fichier manifeste :

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

71
 LES INTENTS IMPLICITES- LANCER MUSIC
PLAYER

Intent myActivity2 = new

Intent("android.intent.action.MUSIC_PLAYER");
startActivity(myActivity2);

72
 LES INTENTS IMPLICITES- ECOUTER CHANSON
SUR CARTE SD

Intent myActivity2 = new

Intent(android.content.Intent.ACTION_VIEW);
Uri data = Uri.parse("file:///sdcard/tiratata.mp3");
String type = "audio/mp3";
myActivity2.setDataAndType(data, type);
startActivity(myActivity2);

73
LES INTENTS IMPLICITES- PARAMETRES
SYSTEME

Intent intent = new

Intent(android.provider.Settings.ACTION_SETTINGS);
startActivity(intent);

74