Développement mobile sous Android

Pr. KADIM Ayoub

a.kadim@uiz.ac.ma
Classe Intent
2
 Activités multiples
 On a vu dans les séances précédentes des exemples d’applications contenant une
seule activité.
 Cependant on peut prévoir plusieurs activités dans une application : par exemple,
dans une application de carnet d'adresses, l'activité principale est une liste de
contacts. Un clic sur un contact permet d'accéder à une autre activité pour afficher
les détails.
 Une activité A peut alors lancer une autre activité B en réponse à un événement.
 L'activité A peut transmettre des données à B.
 La deuxième activité B peut renvoyer des données à A lorsqu'elle est terminée.
 Les intents
 intent : (intention en français) est une classe pour communiquer entre les
composantes d’android (activités, services…). On a deux types :
 intent explicite : défini par l’utilisateur
 intent implicite : où le système qui s’occupe de la suite, il peut proposer un ensemble
d’application (par exemple de partage d’une image)

un pont entre les activités; un moyen pour
qu’une activité invoque une autre

L'activité peut être dans la même application
ou dans une application différente

Peut stocker des données supplémentaires à
transmettre en tant que "paramètres" à cette
activité

La deuxième activité peut " renvoyer " les
informations à l'appelante si nécessaire
 Les intents : principe

 StartActivity(intent) permet de lancer l’activité pointée par l’intent, sans prévoir un

retour.

StartActivity()
intent

Activity A Activity B
 Créer un intent (simple)
 Créer une nouvelle activité :
SecondActivity,
 Un layout se crée automatiquement
pour cette activité : activity_second
 On met un bouton dans le layout de
MainActivity dont le rôle sera de passer
à l’autre activité.
 Dans le layout activity_second on met
un TextView pour marquer qu’on est
dans la seconde activité.
 Créer un intent (simple)

 Dans MainActivity on crée la setOnclickListener du

bouton où on va créer un objet intent :
●
Dans le constructeur, on défini l’activité source et celle
de destination (getBaseContext() à la place de this,
car on est dans une classe OnclickListener)
 Puis on active l’intention avec la méthode startActivity :
bt.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent MyIntent= new
Intent(getBaseContext(),SecondActivity.class);
startActivity(MyIntent);
}
});
 Envoie d’informations avec intent

Cette fois avant d’appeler la méthode startActivity, on va rajouter de

l’information à notre objet intent via la méthode putExtra(name, value) :
myIntent.putExtra("my_info","information1");
 Chaque information à envoyer doit avoir un nom (sensible à la casse) et une
valeur (int, String ...).
 Pour récupérer cette information, on va à la seconde activité, référencer le
TextView et on appel la méthode getIntent() pour récupérer l’intent envoyé
dans un objet intent.
 Envoie d’informations avec intent

 On applique sur cet objet des méthodes

getExtrat selon le type de la valeur
(getStringExtra, getIntExtra …) puis on met
la valeur dans le TextView.
 Dans la seconde activité :
tv=findViewById(R.id.tv);
Intent i= getIntent();
String nom= i.getStringExtra("my_info");
tv.setText(nom);

"information1"
 Envoie d’informations avec intent
Pratiquer : ajouter un EditText sur lequel on ajoute du texte ; ce texte sera récupéré
et affiché dans la seconde activité.
 Intent implicite
 Dans les exemples précédents, c’était nous qui défini l’activité de destination.
L’intent est dit alors dans ce cas : « intent explicite ».
 Néanmoins , pour certains cas, on peut donner la main au système pour que lui
définisse l’activité adéquate. Dans ce cas, on parle d’un « intent implicite »
 Alors, dans un intent implicite on va dire au système le type d’action à
effectuer sur les données envoyées, et c’est à lui de définir qu’elle(s) activité(s)
va s’en occuper.
 Lors de la construction de l’intent, on n’a pas besoin de spécifier l’activité de
destination : Intent myIntent= new Intent();
 La définition du type de l’action se fait au niveau de la classe intent via la
méthode setAction()
myIntent.setAction(Intent.ACTION_DIAL);
//DIAL: composeur numéro téléphoniques
 Intent implicite
➢ NB : Chaque activité développée dans les applications
installées définie les actions qu’elle peut effectuer dans
le fichier manifeste correspondant, dans
 <intent-filter>
 Pour envoyer les données, on utilise la méthode
setData() qui demande un Uri (Uniform Ressource
Identifier) pour identifier la ressource à envoyer.
 Et pour que le numéro envoyé soit traité en tant que
téléphonique on doit le transformer au format Uri
correspondant. On créer alors notre Uri ainsi :
Uri myUri= Uri.parse("tel:"+et.getText().toString());
myIntent.setData(myUri);
startActivity(myIntent);
 Intent avec retour
 StartActivity() permet d’activer l’intent sans prévoir un retour
 StartActivityForResult() permet de prévoir une réponse en retour (ex. Marquer un
message comme lu)
intent
StartActivity()

StartActivityForResult()

Activity A Activity B
intent
setResult()
OnActivityResult()
 Intent avec retour : Exemple pratique
 startActivityForResult() n’est plus supportée car il présentait certains problèmes en
cas de non appel de la fonction call back de récupération onActivityResult().
 ActivityResultLaucher est une classe qui gère les méthodes appelées au retour à
l’activité.
 Pour l’utiliser on en crée une instance en précisant le type générique comme intent :
ActivityResultLauncher<Intent> myARL
 On appel registerForActivityResult() avec deux paramètres (objets) : le premier un
un objet contract précisant qu’il s’agit de StartActivityForResult, et l’autre la call back
à appliquer au retour :
ActivityResultLauncher<Intent> myARL= registerForActivityResult(
new ActivityResultContracts.StartActivityForResult(),
new ActivityResultCallback<ActivityResult>() {
@Override
public void onActivityResult(ActivityResult result) {
Toast.makeText(MainActivity.this,"Activity back",
Toast.LENGTH_LONG).show(); } });
 Intent avec retour : Exemple pratique
 Au mainActivity dans setOnClickListener du bouton, on lance le launcher par la
méthode launch() avec comme paramètre l’intent (car on l’a donné comme type
générique) :
myARL.launch(new Intent(getBaseContext(),SecondActivity.class));

 Maintenant dans la seconde activité on ajoute un EditText et un bouton

 Au click sur le bouton on récupère le texte saisi et on l’affiche au retour  
 On crée un Intent et on y met l’information par la méthode putExtra
 On met l’intent comme résultat par la commande setResult(code, intent)
et = findViewById(R.id.et);
String texte = et.getText().toString();

Intent myIntentR = new Intent();

myIntentR.putExtra("texte", texte);
setResult(RESULT_OK, myIntentR);
finish();
 Intent avec retour : Exemple pratique
 On retourne maintenant à MainActivity et dans la méthode callback de retour :
●
on récupère l’intent de retour : Intent myIntentR = result.getData();
●
On récupère le texte envoyé  texte_recu = myIntentR.getStringExtra("texte");
●
On récupère aussi le code du résultat : int res = result.getResultCode();
●
et on l’affiche dans un TextView avec le code du résultat
//l'ActivityResultLauncher:
ActivityResultLauncher<Intent> myARL= registerForActivityResult(
new ActivityResultContracts.StartActivityForResult(),
new ActivityResultCallback<ActivityResult>() {
@Override
public void onActivityResult(ActivityResult result) {
int res = result.getResultCode();
Intent data = result.getData();
String texte_recu = data.getStringExtra("title");
tv.setText("texte= "+texte_recu+ " , code= "+res);
}
}
);
Intent avec retour : Exemple pratique
 Pratiquer
 Créer une application avec deux activités :
●
une avec un bouton « modifier titre », au click il envoi à la seconde
●
l’autre qui lit la saisie d’un EditText et l’envoi en retour
●
À l’arrivée, on applique le texte retourné comme titre de l’activité (méthode
setTitle())
●
Si l’utilisateur n’a rien saisi (bouton retour) on affiche un toast