Chapitre 1: “Activities” et “Intents”Partie 1

Ce chapitre couvre les sujets suivants:

• Déclarer une activité

• Démarrer une nouvelle activité avec un objet “intent”

• Basculer entre les activités

• Passer des données à une autre activité

• Retourner un résultat d'une activité

IntroductionLe SDK Android fournit un outil puissant pour programmer des appareils mobiles, et la meilleure façon de maîtriser un tel outil est de se lancer directement.

Les activités sont le bloc de construction fondamental de la plupart des applications Android, car la classe d'activité fournit l'interface entre l'application et l'écran. La plupart des applications Android auront au moins une activité, voire plusieurs (mais elles ne sont pas obligatoires). Une application de service en arrière-plan ne nécessitera pas nécessairement une activité s'il n'y a pas d'interface utilisateur.

Ce chapitre explique comment déclarer et lancer des activités au sein d'une application et comment gérer plusieurs activités à la fois en partageant des données entre elles, en leur demandant des résultats et en appelant une activité depuis une autre.

Ce chapitre explore également brièvement l'objet d'intention (Intent), qui est souvent utilisé en conjonction avec des activités. Les intentions peuvent être utilisées pour transférer des données entre les activités de votre propre application, ainsi que dans des applications externes, telles que celles incluses avec le système d'exploitation Android (un exemple courant serait d'utiliser une intention pour lancer le navigateur Web par défaut).

Déclarer une activitéLes activités et autres composants d'application, tels que les services, sont déclarés dans le fichier AndroidManifest.xml. Déclarer un nœud d'activité est la façon dont nous informons le système d'exploitation de notre classe d'activité et comment elle peut être demandée. Par exemple, une application indiquera généralement qu'au moins une activité doit être visible sous forme d'icône sur le bureau et servir de point d'entrée principal à l'application.

Lancez Android Studio, qui ouvre la boîte de dialogue “Welcome to Android Studio”:

Cliquez sur “New Project” et sélectionnez l'option “Empty Activity”. Cliquez sur “next”.

Entrez un nom d'application; pour cet exemple, nous avons utilisé "TP1_Activity". Sélectionnez le langage Java.

Après avoir terminé l'assistant, Android Studio créera les fichiers du projet. Pour cet exemple, les fichiers que nous examinerons sont MainActivity.java, activity_main.xml et AndroidManifest.xml.

Si vous jetez un œil au fichier MainActivity.java, vous vous rendrez compte qu'il est assez basique.C'est parce que nous avons choisi l'option "Empty Activity". Maintenant, regardez le fichier AndroidManifest.xml. C'est là que nous déclarons réellement l'activité. Dans l'élément <application> se trouve l'élément <activity>:

Lorsque vous regardez ce fichier XML dans Android Studio, vous remarquez que l'élément label affiche le texte réel (TP1_Activity dans ce cas) tel que défini dans le fichier de ressources res/values/strings.xml.

La déclaration d'une activité consiste simplement à déclarer l'élément <activity> et à spécifier le nom de la classe d'activité avec l'attribut android:name. En ajoutant l'élément <activity> au AndroidManifest.xml, nous spécifions notre intention d'inclure ce composant dans notre application. Toutes les activités (ou tout autre composant d'ailleurs) qui ne sont pas déclarées dans le manifeste ne seront pas disponibles pour l'application. Tenter d'accéder ou d'utiliser un composant non déclaré entraînera la levée d'une exception au moment de l'exécution.

Dans le code précédent, il y a un autre attribut :android:label. Cet attribut indique le titre affiché à l'écran, ainsi que l'icône s'il s'agit de l'activité Launcher.

Créer un appareil virtuel AndroidSi vous avez déjà créé un appareil virtuel, ignorez cette étape.

Cliquez sur le bouton Gestionnaire AVD (AVD Manager). Une nouvelle fenêtre apparaît.

Cette fenêtre affiche tous les AVD disponibles qui existent sur votre machine. Pour le moment, aucun n'est encore disponible. Au milieu de l'écran, cliquez sur "Create Virtual Device" pour afficher la fenêtre “Select Hardware”. Dans cette fenêtre, vous pouvez sélectionner le type d'appareil que vous souhaitez que votre AVD émule.

Vous pouvez choisir l'appareil que vous voulez. Je choisirai Pixel 2, c'est un excellent choix car il émule étroitement un véritable appareil utilisé par beaucoup de gens.

Il y a quelques onglets qui s'ouvriront au cours de ce processus. La plus intéressante est “Recommended”, qui affiche une liste des versions d'Android que Google vous recommande d'utiliser lors du test de vos applications. Actuellement, ces versions sont grisées car aucune d'entre elles n'est installée sur votre machine. Vous pouvez changer cela en téléchargeant la dernière version d'Android recommandée par Android Studio.

Sélectionnez le premier élément du tableau et cliquez sur Télécharger dans la colonne “Release Name”. Un accord juridique apparaît décrivant les conditions que vous devez accepter si vous souhaitez utiliser Android dans l'émulateur. Sélectionnez “Accept”, puis cliquez sur “Next”. La fenêtre “Component Installer” apparaît et télécharge automatiquement la version sélectionnée d'Android.

Exécuter l'applicationEn haut d'Android Studio, il y a un bouton qui ressemble à un bouton de lecture vert, à côté d'une liste déroulante avec le nom de votre appareil. La liste déroulante vous permet de sélectionner un périphérique sur lequel exécuter TP1_Activity. Selon l'appareil que vous avez configuré, le nom devotre appareil physique ou le nom de votre AVD apparaîtra. Avec l'appareil sélectionné, cliquez sur le bouton “Run App”. Android Studio commence à créer TP1_Activity et installe l'application sur votre appareil. Lorsque Android Studio a fini de créer et d'installer, TP1_Activity apparaîtra sur votre appareil.

Démarrer une nouvelle activité avec un objet d'intention (Intent)Le modèle d'application Android peut être considéré comme un modèle orienté service, avec des activités (activities) en tant que composants et des intentions (intents) en tant que messages envoyés entre elles. Pour simplifier les choses, nous allons utiliser un objet d'intention pour démarrer l'une des applications intégrées d'Android plutôt que d'en créer une nouvelle. Nous allons créer une fonction pour montrer une intention en action et appeler cette fonction à partir d'un boutonsur notre activité principale. Ouvrez la classe MainActivity.java et ajoutez la fonction suivante:

public void launchIntent(View view) { Intent intent = new Intent(Intent.ACTION_VIEW); intent.setData(Uri.parse("https://www.google.fr/")); startActivity(intent);}

vous devez ajouter les références de bibliothèques au projet afin d'utiliser View, Intent, et Uri. ajoutez ce qui suit en haut de votre fichier java:

import android.content.Intent;import android.net.Uri;import android.view.View;

Ouvrez le fichier res/layout/activity_main.xml et remplacez le bloc <TextView /> par le XML suivant:

<Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Lancer le navigateur" android:id="@+id/btnBrowserIntent" android:onClick="launchIntent" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf="parent" app:layout_constraintTop_toTopOf="parent"/>

Lancez votre application. Lorsque vous appuyez sur le bouton “Lancer le navigateur”, vous verrez le navigateur Web par défaut s'ouvrir avec l'URL spécifiée.

Bien que simple, cette application démontre une grande partie de la puissance derrière le système d'exploitation Android. Une intention est un objet de message. Les intents peuvent être utilisés pour communiquer entre les composants de votre application ainsi qu'avec d'autres applications sur l'appareil. Dans cet exemple, nous avons demandé au système d'exploitation de démarrer toute application pouvant gérer les données que nous avons spécifiées avec la méthode setData(). (Si l'utilisateur a installé plusieurs navigateurs et aucun paramètre par défaut n'est définie, le système d'exploitation affichera une liste d'applications parmi lesquelles l'utilisateur pourra choisir.) Pour tester cela sur un périphérique physique, vous devrez peut-être installer des pilotes (drivers) pour votre périphérique (les drivers sont spécifique au fabricant du matériel). Vous devrez également activer le mode développeur sur votre appareil. L'activation du mode développeur varie en fonction de la version du système d'exploitation Android. Si vous ne voyez pas l'option Mode développeur dans les paramètres de votre appareil, ouvrez l'option “À propos du téléphone” (about) et commencez à appuyer sur Numéro de build. Après trois pressions, vous devriez voir un message Toast vous indiquant que vous êtes sur le point de devenir développeur.

ACTION_VIEW, ainsi qu'une URL dans setData(), indiquent que l'intention est d'afficher le site Web, de sorte que le navigateur par défaut est lancé (des données différentes peuvent lancer différentes applications). Dans cet exemple, nous voulons simplement ouvrir un navigateur avec l'URL spécifiée, nous appelons donc la méthode startActivity(). Il existe d'autres façons d'appeler l'intention en fonction de nos besoins.

Basculer entre les activitésSouvent, nous voudrons activer une activité à partir d'une autre activité. Bien que ce ne soit pas une tâche difficile, elle nécessitera un peu plus de configuration que les exemples précédents car elle nécessite deux activités. Nous allons créer deux classes d'activité et les déclarer toutes les deux dansle manifeste. Nous allons également créer un bouton, comme nous l'avons fait dans l'exemple précédent, pour passer à l'activité.

Étant donné que l'assistant Android Studio “New Project” a déjà créé la première activité, il nous suffit de créer la deuxième activité. Ouvrez le projet TP1_Activity et accédez à File | New | Activity | Empty Activity, comme indiqué dans cette capture d'écran:

Dans la boîte de dialogue "New Android Activity", vous pouvez modifier le nom de l'activité en "SecondActivity". Ouvrez le fichier MainActivity.java et ajoutez la fonction suivante:

public void onClickSwitchActivity(View view) { Intent intent = new Intent(this, SecondActivity.class); startActivity(intent);}

Maintenant, ouvrez le fichier activity_main.xml situé dans le dossier res/layout et ajoutez le XML suivant pour créer le bouton:

<Button android:id="@+id/btnSwitchActivity" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_centerVertical="true" android:layout_centerHorizontal="true" android:text="Lancer la deuxième activité" android:onClick="onClickSwitchActivity" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf="parent" app:layout_constraintTop_toBottomOf="@id/btnBrowserIntent"/>

Nous allons aller plus loin et ajouter un bouton à SecondActivity pour le fermer, ce qui nous ramènera à la première activité. Ouvrez le fichier SecondActivity.java et ajoutez cette fonction:

public void onClickClose(View view) { finish();}

Enfin, ajoutez le bouton “Fermer” à la mise en page/layout SecondActivity. Ouvrez le fichier activity_second.xml et ajoutez l'élément <Button> suivant:

<Button android:id="@+id/buttonClose" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Fermer" android:layout_centerVertical="true" android:layout_centerHorizontal="true" android:onClick="onClickClose" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf="parent" app:layout_constraintTop_toTopOf="parent"/>

Exécutez l'application sur votre appareil ou émulateur et voyez les boutons en action.

Le vrai travail de cet exercice se trouve dans la méthode onClickSwitchActivity(). C'est ici que nous déclarons la deuxième activité pour l'intention à l'aide de SecondActivity.class. Nous sommes allés encore plus loin en ajoutant le bouton de fermeture à la deuxième activité pour montrer une situation courante dans le monde réel: lancer une nouvelle activité, puis revenir à l'activité d'appel d'origine. Ce comportement est accompli dans la fonction onClickClose(). Tout ce qu'il fait est d'appeler finish(), mais cela indique au système d'exploitation que nous en avons terminé avec l'activité. Finish ne nous renvoie pas réellement à l'activité d'appel (ou à toute activité spécifique d'ailleurs); il ferme simplement l'activité en cours et s'appuie sur la pile arrière de l'application pour afficher la dernière activité. Si nous voulons une activité spécifique, nous pouvons à nouveau utiliser l'objet Intent et spécifier le nom de la classe d'activité lors de la création de l'Intent.

Ce changement d'activité ne fait pas une application très excitante. Notre activité ne fait que montrer comment passer d'une activité à une autre, ce qui bien sûr constituera un aspect fondamental de presque toutes les applications que nous développons.

Si nous avions créé manuellement les activités, nous aurions dû les ajouter au manifeste. L'utilisation de l'assistant New Android Activity ajoutera automatiquement les éléments nécessaires au fichier manifeste Android. Pour voir ce qu'Android Studio a fait pour vous, ouvrez lefichier AndroidManifest.xml et regardez l'élément <application>:

Une chose à noter dans le code généré automatiquement précédent est que la deuxième activité n'a pas l'élément <intent-filter>. L'activité principale est généralement le point d'entrée au démarrage de l'application. C'est pourquoi MAIN et LAUNCHER sont définis pour que le système sache quelle activité lancer au démarrage de l'application.

Passer des données à une autre activitéL'objet Intent est défini comme un objet de messagerie. En tant qu'objet de message, son objectif est de communiquer avec d'autres composants de l'application. Dans cet exemple, nous allons vous montrer comment transmettre des informations avec l’Intent et comment les extraire à nouveau.

Ouvrez activity_main.xml et ajoutez l'élément <EditText> suivant au-dessus des boutons:

<EditText android:id="@+id/editTextData" android:layout_width="match_parent" android:layout_height="wrap_content" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf="parent" app:layout_constraintTop_toTopOf="parent" app:layout_constraintBottom_toTopOf="@+id/btnBrowserIntent" />

Les éléments <Button> que nous avons créés dans les étapes précédentes ne changent pas. Maintenant, ouvrez le fichier MainActivity.java et modifiez la méthode onClickSwitchActivity() comme suit:

public void onClickSwitchActivity(View view) { EditText editText = (EditText)findViewById(R.id.editTextData); String text = editText.getText().toString(); Intent intent = new Intent(this, SecondActivity.class); intent.putExtra(Intent.EXTRA_TEXT,text); startActivity(intent);}

Assurez-vous d'importer:

import android.widget.EditText;

Ensuite, ouvrez le fichier activity_second.xml et ajoutez l'élément <TextView> suivant:

<TextView android:id="@+id/textViewText" android:layout_width="wrap_content" android:layout_height="wrap_content" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf="parent" app:layout_constraintTop_toTopOf="parent" app:layout_constraintBottom_toTopOf="@id/buttonClose"/>

Le dernier changement consiste à éditer la deuxième activité pour rechercher ces nouvelles données et les afficher à l'écran. Ouvrez SecondActivity.java et modifiez onCreate() comme suit:

@Overrideprotected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); TextView textView = (TextView) findViewById(R.id.textViewText); if (getIntent() != null && getIntent().hasExtra(Intent.EXTRA_TEXT)) { textView.setText(getIntent().getStringExtra(Intent.EXTRA_TEXT)); }}

Maintenant, exécutez le projet. Tapez du texte dans l'activité principale et appuyez sur Lancer la deuxième activité pour voir envoyer les données.

Comme prévu, l'objet Intent fait tout le travail. Nous avons créé une intention comme dans l'exemple précédent, puis ajouté des données supplémentaires. Avez-vous remarqué l'appel de la méthode putExtra()? Dans notre exemple, nous avons utilisé l'Intent.EXTRA_TEXT déjà défini comme identifiant, mais nous n'avions pas à le faire. Nous pouvons utiliser n'importe quelle clé que nous voulons (vous avez déjà vu ce concept si vous êtes familier avec les paires nom/valeur).

Le point clé concernant l'utilisation de paires nom/valeur est que vous devez utiliser le même nom pour récupérer les données. C'est pourquoi nous avons utilisé le même identifiant de clé lorsque nous lisons les données supplémentaires avec getStringExtra().

La deuxième activité a été lancée avec l'intention que nous avons créée, il s'agit donc simplement d'obtenir l'intention et de vérifier les données envoyées avec elle. Nous le faisons dans onCreate():

textView.setText(getIntent().getStringExtra(Intent.EXTRA_TEXT));

Retourner un résultat d'une activitéPouvoir démarrer une activité à partir d'une autre est très utile et couramment utilisé, mais il y a des moments où nous avons besoin de connaître le résultat de l'activité appelée. La méthode startActivityForResult() fournit la solution.

Ouvrez MainActivity.java et ajoutez la constante suivante à la classe:

public static final String REQUEST_RESULT="REQUEST_RESULT";

Ensuite, changez la façon dont l'intention est appelée en modifiant la méthode onClickSwitchActivity() pour attendre un résultat:

public void onClickSwitchActivity(View view) { EditText editText = (EditText)findViewById(R.id.editTextData); String text = editText.getText().toString(); Intent intent = new Intent(this, SecondActivity.class); intent.putExtra(Intent.EXTRA_TEXT,text); startActivityForResult(intent,1);}

Ensuite, ajoutez cette nouvelle méthode pour recevoir le résultat:

@Overrideprotected void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); if (resultCode==RESULT_OK) { Toast.makeText(this, Integer.toString(data.getIntExtra(REQUEST_RESULT, 0)), Toast.LENGTH_LONG).show(); }}

Enfin, modifiez onClickClose dans SecondActivity.java pour définir la valeur de retour comme suit:

public void onClickClose(View view) { Intent returnIntent = new Intent(); returnIntent.putExtra(MainActivity.REQUEST_RESULT,55); setResult(RESULT_OK, returnIntent); finish();}

Exécutez votre application et testez-la.

Comme vous pouvez le voir, obtenir les résultats est relativement simple. Nousappelons simplement l'intention avec startActivityForResult, indiquant que nousvoulons récupérer un résultat. Nous configurons le gestionnaire de rappel onActivityResult() pour recevoir les résultats. Enfin, nous nous assurons que ladeuxième activité renvoie un résultat avec setResult() avant de fermer l'activité.Dans cet exemple, nous définissons simplement un résultat avec une valeurstatique. Nous utilisons un simple Toast pour afficher le résultat à l'utilisateur.

Il est recommandé de vérifier le code de résultat pour s'assurer que l'utilisateur n'apas annulé l'action. C'est techniquement un entier, mais le système l'utilise commevaleur booléenne. Vérifiez RESULT_OK ou RESULT_CANCEL et procédez enconséquence. Dans notre exemple, la deuxième activité n'a pas de bouton d'annulation, alors

pourquoi s'embêter à vérifier? Que faire si l'utilisateur appuie sur le bouton de retour? Android définira le code de résultat sur RESULT_CANCEL et l'intention sur null, ce qui entraînerait la levée d'une exception par notre code si nous tentons d'accéder au résultat null.

Nous avons utilisé l'objet Toast, qui affiche un message contextuel pratique pour informer discrètement l'utilisateur. Il fonctionne également comme une méthode pratique pour le débogage car il n'a pas besoin d'une disposition spéciale ou d'un espace d'écran.

Ne vous inquiétez pas s'il y a des mots-clés que vous ne comprenez pas ou ne savez pas pourquoi ilssont utilisés et ce qu'ils signifient. Ce premier projet est une introduction au cours et nous couvrirons tous les détails dans les prochains chapitres.