Tutoriel Android : Apprendre à utiliser les Intent pour la communication des briques applicatives

Chapitre 3.3

Android2ee

Mathias Séguy

Ce chapitre vous explique la notion d'Intent qui vous permet de lier et de faire communiquer vos briques applicatives (Activity, Service, BroadCastReceiver…) entre elles et avec celles du système. C'est un objet essentiel de la programmation Android.

- Chapitre 0 : Installation et préparation de l'environnement de développement

- Chapitre 1 : Premiers pas avec Android

- Chapitre 1.1 : Cycle de vie de l'activité

- Chapitre 2.1 : Les éléments graphiques fondamentaux

- Chapitre 2.2 : Composants graphiques complexes

- Chapitre 3.3 : Intent et IntentFilters

- Chapitre 4.1 : Les Ressources

- Chapitre 4.2 : SharedPreferences et PreferenceActivity

- Chapitre 4.3 : Base de données SQLite

- Chapitre 4.4 : Gestion des fichiers

- Chapitre 5 : Content Provider

Pour réagir à ce tutoriel, un espace de dialogue vous est proposé sur le forum : Commentez

- Titre : Tutoriel Android : Apprendre à utiliser les Intent pour la communication des briques applicatives

- Auteur : Mathias Séguy

- Parution : 5 décembre 2016

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2016 Mathias Séguy. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Filtres d'intentions

- I-A. Objectif des intentions et bonne pratique

- I-B. Définition

- I-C. Routage des intentions

- I-C-1. Déclarer des intentions

- I-C-2. Récepteur d'intention

- I-D. Lancer des activités

- I-D-1. Instanciation

- I-D-2. Appel

- I-D-2-a. Exemple

- I-E. Cas particulier : la navigation par onglets

- I-F. Filtres d'intention standard

- I-F-1. Action standard des activités

- I-F-2. Actions standard d'un Broadcast

- I-F-3. Catégories standard

- I-F-4. Extra Data standard

- II. La rotation

- III. Remerciements

I - Filtres d'intentions

I-A - Objectif des intentions et bonne pratique

Les applications Android doivent se décomposer en activités distinctes les unes des autres. Au sein de ces applications, les activités doivent pouvoir s'enchaîner, s'appeler, retourner à leur activité principale. Pour mettre en place cette communication entre activités, Android utilise le système des intentions. Celles-ci permettent d'envoyer des messages d'une activité vers une autre avec des données pour les activer.

Dans ce contexte, il faut se demander si l'activité mère, quand elle lance une autre activité, est dans une relation maître-esclave ou dans une relation de pair à pair.

Dans le premier cas, l'activité mère attend que l'activité fille finisse et est informée de cette fin. Dans l'autre cas, l'activité fille est lancée, l'activité mère n'a plus de contact avec elle.

I-B - Définition

Une intention peut se traduire par « je veux, toi système, que tu fasses… ». Et cela dépend de l'action demandée et du contexte. Il faut les considérer comme de la colle entre activités permettant de les lier les unes aux autres.

Une intention est ainsi une action associée à des données. Les actions sont des constantes : ACTION_VIEW, ACTION_EDIT, ACTION_PICK, les données sont des URI.

Les intentions peuvent se spécifier ; on peut leur rajouter des informations :

- Une catégorie : LAUNCHER (pour les activités présentes dans le lanceur Android), DEFAULT ou ALTERNATIVE.

- Un type MIME : indique le type de la ressource (comme pour les mails).

- Un composant : indique la classe d'activité censée recevoir l'intention. Cette méthode n'est pas la plus heureuse, car elle fige l'activité associée. Soit vous l'avez codée vous-même, dans ce cas, c'est naturel, sinon, l'utilisation des autres paramètres est préconisée.

- Des « extras » : un bundle d'informations permettant de transférer des données à l'activité cible.

I-C - Routage des intentions

Il est préférable d'utiliser les URI et le type MIME, plutôt que Composant si vous souhaitez dialoguer avec une application qui n'est pas la vôtre. En d'autres termes, laissez Android se charger de trouver l'activité cible.

Pour qu'une activité soit éligible au routage d'une intention, il faut qu'elle supporte :

- l'action indiquée ;

- le type MIME indiqué ;

- ainsi que la catégorie.

Il faut donc spécifier suffisamment pour permettre à Android de trouver votre activité cible.

I-C-1 - Déclarer des intentions

Les déclarations se déclarent dans le fichier manifest.xml de l'application.

Pour être éligible, une activité doit ainsi déclarer les intentions auxquelles elle souhaite répondre, typiquement, pour une activité qui se lance par l'IHM principale d'Android, on rajoute :

1. <intent-filter>

2. <action android:name="android.intent.action.MAIN" />

3. <category android:name="android.intent.category.LAUNCHER" />

4. </intent-filter>

Un autre exemple plus utile est la déclaration d'une intention qui n'est pas main launcher :

1. <intent-filter>

2. <action android:name="android.intent.action.VIEW" />

3. <action android:name="android.intent.action.EDIT" />

4. <action android:name="android.intent.action.PICK" />

5. <category android:name="android.intent.category.DEFAULT" />

6. <data mimeType:name="vnd.android.cursor.dir/vnd.google.note" />

7. </intent-filter>

Cette intention déclare pouvoir répondre aux actions de visualisation et d'édition associées à un objet de type vnd.android.cursor.dir/vnd.google.note (c'est l'URI de la définition de l'objet). De même, le PICK permet de récupérer l'un de ces objets et de retourner dans l'application appelante. (Cf. http://developer.android.com/reference/android/content/Intent.html pour l'exemple complet).

Les intentions peuvent ainsi, en interne de l'application, faire des appels entre ces sous-modules. Ou en termes Android, les intentions permettent d'appeler différentes activités au sein de votre application de manière transparente.

I-C-2 - Récepteur d'intention

Typiquement, au lieu de recevoir une intention avec une activité, il peut être utile d'implémenter au sein de l'application une classe spécifique qui s'occupe de la récupération des intentions (comme un service) et de leur traitement qui peut être, du coup, contextuel (appel à un service, à plusieurs activités…).

Pour cela, il suffit de faire étendre votre classe réceptrice de la classe BroadCastReceiver et la déclarer dans le manifest.xml par :

<receiver android :name="maClasseReceptionniste"/>

Cette classe doit étendre la méthode onReceive. De plus, elle ne vit que lors de la réception d'une intention, elle est créée à la réception et détruite dès que la méthode onReceive est terminée. Ainsi, la classe BroadcastReceiver ne peut être liée à un service, une fenêtre de dialogue ou quoi que ce soit d'autre n'appartenant pas à son thread.

La seule exception à cette règle est quand votre classe qui hérite de BroadCastReceiver est implémentée par un composant d'une durée de vie longue (un service, une activité), dans ce cas, elle sera détruite quand l'hôte (bref le service, l'activité) est détruite.

Dans ce cas, le receveur ne se déclare pas dans le manifest.xml, il faut appeler la méthode registerReceiver dans le code de votre activité (service) au sein de la méthode onResume() et unregisterReceiver dans la méthode onPause().

Seuls les récepteurs actifs peuvent recevoir des intentions…

I-D - Lancer des activités

I-D-1 - Instanciation

Pour instancier une activité interne à son programme :

final Intent intent = new Intent().setClass(this, MyDaughterActivity.class);

Cette instruction déclare une intention associée à l'activité MyDaughterActivity qui est une classe de votre programme et this qui est l'activité courante.

Pour instancier une activité externe à votre programme, il vaut mieux spécifier une URI et une action, par exemple :

1. // Retrieve latitude and longitude

2. String latitude = "43.565715431592736";

3. String longitude = "1.398482322692871";

4. // Format the associated uri

5. Uri uriGeo = Uri.parse("geo:" + latitude + "," + longitude);

6. // Declare the associated Intent

7. final Intent intentGeo = new Intent(Intent.ACTION_VIEW, uriGeo);

Cette intention demande au système d'afficher une URI de type géo, à lui de se débrouiller pour trouver quelle activité répondra à cette intention.

I-D-2 - Appel

Pour lancer une activité, deux cas s'offrent à vous, le cas de la relation pair-à-pair ou le cas maître-esclave entre vos deux activités.

Dans le cas pair-à-pair (c.-à-d. l'activité mère lance l'activité fille et n'attend rien) :

startActivity(intentGeo);

Dans le cas maître-esclave :

startActivityForResult(intentContactForResult, INTENT_CALL_ID);

Il faut alors implémenter dans l'activité mère la méthode onActivityResult qui est appelée lorsque l'activité fille prend fin. L'activité fille, elle, doit implémenter la méthode setResult() qui généralement renvoie RESULT_OK ou RESULT_CANCELLED.

On peut récupérer aussi dans onActivityResult un String contenant des informations (une URL par exemple) ou un objet Bundle.

I-D-2-a - Exemple

Dans cet exemple, nous montrons comment lancer :

- une activité qui appartient à votre programme ;

- une activité qui permet de se géolocaliser avec une latitude/longitude grâce à la carte ;

- une activité qui récupère un contact et affiche les informations associées.

Ce projet est donc séparé en deux classes :

- l'activité principale qui lance les autres activités et qui implémente onActivityResult pour traiter les activités lancées avec la méthode startActivityForResults ;

- l'activité otherActivity qui ne fait qu'afficher un champ texte.

Le code Java de la classe principale :

1. public class IntentionSimpleTuto extends Activity {

2. // The unique identifier for the call using Intent of contact

3. private final int INTENT_CALL_ID = 10012220;

5. @Override

6. public void onCreate(Bundle savedInstanceState) {

7. super.onCreate(savedInstanceState);

8. setContentView(R.layout.main);

9. // To launch your own activity

10. // First declare an intent

11. final Intent intent = new Intent().setClass(this, OtherActivity.class);

12. // Then add the action to the button:

13. Button btnOtherActivity = (Button) findViewById(R.id.launchOther);

14. btnOtherActivity.setOnClickListener(new View.OnClickListener() {

15. public void onClick(View v) {

16. // Launch the activity

17. startActivity(intent);

18. }

19. });

21. // Do the same for Geo*

22. // Retrieve latitude and longitude

23. String latitude = "43.565715431592736";

24. String longitude = "1.398482322692871";

25. // Format the associated uri

26. Uri uriGeo = Uri.parse("geo:" + latitude + "," + longitude);

27. // Declare the associated Intent

28. final Intent intentGeo = new Intent(Intent.ACTION_VIEW, uriGeo);

29. // instanciate the button

30. Button btnGeoActivity = (Button) findViewById(R.id.launchGeo);

31. btnGeoActivity.setOnClickListener(new View.OnClickListener() {

32. public void onClick(View v) {

33. // Launch the activity

34. startActivity(intentGeo);

35. }

36. });

37. // Do the same for Contact waiting for result

38. // Format the associated uri

39. Uri uriContact = Uri.parse("content://contacts/people");// "content://contacts/people"

40. // Declare the intent:

41. final Intent intentContactForResult = new Intent(Intent.ACTION_PICK,

42. uriContact);

43. // instanciate the button

44. Button btnContactActivityForResults = (Button) findViewById(R.id.launchContactForResult);

45. btnContactActivityForResults

46. .setOnClickListener(new View.OnClickListener() {

47. public void onClick(View v) {

48. // Launch the activity

49. startActivityForResult(intentContactForResult,

50. INTENT_CALL_ID);

51. }

52. });

53. }

55. /*

56. *  * (non-Javadoc) * * @see android.app.Activity#onActivityResult(int, int,

57. * android.content.Intent)

58. */

59. @Override

60. protected void onActivityResult(int requestCode, int resultCode, Intent data) {

61. super.onActivityResult(requestCode, resultCode, data);

62. if (requestCode == INTENT_CALL_ID) {

63. if (resultCode == Activity.RESULT_OK) {

64. Uri contactData = data.getData();

65. Toast.makeText(

66. IntentionSimpleTuto.this,

67. "Result ok (uri:" + contactData + ") data "

68. + contactData.toString(), Toast.LENGTH_LONG)

69. .show();

70. Cursor c = managedQuery(contactData, null, null, null, null);

71. StringBuffer columnName = new StringBuffer("Result : ");

72. String value;

73. String name = "...";

74. if (c.moveToFirst()) {

75. for (int i = 0; i < c.getColumnCount(); i++) {

76. value = c.getString(c.getColumnIndexOrThrow(c

77. .getColumnName(i)));

78. columnName.append(",\r\n" + c.getColumnName(i) + ": "

79. + value);

80. }

81. Toast.makeText(IntentionSimpleTuto.this, columnName,

82. Toast.LENGTH_LONG).show();

83. name = c.getString(c

84. .getColumnIndexOrThrow(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME));

85. Toast.makeText(IntentionSimpleTuto.this,

86. "Et le nom : " + name, Toast.LENGTH_LONG).show();

87. }

88. } else if (resultCode == Activity.RESULT_CANCELED) {

89. Toast.makeText(IntentionSimpleTuto.this,

90. "Result ko no contact picked", Toast.LENGTH_LONG)

91. .show();

92. }

93. }

94. }

95. }

Le code Java de la seconde activité :

1. public class OtherActivity extends Activity {

2. /** Called when the activity is first created. */

3. @Override

4. public void onCreate(Bundle savedInstanceState) {

5. super.onCreate(savedInstanceState);

6. setContentView(R.layout.other_activity);

7. }

8. }

Le mainLayout.xml de l'activité principale qui déclare trois boutons et un champ texte :

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

2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

3. android:orientation="vertical"

4. android:layout_width="fill_parent"

5. android:layout_height="fill_parent"

6. >

7. <TextView

8. android:layout_width="fill_parent"

9. android:layout_height="wrap_content"

10. android:text="@string/hello">

11. </TextView>

12. <Button

13. android:text="@string/launchOther"

14. android:id="@+id/launchOther"

15. android:layout_width="wrap_content"

16. android:layout_height="wrap_content">

17. </Button>

18. <Button

19. android:text="@string/launchGeo"

20. android:id="@+id/launchGeo"

21. android:layout_width="wrap_content"

22. android:layout_height="wrap_content">

23. </Button>

24. <Button

25. android:text="@string/launchContactForResult"

26. android:id="@+id/launchContactForResult"

27. android:layout_width="wrap_content"

28. android:layout_height="wrap_content">

29. </Button>

30. </LinearLayout>

Le layout de other_activity.xml :

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

2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

3. android:orientation="vertical"

4. android:layout_width="fill_parent"

5. android:layout_height="fill_parent"

6. >

7. <TextView

8. android:id="@+id/otherTextView"

9. android:layout_width="fill_parent"

10. android:layout_height="wrap_content"

11. android:text="@string/otheractivity"

12. />

13. </LinearLayout>

Le fichier des chaînes de caractères (string.xml) :

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

2. <resources>

3. <string name="hello">Hello World, IntentionSimpleTuto!</string>

4. <string name="app_name">IntentionSimpleTuto</string>

5. <string name="launchOther">Launch the activity other</string>

6. <string name="launchGeo">Launch the activity Geo</string>

7. <string name="launchContactForResult">Launch the activity Contact for results</string>

8. <string name="otheractivity">And an other activity appears in front of your amazed eyes !</string>

9. </resources>

Et le fichier manifest.xml :

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

2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"

3. package="net.stinfoservices.android.tuto.core" android:versionCode="1"

4. android:versionName="1.0">

5. <application android:icon="@drawable/icon" android:label="@string/app_name">

6. <activity android:name=".IntentionSimpleTuto" android:label="@string/app_name">

7. <intent-filter>

8. <action android:name="android.intent.action.MAIN" />

9. <category android:name="android.intent.category.LAUNCHER" />

10. </intent-filter>

11. </activity>

13. <activity android:name="OtherActivity"></activity>

14. </application>

15. <uses-sdk android:minSdkVersion="8" />

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

17. </manifest>

I-E - Cas particulier : la navigation par onglets

Pour des raisons de sécurité, une activité ne peut héberger les activités d'autres applications au sein de ses onglets. Ainsi, pour obtenir une navigation par onglet, il faut tout d'abord créer l'activité contenante qui est une TabActivity et lui rajouter des onglets que l'on peuple avec des intentions. Pour cela, on récupère le TabHost de la classe TabActivity et pour chacun des onglets on effectue les opérations suivantes :

- définition de l'Intent qui représente l'activité contenue par l'onglet ;

- récupération puis définition du TabSpec (son tag, son label, son contenu via l'Intent) ;

- ajout du TabSpec au TabHost.

Le code Java de la classe principale :

1. public class MultiTabBrowserTuto extends TabActivity {

2. /** Called when the activity is first created. */

3. @Override

4. public void onCreate(Bundle savedInstanceState) {

5. super.onCreate(savedInstanceState);

6. // Define the Tab structure

7. setContentView(R.layout.main);

8. // Retrieve the ressource to access to the icon

9. Resources resources = getResources(); // Resource object to get

10. // Drawables

11. // Set the tabHost (set it has final to use it in the

12. // OnTabChangeListener)

13. final TabHost tabHost = getTabHost();

14. // Define the tabSpec that can be thought has the content of the

15. // TabPanel

16. TabHost.TabSpec tabSpec;

17. // Define the intent that is used to populate the tabSpec

18. Intent intent;

20. // Create an Intent to launch an Activity for the tab

21. intent = new Intent().setClass(this, SiteWebSTI.class);

23. // Initialize a TabSpec for each tab and add it to the TabHost

24. // Get a new TabHost.TabSpec associated with this tab host.

25. tabSpec = tabHost.newTabSpec("SiteWebSti");

26. // Define its indicator the label displayed (it should be

27. // ressources.getString(R.string.stringId)

28. tabSpec.setIndicator("SiteSti",

29. resources.getDrawable(R.drawable.ic_tab));

30. // Define the content of the Spec (the TabPanel)

31. tabSpec.setContent(intent);

32. // Add it to the tab container

33. tabHost.addTab(tabSpec);

35. // Do the same with the tab that displays a simple TextView:

36. // Define the intent that will be displayed

37. intent = new Intent().setClass(this, TextViewActivity.class);

38. // Get a new TabHost.TabSpec associated with this tab host.

39. tabSpec = tabHost.newTabSpec("textView");

40. // Define its indicator the label displayed (it should be

41. // ressources.getString(R.string.stringId)

42. tabSpec.setIndicator("TextView",

43. resources.getDrawable(R.drawable.ic_tab));

44. // Define the content of the Spec (the TabPanel)

45. tabSpec.setContent(intent);

46. // Add it to the tab container

47. tabHost.addTab(tabSpec);

49. // Do the same with the tab that displays a simple Clock (analogic and

50. // digital):

51. // Define the intent that will be displayed

52. intent = new Intent().setClass(this, ClockAD.class);

53. // Get a new TabHost.TabSpec associated with this tab host.

54. tabSpec = tabHost.newTabSpec("clock");

55. // Define its indicator the label displayed

56. tabSpec.setIndicator("Clock", resources.getDrawable(R.drawable.ic_tab));

57. // Define the content of the Spec (the TabPanel)

58. tabSpec.setContent(intent);

59. // Add it to the tab container

60. tabHost.addTab(tabSpec);

62. // Define the current tab displayed (here the clock)

63. tabHost.setCurrentTab(2);

64. // Add a listener that just displays a Toast with the tag of the new

65. // selected tab

66. tabHost.setOnTabChangedListener(new OnTabChangeListener() {

67. @Override

68. public void onTabChanged(String tabId) {

69. Toast.makeText(getApplicationContext(),

70. "New tab selection : " + tabHost.getCurrentTabTag(),

71. Toast.LENGTH_SHORT).show();

72. }

73. });

75. }

76. }

Les codes Java des classes des activités sont des codes d'activités normales. Les classes ne savent pas qu'elles vont être utilisées au sein d'onglets.

Le code Java de la classe SiteWebSti qui ne fait que déclarer un WebKit qui pointe vers un site :

1. public class SiteWebSTI extends Activity {

2. WebView browser;

4. @Override

5. public void onCreate(Bundle icicle) {

6. super.onCreate(icicle);

8. browser = new WebView(this);

9. setContentView(browser);

10. browser.loadUrl("http://www.stinfoservices.net/");

11. }

12. }

Le code Java de la classe TextView qui ne fait que déclarer un TextView avec un texte simple :

1. public class TextViewActivity extends Activity {

2. public void onCreate(Bundle savedInstanceState) {

3. super.onCreate(savedInstanceState);

5. TextView textview = new TextView(this);

6. textview.setText("Hello Guy this a TabPanel also called TabSpec");

7. setContentView(textview);

8. }

9. }

Le code Java de la classe ClockAD qui ne fait que charger son fichier de layout.xml nommé clock.xml :

1. public class ClockAD extends Activity {

2. /** Called when the activity is first created. */

3. @Override

4. public void onCreate(Bundle savedInstanceState) {

5. super.onCreate(savedInstanceState);

6. setContentView(R.layout.clock);

7. }

8. }

Le fichier de layout associé à la classe ClockAD qui se nomme clock. Il déclare deux éléments, une horloge digitale et une analogique :

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

2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"

3. android:orientation="vertical"

4. android:layout_width="fill_parent"

5. android:layout_height="fill_parent"

6. >

7. <AnalogClock android:id="@+id/analog"

8. android:layout_width="fill_parent"

9. android:layout_height="wrap_content"

10. android:layout_centerHorizontal="true"

11. android:layout_alignParentTop="true"

12. />

13. <DigitalClock android:id="@+id/digital"

14. android:layout_width="wrap_content"

15. android:layout_height="wrap_content"

16. android:layout_centerHorizontal="true"

17. android:layout_below="@id/analog"

18. />

19. </RelativeLayout>

Puis les fichiers principaux de l'application :

Le fichier Layout principal de la classe MultiTabBrowserTuto qui déclare la structure usuelle d'une application à onglets :

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

2. <TabHost xmlns:android="http://schemas.android.com/apk/res/android"

3. android:id="@android:id/tabhost"

4. android:layout_width="fill_parent"

5. android:layout_height="fill_parent">

6. <LinearLayout

7. android:orientation="vertical"

8. android:layout_width="fill_parent"

9. android:layout_height="fill_parent"

10. android:padding="5dp">

11. <TabWidget

12. android:id="@android:id/tabs"

13. android:layout_width="fill_parent"

14. android:layout_height="wrap_content" />

15. <FrameLayout

16. android:id="@android:id/tabcontent"

17. android:layout_width="fill_parent"

18. android:layout_height="fill_parent"

19. android:padding="5dp" />

20. </LinearLayout>

21. </TabHost>

Le fichier de ressource pour les icônes qui reroute automatiquement vers une ressource en fonction de son état « de sélection » :

1. <?xml version="1.0" encoding="UTF-8"?>

2. <selector xmlns:android="http://schemas.android.com/apk/res/android">

3. <!-- When selected, use grey -->

4. <item android:drawable="@drawable/ic_tab_grey"

5. android:state_selected="true" />

6. <!-- When not selected, use white-->

7. <item android:drawable="@drawable/ic_tab_white" />

8. </selector>

Il est à noter que le dossier drawable contient deux icônes, ic_tab_grey.png et ic_tab_white.png qui sont dans les en-têtes des onglets et qui sont pointés par le fichier ci-dessus.

Et enfin le fichier manifest.xml de l'application. Trois choses sont importantes dans ce manifest.xml :

- Chaque activité est déclarée (il ne faut pas l'oublier).

- L'attribut noTitleBar est spécifié pour l'activité principale, ce qui permet de gagner un peu de place en hauteur.

- L'accès à Internet est demandé (nécessaire à l'activité WebKit).

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

2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"

3. package="net.stinfoservices.android.tuto.gui" android:versionCode="1"

4. android:versionName="1.0">

5. <application android:icon="@drawable/icon" android:label="@string/app_name">

6. <activity android:name=".MultiTabBrowserTuto"

7. android:label="@string/app_name"

8. android:theme="@android:style/Theme.NoTitleBar">

9. <intent-filter>

10. <action android:name="android.intent.action.MAIN" />

11. <category android:name="android.intent.category.LAUNCHER" />

12. </intent-filter>

13. </activity>

14. <activity android:name="SiteWebSTI"></activity>

15. <activity android:name="TextViewActivity"></activity>

16. <activity android:name="ClockAD"></activity>

17. </application>

18. <uses-sdk android:minSdkVersion="8" />

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

20. </manifest>

Voilà, une activité affichant un navigateur avec des onglets qui marchent avec les intentions. Ce qui correspond à l'état de l'art pour un programme Android qui se doit d'être un ensemble d'activités liées les unes aux autres au moyen d'intents.

I-F - Filtres d'intention standard

Vous trouverez dans http://developer.android.com/reference/android/content/Intent.html une très bonne description de ces intentions.

Les points suivants listent les paramètres les plus utilisés pour la déclaration d'intentions.

I-F-1 - Action standard des activités

Actions courantes et standard que les Intents définissent pour lancer les activités (usuellement au moyen de startActivity(Intent)). Les plus importantes et les plus utilisées sont de loin ACTION_MAIN et ACTION_EDIT.

- ACTION_MAIN

- ACTION_VIEW

- ACTION_ATTACH_DATA

- ACTION_EDIT

- ACTION_PICK

- ACTION_CHOOSER

- ACTION_GET_CONTENT

- ACTION_DIAL

- ACTION_CALL

- ACTION_SEND

- ACTION_SENDTO

- ACTION_ANSWER

- ACTION_INSERT

- ACTION_DELETE

- ACTION_RUN

- ACTION_SYNC

- ACTION_PICK_ACTIVITY

- ACTION_SEARCH

- ACTION_WEB_SEARCH

- ACTION_FACTORY_TEST

I-F-2 - Actions standard d'un Broadcast

Actions courantes et standard que les Intents définissent pour recevoir les BroadCast (usuellement au moyen de registerReceiver(BroadcastReceiver, IntentFilter) ou au moyen du tag <receiver> dans le fichier manifest.xml).

- ACTION_TIME_TICK

- ACTION_TIME_CHANGED

- ACTION_TIMEZONE_CHANGED

- ACTION_BOOT_COMPLETED

- ACTION_PACKAGE_ADDED

- ACTION_PACKAGE_CHANGED

- ACTION_PACKAGE_REMOVED

- ACTION_PACKAGE_RESTARTED

- ACTION_PACKAGE_DATA_CLEARED

- ACTION_UID_REMOVED

- ACTION_BATTERY_CHANGED

- ACTION_POWER_CONNECTED

- ACTION_POWER_DISCONNECTED

- ACTION_SHUTDOWN

I-F-3 - Catégories standard

Catégories courantes et standard qui peuvent être utilisées pour classifier les Intents au moyen de la méthode addCategory(String).

- CATEGORY_DEFAULT

- CATEGORY_BROWSABLE

- CATEGORY_TAB

- CATEGORY_ALTERNATIVE

- CATEGORY_SELECTED_ALTERNATIVE

- CATEGORY_LAUNCHER

- CATEGORY_INFO

- CATEGORY_HOME

- CATEGORY_PREFERENCE

- CATEGORY_TEST

- CATEGORY_CAR_DOCK

- CATEGORY_DESK_DOCK

- CATEGORY_CAR_MODE

I-F-4 - Extra Data standard

Champs courants et standard qui peuvent être utilisés comme données supplémentaires au moyen de la méthode putExtra(String, Bundle).

- EXTRA_ALARM_COUNT

- EXTRA_BCC

- EXTRA_CC

- EXTRA_CHANGED_COMPONENT_NAME

- EXTRA_DATA_REMOVED

- EXTRA_DOCK_STATE

- EXTRA_DOCK_STATE_CAR

- EXTRA_DOCK_STATE_DESK

- EXTRA_DOCK_STATE_UNDOCKED

- EXTRA_DONT_KILL_APP

- EXTRA_EMAIL

- EXTRA_INITIAL_INTENTS

- EXTRA_INTENT

- EXTRA_KEY_EVENT

- EXTRA_PHONE_NUMBER

- EXTRA_REMOTE_INTENT_TOKEN

- EXTRA_REPLACING

- EXTRA_SHORTCUT_ICON

- EXTRA_SHORTCUT_ICON_RESOURCE

- EXTRA_SHORTCUT_INTENT

- EXTRA_STREAM

- EXTRA_SHORTCUT_NAME

- EXTRA_SUBJECT

- EXTRA_TEMPLATE

- EXTRA_TEXT

- EXTRA_TITLE

- EXTRA_UID

II - La rotation

Lors de la rotation de l'écran, votre activité est détruite puis reconstruite.

Vous pouvez vous référer à la partie 5.2 : Gestion des événements du cycle de vie d'une activité.

Pour désactiver la rotation, il suffit de rajouter dans son fichier manifest.xml le type d'orientation (landscape, portrait ou sensor) de votre activité :

1. <activity android:name=".LaunchDemo" android:label="LaunchDemo">

2. <intent-filter>

3. <action android:name="android.intent.action.MAIN"

4. android:screenOrientation="landscape" />

5. <category android:name="android.intent.category.LAUNCHER" />

6. </intent-filter>

7. </activity>

Si vous mettez le paramètre sensor, cela demande à Android de faire pivoter l'activité en fonction de l'accéléromètre qui détecte quand l'écran est en mode portrait ou pas.

III - Remerciements

Cet article a été publié avec l'aimable autorisation de la société Android2EE.

Nous tenons à remercier Ced et f-leb pour la relecture orthographique de cet article et Mickael Baron pour la mise au format Developpez.com.