Afin de valider ces différentes notions, je vous propose de réaliser un projet qui permet de choisir un jour de la semaine. La vue montre simplement une liste surmontée d'un label qui devra afficher en permanence la sélection courante :

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
   <TextView  
       android:id="@+id/selection"
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content" 
       android:background="#FF9900"
       android:textColor="#FFFF00"
       android:textSize="24sp"
       android:paddingLeft="7dp"
       android:text="Votre choix ?"
       />
   <ListView  
       android:id="@android:id/list"
       android:layout_width="fill_parent" 
       android:layout_height="fill_parent" />
</LinearLayout>

Vu que nous allons prendre une activité de type ListActivity, la vue est vraiment très simple à mettre en oeuvre. En réalité, nous passons beaucoup plus de temps à régler le TextView par rapport au ListView.

fr.manu.test.ListeChoix.java

package fr.manu.test;

import android.app.*;
import android.os.Bundle;
import android.view.View;
import android.widget.*;

public class ListeChoix extends ListActivity  {
   private TextView selection;
   private String[] semaine = {"Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"};
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        setListAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, semaine));
        selection = (TextView) findViewById(R.id.selection);
   }

   @Override
   protected void onListItemClick(ListView l, View v, int position, long id) {
      selection.setText(semaine[position]);
   } 
}

1. Vous pouvez configurer l'adaptateur d'une ListActivity par un appel à setListAdapter() - ici, nous fournissons un ArrayAdapter qui enveloppe un tableau de chaînes quelconques.
2. Afin d'être prévenu des changements dans la liste de sélection, nous redéfinissons onListItemClick() pour qu'elle agisse de façon appropriée en tenant compte de la vue fille et de la position qui lui sont passée en paramètre.
3. Le second paramètre android.R.layout.simple_list_item_1 (prédéfini par Android) de notre ArrayAdapter - contrôle l'aspect des lignes. La constante utilisée ici fournit une ligne Android standard : grande police, remplissage important et texte en blanc.

Proposer d'autres vues avec la même liste

Par défaut, ListView est simplement configurée pour recevoir les clics sur les entrées de la liste. Cependant, nous avons parfois besoin d'une liste qui mémorise un ou plusieurs choix de l'utilisateur ; ListView permet également de le faire, au prix de quelques modifications :

1. Dans le code Java, appelez la méthode setChoiceMode() de l'objet ListView afin de configurer le mode de sélection en lui passant en paramètre la constante CHOICE_MODE_SINGLE ou CHOICE_MODE_MULTIPLE (pour obtenir l'objet ListView, il suffit d'appeler la méthode getListView() à partir d'une ListActivity).
2. Puis, au lieu de passer en paramètre android.R.layout.simple_list_item_1 au constructeur d'ArrayAdapter, utilisez soit android.R.layout.simple_list_item_single_choice, soit android.R.layout.simple_list_item_multiple_choice pour mettre en place, respectivement, une liste à choix unique ou à choix multiple.
3. Pour connaître quel est l'élément choisi par l'utilisateur, appelez la méthode getCheckedItemPositions() du widget ListView.

fr.manu.test.ListeChoix.java

package fr.manu.test;

import android.app.*;
import android.os.Bundle;
import android.view.View;
import android.widget.*;

public class ListeChoix extends ListActivity  {
   private TextView selection;
   private enum Semaine {Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche};
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        setListAdapter(new ArrayAdapter<Semaine>(this, android.R.layout.simple_list_item_single_choice, Semaine.values()));
        getListView().setChoiceMode(ListView.CHOICE_MODE_SINGLE);
        selection = (TextView) findViewById(R.id.selection);
   }

   @Override
   protected void onListItemClick(ListView l, View v, int position, long id) {
      Semaine semaine = (Semaine) getListAdapter().getItem(position);
      selection.setText(semaine.name());
   } 
}

Dans le code Java ci-dessus, je précise cette fois-ci que le choix effectué sera unique. Au niveau de la vue, cela se traduit par une liste de bouton radio. Cela n'était pas indispensable, mais j'ai profité de l'occasion pour implémenter une énumération (un seul choix parmi plusieurs possibles). Nous n'avons absolument rien modifié du côté du layout (fichier de description XML).

fr.manu.test.ListeChoix.java

package fr.manu.test;

import android.app.*;
import android.os.Bundle;
import android.view.View;
import android.widget.*;

public class ListeChoix extends ListActivity  {
   private TextView selection;
   private enum Semaine {Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche};
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        setListAdapter(new ArrayAdapter<Semaine>(this, android.R.layout.simple_list_item_multiple_choice, Semaine.values()));
        getListView().setChoiceMode(ListView.CHOICE_MODE_MULTIPLE);
        selection = (TextView) findViewById(R.id.selection);
   }

   @Override
   protected void onListItemClick(ListView liste, View v, int position, long id) {
      String resultat = "";
      Semaine semaine;
      SparseBooleanArray tableau = liste.getCheckedItemPositions();
      for (int i=0; i<tableau.size(); i++) {
         if (tableau.valueAt(i)) {
            semaine = (Semaine) getListAdapter().getItem(tableau.keyAt(i));
            resultat += semaine.name() + " ";
         }
      }
      selection.setText("["+resultat+"]");
   } 
}

1. La méthode getCheckedItemPositions() retourne un tableau particulier représenté par la classe SparseBooleanArray.
2. Il s'agit en réalité d'une carte correspondant à l'ensemble des éléments déjà sélectionnés.
3. Cette carte est une relation entre une valeur entière correspondant à l'indice de la position de l'élément dans la ListView avec une valeur booléenne qui précise si cet élément est actuellement sélectionné.
4. Attention, il est possible d'avoir sélectionné dans un premier temps une valeur et ensuite de l'avoir inhiber. Cette carte mémorise tous les éléments qui ont déjà étaient pris en compte.
5. Ainsi, avant de récupérer l'indice de l'élément, au moyen de la méthode keyAt(), vous devez évaluer si cet élément est actuellement sélectionné, au moyen de la méthode valueAt().

Je vous propose de reprendre le projet précédent en prenant cette fois-ci une liste déroulante pour réaliser le choix :

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
   <TextView  
       android:id="@+id/selection"
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content" 
       android:background="#FF9900"
       android:textColor="#FFFF00"
       android:textSize="24sp"
       android:paddingLeft="7dp"  />
   <Spinner 
       android:id="@+id/choix"
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content" />
</LinearLayout>  

1. Nous retrouvons pratiquement la même vue que précédemment avec toutefois le remplacement de la balise <ListView> par la balise <Spinner>.
2. Une autre différence importante concerne l'identification. Cette fois-ci l'activité est représenté de façon plus classique par la classe Activity et non plus ListActivity (cela n'a plus aucun sens avec la classe Spinner).
3. Du coup, il faut également remplacer @android/list par une identification classique et personnalisé, ici @+id/choix.

fr.manu.test.ListeChoix.java

package fr.manu.test;

import android.app.*;
import android.os.Bundle;
import android.view.View;
import android.widget.*;

public class ListeChoix extends Activity implements AdapterView.OnItemSelectedListener {
   private TextView selection;
   private enum Semaine {Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche};
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      selection = (TextView) findViewById(R.id.selection);
      Spinner choix = (Spinner) findViewById(R.id.choix);
      ArrayAdapter<Semaine> semaine = new ArrayAdapter<Semaine>(this, android.R.layout.simple_spinner_item, Semaine.values());
      semaine.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
      choix.setOnItemSelectedListener(this);
      choix.setAdapter(semaine);
   }

   public void onItemSelected(AdapterView<?> parent, View vue, int position, long id) {
      Semaine semaine = Semaine.values()[position];
      selection.setText(semaine.name());
   }

   public void onNothingSelected(AdapterView<?> parent) {
      selection.setText("Votre sélection ?");
   }
}

1. Comme nous nous trouvons avec une activité classique, nous devons implémenter l'interface AdapterView.OnItemSelectedListener afin de gérer l'événement relatif à la sélection.
2. Elle possède deux méthodes spécifiques onItemSelected() et onNothingSelected() que vous complétez en conséquence.
3. Nous configurons l'adaptateur, non seulement avec une énumération, mais également avec une ressource spécifique qui sert à la vue déroulante, au travers de la méthode setDropDownViewRessource().
4. Vous remarquez également que nous utilisons la constante prédéfinie afin d'afficher les éléments du Spinner.

Je vous propose de reprendre le projet précédent en prenant cette fois-ci une grille pour réaliser le choix :

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
   <TextView  
       android:id="@+id/selection"
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content" 
       android:background="#FF9900"
       android:textColor="#FFFF00"
       android:textSize="24sp"
       android:paddingLeft="7dp"
       android:text="Votre choix ?"  />
   <GridView
       android:id="@+id/choix"
       android:layout_width="fill_parent" 
       android:layout_height="fill_parent" 
       android:horizontalSpacing="5px"
       android:numColumns="auto_fit"
       android:columnWidth="100px"
       android:stretchMode="columnWidth"
       android:gravity="center"  />
</LinearLayout>

fr.manu.test.ListeChoix.java

package fr.manu.test;

import android.app.*;
import android.os.Bundle;
import android.view.View;
import android.widget.*;

public class ListeChoix extends Activity implements AdapterView.OnItemSelectedListener {
   private TextView selection;
   private enum Semaine {Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche};
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      selection = (TextView) findViewById(R.id.selection);
      GridView choix = (GridView) findViewById(R.id.choix);
      choix.setOnItemSelectedListener(this);
      choix.setAdapter(new ArrayAdapter<Semaine>(this, android.R.layout.simple_list_item_1, Semaine.values()));
   }

   public void onItemSelected(AdapterView<?> parent, View vue, int position, long id) {
      Semaine semaine = Semaine.values()[position];
      selection.setText(semaine.name());
   }

   public void onNothingSelected(AdapterView<?> parent) {
      selection.setText("Votre sélection ?");
   }
}

Je vous propose de reprendre le projet précédent en prenant cette fois-ci la saisie avec auto-complétion pour réaliser le choix :

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
   <TextView  
       android:id="@+id/selection"
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content" 
       android:background="#FF9900"
       android:textColor="#FFFF00"
       android:textSize="24sp"
       android:paddingLeft="7dp"
       android:text="Votre choix ?" />
   <AutoCompleteTextView
       android:id="@+id/choix"
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content"        
       android:completionThreshold="1" />
</LinearLayout>  

L'attribut android:completionThreshold permet de spécifier à partir de quel nombre de lettres saisies les choix automatiques, donnés par la liste déroulante, sont proposés. Ici, nous demandons à visualiser tous les choix possibles dès que la première lettre est proposée.

fr.manu.test.ListeChoix.java

package fr.manu.test;

import android.app.*;
import android.os.Bundle;
import android.text.*;
import android.widget.*;

public class ListeChoix extends Activity implements TextWatcher {
   private TextView selection;
   private AutoCompleteTextView choix;
   private enum Semaine {Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche};
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      selection = (TextView) findViewById(R.id.selection);
      choix = (AutoCompleteTextView) findViewById(R.id.choix);
      choix.addTextChangedListener(this);
      choix.setAdapter(new ArrayAdapter<Semaine>(this, android.R.layout.simple_dropdown_item_1line, Semaine.values()));
   }

   public void beforeTextChanged(CharSequence chaine, int debut, int apres, int nombre) { }

   public void onTextChanged(CharSequence chaine, int debut, int fin, int nombre) {
      selection.setText(choix.getText());
   }

   public void afterTextChanged(Editable chaine) {  }
}

Cette fois-ci, notre activité implémente l'interface TextWatcher, ce qui signifie que nos méthodes de rappel doivent se nommer beforeTextChanged(), onTextChanged() et afterTextChanged(). Remarquez également le changement de la constante au niveau de l'adaptateur qui s'appelle ici android.R.layout.simple_dropdown_item_1line.

Encore une dernière fois, reprenons le projet précédent en prenant cette fois-ci la sélection sous forme de galerie :

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
   <TextView  
       android:id="@+id/selection"
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content" 
       android:background="#FF9900"
       android:textColor="#FFFF00"
       android:textSize="24sp"
       android:paddingLeft="7dp"
       android:text="Votre choix ?"  />
   <Gallery
       android:id="@+id/choix"
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content"
       android:spacing="10px"  />
</LinearLayout>

fr.manu.test.ListeChoix.java

package fr.manu.test;

import android.app.*;
import android.os.Bundle;
import android.text.*;
import android.widget.*;
import android.widget.AdapterView.OnItemClickListener;

public class ListeChoix extends Activity implements OnItemClickListener {
   private TextView selection;
   private Gallery choix;
   private enum Semaine {Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche};
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      selection = (TextView) findViewById(R.id.selection);
      choix = (Gallery) findViewById(R.id.choix);
      choix.addTextChangedListener(this);
      choix.setAdapter(new ArrayAdapter<Semaine>(this, android.R.layout.simple_gallery_item, Semaine.values()));
      choix.setOnItemClickListener(this);      
   }

   public void onItemClick(AdapterView<?> parent, View vue, int position, long id) {
      Semaine semaine = Semaine.values()[position];
      selection.setText(semaine.name());      
   }
}

Cette fois-ci, notre activité implémente l'interface OnItemClickListener, ce qui signifie que la méthode de rappel à prendre en compte se nomme onItemClick(). Remarquez également le changement de la constante au niveau de l'adaptateur qui s'appelle ici android.R.layout.simple_gallery_item.

Dans l'exemple qui suit, nous allons créer un nouveau composant qui est capable de saisir et d'afficher directement des valeurs monétaires. Nous décidons donc d'étendre la vue EditText afin de permettre une saisie, et nous appelons notre nouveau composant Monnaie :

fr.manu.monnaie.Monnaie.java

package fr.btsiris.monnaie;

import android.content.Context;
import android.text.InputType;
import android.util.AttributeSet;
import android.view.Gravity;
import android.widget.EditText;
import java.text.*;

public class Monnaie extends EditText {
   private NumberFormat formatMonnaie;

   public Monnaie(Context context, AttributeSet attrs, int defStyle) {
      super(context, attrs, defStyle);
      init();
   }

   public Monnaie(Context context, AttributeSet attrs) {
      super(context, attrs);
      init();
   }

   public Monnaie(Context context) {
      super(context);
      init();
   }
   
   private void init() {
      setSymbole('€');
      setValeur(0.0);
      setGravity(Gravity.RIGHT);
      setInputType(InputType.TYPE_CLASS_NUMBER);
   }

   public void setSymbole(char symbole) {
      formatMonnaie = new DecimalFormat("#,##0.00 "+symbole);
   }

   public double getValeur() {
      try {
         Number valeur = (Number) formatMonnaie.parse(getText().toString());
         setText(formatMonnaie.format(valeur));
         return valeur.doubleValue();
      } 
      catch (ParseException ex) { return 0.0; }
   }

   public void setValeur(double valeur) {
      setText(formatMonnaie.format(valeur));
   }
}

1. Vous noterez la déclaration des trois constructeurs de base d'une vue. Ils servent notamment à créer une vue à partir d'un gabarit d'interface au format XML. De cette façon, la création du composant et son utilisattion dans un fichier de description XML sont semblables à tout autre composant de la plate-forme Android.
2. Vous remarquez également la présence de méthodes supplémentaires accesseurs (setXxx() notamment) permettant de mettre à jour les propriétés du composant.

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:stretchColumns="1">
    <TableRow>
       <fr.btsiris.monnaie.Monnaie 
          android:id="@+id/euro"
          android:layout_width="fill_parent" 
          android:layout_height="wrap_content"
          android:layout_span="3"/>
       <Button     
          android:layout_width="fill_parent" 
          android:layout_height="wrap_content" 
          android:text="Franc"
          android:onClick="calculFranc"  />
    </TableRow>
    <TableRow>
       <fr.btsiris.monnaie.Monnaie 
          android:id="@+id/franc"
          android:layout_width="fill_parent" 
          android:layout_height="wrap_content"
          android:layout_span="3"/>
       <Button     
          android:layout_width="fill_parent" 
          android:layout_height="wrap_content" 
          android:text="€uro"
          android:onClick="calculEuro"  />
    </TableRow>    
</TableLayout>

Pour faire référence à notre nouveau composant dans le fichier de description XML concernant le layout, il suffit d'utiliser la balise qui porte son nom. La seule petite contrainte est de préciser le nom complet avec son chemin, ici donc <fr.btsiris.monnaie.Monnaie>.

fr.manu.monnaie.Conversion.java

package fr.btsiris.monnaie;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;

public class Conversion extends Activity {
   private Monnaie euro, franc;
   private final double TAUX = 6.55957;
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState); 
       setContentView(R.layout.main);
       euro = (Monnaie) findViewById(R.id.euro);
       franc = (Monnaie) findViewById(R.id.franc);
       franc.setSymbole('F');     
       franc.setValeur(0.0);
   }
    
   public void calculFranc(View vue) {
      franc.setValeur(euro.getValeur() * TAUX);
   }
   
   public void calculEuro(View vue) {
      euro.setValeur(franc.getValeur() / TAUX);
   }   
}

Afin de bien maîtriser tous ces concepts, je vous propose de reprendre le tout premier exemple que nous avons mis en oeuvre qui affiche la liste des jours de la semaine afin de choisir celui qui nous intéresse. Je rappelle les codes que nous commenterons par la suite :

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
   <TextView  
       android:id="@+id/selection"
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content" 
       android:background="#FF9900"
       android:textColor="#FFFF00"
       android:textSize="24sp"
       android:paddingLeft="7dp"
       android:text="Votre choix ?"
       />
   <ListView  
       android:id="@android:id/list"
       android:layout_width="fill_parent" 
       android:layout_height="fill_parent" />
</LinearLayout>

Vu que nous allons prendre une activité de type ListActivity, la vue est vraiment très simple à mettre en oeuvre. En réalité, nous passons beaucoup plus de temps à régler le TextView par rapport au ListView.

fr.manu.test.ListeChoix.java

package fr.manu.test;

import android.app.*;
import android.os.Bundle;
import android.view.View;
import android.widget.*;

public class ListeChoix extends ListActivity  {
   private TextView selection;
   private String[] semaine = {"Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"};
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        setListAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, semaine));
        selection = (TextView) findViewById(R.id.selection);
   }

   @Override
   protected void onListItemClick(ListView l, View v, int position, long id) {
      selection.setText(semaine[position]);
   } 
}

1. Nous commençons par déclarer le tableau que nous associerons à un ArrayAdapter.
2. Ensuite, afin de simplifier la gestion des vues, nous appliquons cet adaptateur dans une activité de type ListActivity. Ce type d'activité embarque en effet une ListView et des méthodes simplifiant la gestion des adaptateurs.

Le constructeur utilisé pour instancier un nouvel objet de type ArrayAdapter prend trois paramètres :

1. Le contexte : grâce à ce paramètre, l'adaptateur est capable de créer seul les objets nécessaires à la transcription des fichiers XML en ressources ;
2. L'identifiant : du fichier XML à utiliser comme modèle pour la liste (en général contenu dans le dossier /res/layout du projet). Le modèle est la vue qui sera utilisée par chaque entrée pour s'afficher dans la liste associée avec ArrayAdapter ;
3. La collection : les données sous forme d'un tableau de chaînes de caractères.

Supposons, par exemple, que vous désiriez produire une liste dont chaque ligne est constituée d'une icône suivie d'un texte. Vous pourriez utiliser alors une disposition en lignes, dans un fichier de description spécifique appelé ligne.xml :

res/layout/ligne.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="horizontal"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content">
   <ImageView  
       android:id="@+id/icone"
       android:layout_width="wrap_content" 
       android:layout_height="wrap_content" 
       android:paddingTop="5px"
       android:paddingLeft="3px"
       android:src="@drawable/validation"  />  
                   // fichier image validation.png représentant l'icône placé dans le répertoire res/drawable.
   <TextView  
       android:id="@+id/texte"
       android:layout_width="wrap_content" 
       android:layout_height="wrap_content" 
       android:textSize="24sp"
       android:textStyle="bold|italic"
       android:textColor="#00BB00"  />
</LinearLayout>

  

Nous utilisons ici un conteneur LinearLayout afin de créer une ligne contenant une icône à gauche et un texte droite avec une grande police de caractères agréable à lire.

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
   <TextView  
       android:id="@+id/selection"
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content" 
       android:background="#FF9900"
       android:textColor="#FFFF00"
       android:textSize="24sp"
       android:paddingLeft="7dp"
       android:text="Votre choix ?"  />
   <ListView  
       android:id="@android:id/list"
       android:layout_width="fill_parent" 
       android:layout_height="fill_parent" />
</LinearLayout>

Dans le fichier de description principal, nous retrouvons l'ossature générale d'une liste classique avec, d'une part la balise <ListView>, et d'autre part la valeur spécifique"@android:id/list" attribuée à l'identification de la liste. Cela sous-entend, rappelez-vous, que l'activité soit une ListActivity.

fr.manu.test.ListeChoix.java

package fr.manu.test;

import android.app.*;
import android.os.Bundle;
import android.text.*;
import android.widget.*;

public class ListeChoix extends ListActivity {
   private TextView selection;
   private enum Semaine {Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche};
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      selection = (TextView) findViewById(R.id.selection);
      setListAdapter(new ArrayAdapter<Semaine>(this, R.layout.ligne, R.id.texte, Semaine.values()));     
   }

   @Override
   public void onListItemClick(ListView liste, View vue, int position, long id) {
      Semaine semaine = Semaine.values()[position];
      selection.setText(semaine.name());      
   }
}

Par défaut, Android ne sait pas que vous souhaitez utiliser cette disposition avec votre ListView. Afin d'établir cette connexion, vous devez donc indiquer à l'adaptateur l'identifiant de ressource de cette disposition personnalisée.

1. Le point essentiel de cet exemple est que nous avons indiqué à notre adaptateur ArrayAdapter que nous voulions utiliser notre propre disposition de ligne (R.layout.ligne) et que le TextView contenant la valeur de la semaine est désignée par R.id.texte dans cette disposition.
2. N'oubliez pas que, pour désigner une disposition ligne.xml, il faut préfixer le nom de base du fichier de description par R.layout (R.layout.ligne).
3. Il est aussi important de souligné, pour éviter tout disfonctionnement, que vous êtes obligé d'identifier chaque composant constituant la ligne, même si à priori vous n'y faites pas référence dans le code.

Nous allons reprendre l'idée du projet précédent. Cette fois-ci toutefois, nous remplaçons la petite icône par un petit commentaire textuel placé sous le jour de la semaine. Voici ci-dessous les différents codes que nous commenterons par la suite :

res/layout/ligne.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content">
   <TextView  
       android:id="@+id/semaine"
       android:layout_width="wrap_content" 
       android:layout_height="wrap_content" 
       android:textSize="20sp"
       android:textStyle="bold"
       android:textColor="#00BB00"/>
   <TextView  
       android:id="@+id/commentaire"
       android:layout_width="wrap_content" 
       android:layout_height="wrap_content" 
       android:textStyle="bold|italic"/>
</LinearLayout>  



  

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
   <TextView  
       android:id="@+id/selection"
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content" 
       android:background="#FF9900"
       android:textColor="#FFFF00"
       android:textSize="24sp"
       android:paddingLeft="7dp"
       android:text="Votre choix ?"  />
   <ListView  
       android:id="@android:id/list"
       android:layout_width="fill_parent" 
       android:layout_height="fill_parent" />
</LinearLayout>

Dans le fichier de description principal, nous retrouvons l'ossature générale d'une liste classique avec, d'une part la balise <ListView>, et d'autre part la valeur spécifique"@android:id/list" attribuée à l'identification de la liste. Cela sous-entend, rappelez-vous, que l'activité soit une ListActivity.

fr.manu.test.ListeChoix.java

package fr.manu.test;

import android.app.*;
import android.os.Bundle;
import android.text.*;
import android.widget.*;
import android.view.*

public class ListeChoix extends ListActivity {
   private TextView selection;
   private enum Semaine {Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche};
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      selection = (TextView) findViewById(R.id.selection);
      setListAdapter(new SemaineAdapter(this));     
   }

   @Override
   public void onListItemClick(ListView liste, View vue, int position, long id) {
      Semaine semaine = Semaine.values()[position];
      selection.setText(semaine.name());      
   }

   class SemaineAdapter extends ArrayAdapter {

      SemaineAdapter(Context context) {
         super(context, R.layout.ligne, Semaine.values());
      }

      @Override
      public View getView(int position, View convertView, ViewGroup parent) {
         LayoutInflater xml = ListeChoix.this.getLayoutInflater();
         View ligne = xml.inflate(R.layout.ligne, null);
         TextView semaine = (TextView) ligne.findViewById(R.id.semaine);
         TextView commentaire = (TextView) ligne.findViewById(R.id.commentaire);
         Semaine jour = Semaine.values()[position];
         semaine.setText(jour.name());
         switch (jour) {
            case Lundi :
            case Mardi :
            case Jeudi :
            case Vendredi : commentaire.setText("Bon travail à l'école"); break;
            case Mercredi :  commentaire.setText("Bon repos"); break;
            case Samedi :
            case Dimanche : commentaire.setText("Bon Week-end"); break;
         }
         return ligne;
      }  
   }
}

1. Comme choix d'adaptateur, il est souvent judicieux de choisir un ArrayAdapter comme classe de base. Dans ce cas là, seule la méthode getView() est à redéfinir. Si vous désidez de prendre l'adaptateur BaseAdapter, en plus de la méthode getView(), vous devez redéfinir les méthodes getCount(), getItem() et getItemId().
2. Le principe consiste donc à redéfinir la méthode getView() afin qu'elle renvoie une ligne dépendant de l'objet à afficher, qui est stipulé par l'indice position dans l'adaptateur.
3. Grâce à la classe LayoutInflater, nous mettons en oeuvre la technique d'inflation qui consiste à convertir une description XML dans l'arborescence d'objets View qu'elle représente, ce qui nous permet de récupérer toutes les valeurs utiles au traitement Java.
4. Ainsi, dans le traitement de la méthode getView() nous transformons la description R.layout.ligne. Ceci nous donne un objet View qui, en réalité, n'est autre que notre LinearLayout contenant deux TextView, exactement comme cela est spécifié par R.layout.ligne.
5. Cependant, au lieu de créer nous-même tous ces objets et de les lier ensemble, le code XML et la classe LayoutInflater gèrent pour nous les "détails scabreux".
6. Nous utilisons donc le LayoutInflater afin d'obtenir un objet View représentant la ligne. Cette ligne est "vide" car le fichier de description ne sait pas quelles sont les données qu'elle recevra. Il nous appartient donc de la personnaliser et de la remplir comme nous le souhaitons avant de la renvoyer.

Il s'agit bien sûr d'un exemple assez artificiel, mais cette technique peut servir à personnaliser les lignes en fonction de n'importe quel critère - le contenu des colonnes d'un Cursor par exemple.

Utilisation de convertView

L'implémentation de getView() que nous venons de mettre en oeuvre fonctionne très bien, mais malheureusement elle est aussi peu efficace. En effet, à chaque fois que l'utilisateur fait défilé l'écran, nous devons créer tout un lot de nouveaux objets View pour les nouvelles lignes qui s'affichent.

Le framework d'Android ne mettant pas automatiquement en cache les objets View existant, il est nécessaire de les recréer de nouveaux, même pour des lignes que nous venions de créer très peu de temps auparavant.

Ce traitement supplémentaire est par ailleurs aggravé par la charge qui est imposé au ramasse-miettes puisque celui-ci doit détruire tous les objets que nous créons.

1. La méthode getView() reçoit en paramètre un objet View nommé, par convention, convertView. Parfois, cet objet est null, auquel cas vous devez créer une nouvelle instance de View pour la ligne (par inflation), comme nous l'avons expliqué plus haut.
2. Si convertView n'est pas null, en revanche, il s'agit en fait de l'une des View que vous avez déjà créées. Ce sera notamment le cas lorsque l'utilisateur fait défiler la ListView : à mesure que de nouvelles lignes apparaissent, Android tentera de réutiliser les vues des lignes qui ont disparues à l'autre extrémité, vous évitant ainsi de devoir les reconstruire totalement.
3. Vous avez ci-dessous la modification du code qui tient compte des vues déjà construites :

fr.manu.test.ListeChoix.java

package fr.manu.test;

import android.app.*;
import android.os.Bundle;
import android.text.*;
import android.widget.*;
import android.view.*

public class ListeChoix extends ListActivity {
   private TextView selection;
   private enum Semaine {Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche};
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      selection = (TextView) findViewById(R.id.selection);
      setListAdapter(new SemaineAdapter(this));     
   }

   @Override
   public void onListItemClick(ListView liste, View vue, int position, long id) {
      Semaine semaine = Semaine.values()[position];
      selection.setText(semaine.name());      
   }

   class SemaineAdapter extends ArrayAdapter {

      SemaineAdapter(Context context) {
         super(context, R.layout.ligne, Semaine.values());
      }

      @Override
      public View getView(int position, View convertView, ViewGroup parent) {
         View ligne = convertView;
          if (ligne==null) {
             LayoutInflater xml = ListeChoix.this.getLayoutInflater();
             ligne = xml.inflate(R.layout.ligne, null);
          }
         TextView semaine = (TextView) ligne.findViewById(R.id.semaine);
         TextView commentaire = (TextView) ligne.findViewById(R.id.commentaire);
         Semaine jour = Semaine.values()[position];
         semaine.setText(jour.name());
         switch (jour) {
            case Lundi :
            case Mardi :
            case Jeudi :
            case Vendredi : commentaire.setText("Bon travail à l'école"); break;
            case Mercredi :  commentaire.setText("Bon repos"); break;
            case Samedi :
            case Dimanche : commentaire.setText("Bon Week-end"); break;
         }
         return ligne;
      }  
   }
}

Ainsi, si convertView est null, nous créons une ligne par inflation ; dans le cas contraire, nous nous contentons de la réutiliser. Le code pour remplir les contenus des deux TextView est identique dans les deux cas de figure. Nous évitons ainsi une étape d'inflation potentiellement coûteuse lorsque convertView n'est pas null.

Nous allons reprendre l'exemple qui réalise des conversions monétaires dans les deux sens en reprenant le nouveau composant Monnaie que nous avons généré. Cette fois-ci, il sera possible de choisir le nombre de chiffres pour les centimes, soit deux, soit trois (des millièmes) ou tout simplement sans montrer les centimes. Toutefois, rien n'est changé au niveau du fichier de description XML (la vue) :

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:stretchColumns="1">
    <TableRow>
       <fr.btsiris.monnaie.Monnaie 
          android:id="@+id/euro"
          android:layout_width="fill_parent" 
          android:layout_height="wrap_content"
          android:layout_span="3"/>
       <Button     
          android:layout_width="fill_parent" 
          android:layout_height="wrap_content" 
          android:text="Franc"
          android:onClick="calculFranc"  />
    </TableRow>
    <TableRow>
       <fr.btsiris.monnaie.Monnaie 
          android:id="@+id/franc"
          android:layout_width="fill_parent" 
          android:layout_height="wrap_content"
          android:layout_span="3"/>
       <Button     
          android:layout_width="fill_parent" 
          android:layout_height="wrap_content" 
          android:text="€uro"
          android:onClick="calculEuro"  />
    </TableRow>    
</TableLayout>

Nous allons maintenant modifier notre composant personnalisé afin qu'il puisse accepter différentes présentations de la monnaie suivant le nombre de centimes que nous désirons voir apparaître :

fr.manu.monnaie.Monnaie.java

package fr.btsiris.monnaie;

import android.content.Context;
import android.text.InputType;
import android.util.AttributeSet;
import android.view.Gravity;
import android.widget.EditText;
import java.text.*;

public class Monnaie extends EditText {
   private NumberFormat formatMonnaie;
   private String nombreDecimales = "0.00 ";
   private char symbole;

   public Monnaie(Context context, AttributeSet attrs, int defStyle) {
      super(context, attrs, defStyle);
      init();
   }

   public Monnaie(Context context, AttributeSet attrs) {
      super(context, attrs);
      init();
   }

   public Monnaie(Context context) {
      super(context);
      init();
   }
   
   private void init() {
      setSymbole('€');
      setValeur(0.0);
      setGravity(Gravity.RIGHT);
      setInputType(InputType.TYPE_CLASS_NUMBER);
   }

   public void setSymbole(char symbole) {
      this.symbole = symbole;
      formatMonnaie = new DecimalFormat("#,##"+nombreDecimales+symbole);
   }

   public double getValeur() {
      try {
         Number valeur = (Number) formatMonnaie.parse(getText().toString());
         setText(formatMonnaie.format(valeur));
         return valeur.doubleValue();
      } 
      catch (ParseException ex) { return 0.0; }
   }

   public void setValeur(double valeur) {
      setText(formatMonnaie.format(valeur));
   }

   public void setNombreDecimales(int nombre) {
      switch(nombre) {
         case 0 : nombreDecimales = "0 "; break;
         case 2 : nombreDecimales = "0.00 "; break;
         case 3 : nombreDecimales = "0.000 "; break; 
      }
      formatMonnaie = new DecimalFormat("#,##"+nombreDecimales+symbole);  
      getValeur(); 
   }
}

1. La grande nouveauté par rapport au code précédent, c'est la présence d'une nouvelle propriété nombreDécimales qui va servir au formatage du texte suivant la valeur monétaire désirée et bien sûr suivant le nombre de décimales après la virgule.
2. Pour que tout se passe correctement, il est aussi nécessaire cette fois-ci d'enregistrer le symbole de la monnaie.

Pour l'activité principale, nous devons maintenant mettre en oeuvre notre menu au moyen des deux méthodes importantes, savoir onCreateOptionsMenu() et onOptionsItemSelected().

fr.manu.monnaie.Conversion.java

package fr.btsiris.monnaie;

import android.app.Activity;
import android.os.Bundle;
import android.view.*;

public class Conversion extends Activity {
   private Monnaie euro, franc;
   private final double TAUX = 6.55957;
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState); 
       setContentView(R.layout.main);
       euro = (Monnaie) findViewById(R.id.euro);
       franc = (Monnaie) findViewById(R.id.franc);
       franc.setSymbole('F');     
       franc.setValeur(0.0);
   }
    
   public void calculFranc(View vue) {
      franc.setValeur(euro.getValeur() * TAUX);
   }
   
   public void calculEuro(View vue) {
      euro.setValeur(franc.getValeur() / TAUX);
   } 

   @Override
   public boolean onCreateOptionsMenu(Menu menu) {     
      menu.add(Menu.NONE, 0, Menu.NONE, "Pas de centimes");
      menu.add(Menu.NONE, 2, Menu.NONE, "2 chiffres");
      menu.add(Menu.NONE, 3, Menu.NONE, "3 chiffres");
      return super.onCreateOptionsMenu(menu);   // ou bien return true;
   }

   @Override
   public boolean onOptionsItemSelected(MenuItem item) {
      euro.setNombreDecimales(item.getItemId());
      franc.setNombreDecimales(item.getItemId());
      return super.onOptionsItemSelected(item);   // ou bien return true;
   }  
}

A titre d'exemple, sur le projet précédent, je propose cette fois-ci d'avoir un menu avec simplement deux options "Pas de centimes" et "Avec des centimes". Lorsque l'utilisateur choisi l'option "Avec des centimes" un sous-menu apparaît qui propose de visualiser les centimes ou les millièmes, avec deux ou trois chiffres :

Voici ci-dessous les modifications à apporter dans le code de Conversion.java afin d'obtenir le lancement de ce sous-menu :

fr.manu.monnaie.Conversion.java

package fr.btsiris.monnaie;

import android.app.Activity;
import android.os.Bundle;
import android.view.*;

public class Conversion extends Activity {
   private Monnaie euro, franc;
   private final double TAUX = 6.55957;
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState); 
       setContentView(R.layout.main);
       euro = (Monnaie) findViewById(R.id.euro);
       franc = (Monnaie) findViewById(R.id.franc);
       franc.setSymbole('F');     
       franc.setValeur(0.0);
   }
    
   public void calculFranc(View vue) {
      franc.setValeur(euro.getValeur() * TAUX);
   }
   
   public void calculEuro(View vue) {
      euro.setValeur(franc.getValeur() / TAUX);
   } 

   @Override
   public boolean onCreateOptionsMenu(Menu menu) {     
      menu.add(Menu.NONE, 0, Menu.NONE, "Pas de centimes");
      SubMenu sousMenu = menu.addSubMenu(Menu.NONE, -1, Menu.NONE, "Avec des centimes");
      sousMenu.add(Menu.NONE, 2, Menu.NONE, "2 chiffres");
      sousMenu.add(Menu.NONE, 3, Menu.NONE, "3 chiffres");
      sousMenu.setHeaderIcon(R.drawable.icon);
      return super.onCreateOptionsMenu(menu);   // ou bien return true;
   }

   @Override
   public boolean onOptionsItemSelected(MenuItem item) {
      if (item.getItemId() == -1) return true;
      euro.setNombreDecimales(item.getItemId());
      franc.setNombreDecimales(item.getItemId());
      return super.onOptionsItemSelected(item);   // ou bien return true;
   }  
}

Attention, lorsque l'utilisateur sélectionne le sous-menu, c'est un choix comme un autre, et du coup, la méthode de rappel onOptionsItemSelected() est également sollicité. Il faut donc prendre en compte ce choix particulier afin de faire la différence avec un véritable choix. C'est la raison pour laquelle, le sous-menu prend la valeur -1 pour l'identifiant de choix que nous devons évaluer avant de soumettre la valeur au monnaies euro et franc.

Toujours avec le même type de projet, je vous propose de mettre en oeuvre un menu contextuel associé à chacune des monnaies. Ainsi, il sera maintenant possible de personnaliser chacune des monnaies pour choisir le nombre de chiffres après la virgule :

Voici ci-dessous les modifications à apporter dans le code de Conversion.java afin d'obtenir le lancement de ce menu contextuel :

fr.manu.monnaie.Conversion.java

package fr.btsiris.monnaie;

import android.app.Activity;
import android.os.Bundle;
import android.view.*;
import android.view.ContextMenu.ContextMenuInfo;

public class Conversion extends Activity {
   private Monnaie euro, franc;
   private final double TAUX = 6.55957;
   private View monnaie;
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState); 
       setContentView(R.layout.main);
       euro = (Monnaie) findViewById(R.id.euro);
       franc = (Monnaie) findViewById(R.id.franc);
       franc.setSymbole('F');     
       franc.setValeur(0.0);
       registerForContextMenu(euro);
       registerForContextMenu(franc);
   }
    
   public void calculFranc(View vue) {
      franc.setValeur(euro.getValeur() * TAUX);
   }
   
   public void calculEuro(View vue) {
      euro.setValeur(franc.getValeur() / TAUX);
   } 

   @Override
   public void onCreateContextMenu(ContextMenu menu, View vue, ContextMenuInfo menuInfo) {     
      menu.clear();
      menu.setHeaderTitle("Nombre de décimales");
      menu.setHeaderIcon(R.drawable.icon);
      menu.add(Menu.NONE, 0, Menu.NONE, "Pas de centimes");
      menu.add(Menu.NONE, 2, Menu.NONE, "2 chiffres");
      menu.add(Menu.NONE, 3, Menu.NONE, "3 chiffres");
      monnaie = vue; 
   }

   @Override
   public boolean onContextItemSelected(MenuItem item) {
      if (monnaie.equals(euro)) euro.setNombreDecimales(item.getItemId());
      if (monnaie.equals(franc)) franc.setNombreDecimales(item.getItemId());
      return super.onOptionsItemSelected(item);
   }  
}

1. Dans la méthode onCreate() de l'activité, il est nécessaire d'enregistrer les vues qui lancent le menu contextuel au travers de la méthode registerForContextMenu().
2. La méthode onCreateContextMenu() est appelée à chaque fois que le menu contextuel est appelé. Nous constituons donc notre menu en effaçant au préalable les choix proposés par défaut par Android qui permettent, comme il s'agit d'une zone de saisie, de réaliser par exemple du copier-coller.
3. Afin de connaître quelle zone de saisie propose ce sous-menu, il est préférable de l'enregistrer au travers d'un attribut adapté, ici monnaie.
4. Dès que l'utilisateur à fait son choix, la méthode onContextItemSelected() est lancée. Vous devez maintenant tester qu'elle est la zone de saisie qui désire changer le nombre de chiffres après la virgule et de faire le changement uniquement sur le bon composant.

Je vous propose de reprendre tout simplement le projet précédent qui affiche un message surgissant circonstancié suivant le nombre de chiffres choisi sur la monnaie qui vous intéresse :

fr.manu.monnaie.Conversion.java

package fr.btsiris.monnaie;

import android.app.Activity;
import android.os.Bundle;
import android.view.*;
import android.view.ContextMenu.ContextMenuInfo;
import android.widget.Toast;

public class Conversion extends Activity {
   private Monnaie euro, franc;
   private final double TAUX = 6.55957;
   private View monnaie;
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState); 
       setContentView(R.layout.main);
       euro = (Monnaie) findViewById(R.id.euro);
       franc = (Monnaie) findViewById(R.id.franc);
       franc.setSymbole('F');     
       franc.setValeur(0.0);
       registerForContextMenu(euro);
       registerForContextMenu(franc);
   }
    
   public void calculFranc(View vue) {
      franc.setValeur(euro.getValeur() * TAUX);
   }
   
   public void calculEuro(View vue) {
      euro.setValeur(franc.getValeur() / TAUX);
   } 

   @Override
   public void onCreateContextMenu(ContextMenu menu, View vue, ContextMenuInfo menuInfo) {     
      menu.clear();
      menu.setHeaderTitle("Nombre de décimales");
      menu.setHeaderIcon(R.drawable.icon);
      menu.add(Menu.NONE, 0, Menu.NONE, "Pas de centimes");
      menu.add(Menu.NONE, 2, Menu.NONE, "2 chiffres");
      menu.add(Menu.NONE, 3, Menu.NONE, "3 chiffres");
      monnaie = vue; 
   }

   @Override
   public boolean onContextItemSelected(MenuItem item) {
      String nom = "";
      if (monnaie.equals(euro)) {
         euro.setNombreDecimales(item.getItemId());
         nom = "€uro";
      }
      if (monnaie.equals(franc)) {
         franc.setNombreDecimales(item.getItemId());
         nom = "Franc";
      }
      if (nom.length()!=0) {
         String decimales = item.getItemId() == 0 ? " sans décimale" : " utilise "+ item.getItemId() + " décimales";
         Toast.makeText(this, nom + decimales, Toast.LENGTH_SHORT).show();
      }     
      return super.onOptionsItemSelected(item);
   }  
}

Sur le projet précédent, même si cela n'est pas du tout judicieux, je vous invite à enlever le toast et de proposer maintenant une boîte d'alerte :

fr.manu.monnaie.Conversion.java

package fr.btsiris.monnaie;

import android.app.*;
import android.os.Bundle;
import android.view.*;
import android.view.ContextMenu.ContextMenuInfo;

public class Conversion extends Activity {
   private Monnaie euro, franc;
   private final double TAUX = 6.55957;
   private View monnaie;
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState); 
       setContentView(R.layout.main);
       euro = (Monnaie) findViewById(R.id.euro);
       franc = (Monnaie) findViewById(R.id.franc);
       franc.setSymbole('F');     
       franc.setValeur(0.0);
       registerForContextMenu(euro);
       registerForContextMenu(franc);
   }
    
   public void calculFranc(View vue) {
      franc.setValeur(euro.getValeur() * TAUX);
   }
   
   public void calculEuro(View vue) {
      euro.setValeur(franc.getValeur() / TAUX);
   } 

   @Override
   public void onCreateContextMenu(ContextMenu menu, View vue, ContextMenuInfo menuInfo) {     
      menu.clear();
      menu.setHeaderTitle("Nombre de décimales");
      menu.setHeaderIcon(R.drawable.icon);
      menu.add(Menu.NONE, 0, Menu.NONE, "Pas de centimes");
      menu.add(Menu.NONE, 2, Menu.NONE, "2 chiffres");
      menu.add(Menu.NONE, 3, Menu.NONE, "3 chiffres");
      monnaie = vue; 
   }

   @Override
   public boolean onContextItemSelected(MenuItem item) {
      String nom = "";
      if (monnaie.equals(euro)) {
         euro.setNombreDecimales(item.getItemId());
         nom = "€uro";
      }
      if (monnaie.equals(franc)) {
         franc.setNombreDecimales(item.getItemId());
         nom = "Franc";
      }
      if (nom.length()!=0) {
         String decimales = item.getItemId() == 0 ? "Sans décimale" : item.getItemId() + " décimales";
         new AlertDialog.Builder(this)
                 .setTitle(nom)
                 .setIcon(R.drawable.icon)
                 .setMessage(decimales)
                 .setNeutralButton("Fermeture", null)
                 .show();
      }     
      return super.onOptionsItemSelected(item);
   }  
}

La méthode setNeutralButton(), comme les autres méthodes connexes, prend en deuxième paramètre un écouteur de type OnClickListener que vous devez implémenter afin de réaliser le traitement souhaité lorsque l'utilisateur clique sur le bouton. Ici, il ne fallait rien faire de spécial, la valeur de ce paramètre est donc null.

Un exemple typique de l'utilisation de la classe Handler pour gérer les threads est l'intégration d'une barre de progression dans l'interface. Voici ci-dessous le fichier de mise en page de l'activité :

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<ProgressBar xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/progression"
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    style="@android:style/Widget.ProgressBar.Horizontal"
/>














  

Voici également le code associé utilisant le Handler pour communiquer entre le thread d'arrière-plan et celui de l'interface utilisateur :

fr.btsiris.tache.Tache.java

package fr.btsiris.tache;

import android.app.Activity;
import android.os.*;
import android.widget.ProgressBar;

public class Tache extends Activity {
    private ProgressBar progression;
    private boolean enExecution = false;
    
    private Handler  communication = new Handler() {
      @Override
      public void handleMessage(Message msg) {
         progression.incrementProgressBy(1);
      }      
    };
    
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        progression = (ProgressBar) findViewById(R.id.progression);
    }

   @Override
   protected void onStart() {
      super.onStart();
      progression.setProgress(0);
      enExecution = true;
      new Thread(new TacheDeFond()).start();
   }

   @Override
   protected void onStop() {
      super.onStop();
      enExecution = false;
   }  
   
   private class TacheDeFond implements Runnable {
      @Override
      public void run() {
         try {
            for (int i=0; i<100 && enExecution; i++) {
               Thread.sleep(100);
               communication.sendMessage(communication.obtainMessage());
            }
         }
         catch (Throwable t) {}
      }      
   }
}

1. Une partie de la construction de l'activité passe par la création d'une instance de Handler, communication, contenant l'implémentation de handleMessage(). Pour chaque message reçu, nous nous contentons de faire avancer la barre de progression de 1 point puis nous sortons du gestionnaire de message le plus vite possible.
2. Dans la méthode onStart(), nous configurons un thread en arrière-plan. Dans une vraie application, celui-ci effectuerait une tâche significative mais, ici, nous nous mettons simplement en pause pendant 1/10 de seconde, nous postons le Message au Handler et nous répétons ces deux opérations 100 fois. Combiné avec la progression d'une unité de la position de la barre de progression, ce traitement fera donc avancer la barre à travers tout l'écran puisque la valeur maximale par défaut de la barre est 100.
3. Notez que nous devons ensuite quitter la méthode onStart(). C'est un point crucial : la méthode onStart() est appelée dans le thread qui gère l'interface utilisateur de l'activité afin qu'elle puisse modifier les widgets et tout ce qui affecte cette interface - la barre de titre, par exemple. Ceci signifie donc que nous devons sortir de la méthode onStart(), à la fois pour laisser le Handler faire son travail et pour qu'Android ne pense pas que notre activité est bloquée.

Notez que, bien que le code de cet exemple s'arrange pour mettre à jour la barre de progression dans le thread de l'interface graphique, ce n'est pas nécessaire. A partir d'Android 1.5, en effet, ProgressBar est thread safe, ce qui signifie que vous pouvez la modifier à partir de n'importe quel thread et qu'elle gèrera les détails de la modification de l'interface graphique dans le thread de celle-ci.

Vous remarquez que le message envoyé n'est pas du tout utiliser par la méthode handleMessage() de l'objet communication. Du coup, il est possible d'utiliser éventuellement la méthode sendEmptyMessage() au lieu de la méthode sendMessage() dans notre tâche de fond :

fr.btsiris.tache.Tache.java

...
   private class TacheDeFond implements Runnable {
      @Override
      public void run() {
         try {
            for (int i=0; i<100 && enExecution; i++) {
               Thread.sleep(100);
               communication.sendEmptyMessage(0);
            }
         }
         catch (Throwable t) {}
      }      
   }
}

Les objets Runnable

Si vous préférez ne pas vous ennuyer avec les objets Message, vous pouvez également passer des objets Runnable au Handler, qui les exécutera dans le thread de l'interface utilisateur. La classe Handler fournit un ensemble de méthodes post(), postAsFrontOfQueue(), postDelayed() et postAtTime() pour faire passer les objets Runnable afin qu'ils soient traités.

Démarrer une activité fille sans tenir compte du retour

Après tout ce préambule, je vous propose de prendre le premier cas, qui se présente assez souvent, et qui consiste à posséder plusieurs activités dans une même application. Ainsi, une activité principale lancera, au travers des intentions, plusieurs activités filles, dans un premier temps, sans attendre une valeur quelconque de leur part.

Afin de mieux comprendre le lancement des activités filles, je vous propose de réaliser un projet qui réalise des conversions entre les radians et les degrés :

Attention, avant de pouvoir démarrer une activité, il est nécessaire au préalable de la déclarer dans le fichier de configuration AndroidManifest.xml de l'application. Sans cela, une erreur de type ActivityNotFoundException sera générée lors de l'appel de la méthode startActivity().

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.radian"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="Angles" android:icon="@drawable/icon">
        <activity android:name="Choix" android:label="Conversion des angles">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name="Radian" android:label="Recherche du radian" />
        <activity android:name="Degre" android:label="Recherche du degré" />
    </application>
</manifest>

Nous remarquons au travers de ce manifeste que l'activité principale de cette application se nomme Choix. Par ailleurs, deux autres activités sont déclarées, respectivement Radian et Degre qui sont les activités filles de Choix.

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:padding="3px">
   <Button  
       android:layout_width="0px" 
       android:layout_height="wrap_content" 
       android:layout_weight="1"
       android:text="Radian"
       android:onClick="calculRadian" />
   <Button  
       android:layout_width="0px" 
       android:layout_height="wrap_content" 
       android:layout_weight="1"
       android:text="Degré"      
       android:onClick="calculDegre" />       
</LinearLayout>

fr.btsiris.radian.Choix.java

package fr.btsiris.radian;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;

public class Choix extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
    
    public void calculRadian(View vue) {
       startActivity(new Intent(this, Radian.class));
    }

    public void calculDegre(View vue) {
       startActivity(new Intent(this, Degre.class));       
    }
}

Cette activité principale est très simple. Elle possède juste les deux méthodes déjà déclarées dans le fichier de description principal et qui s'occupent de lancer les activités filles au travers de la méthode startActivity() et des Intentions respectives.

Maintenant, pour chacune des activités filles, vous devez créer un fichier de description spécifique ainsi que la classe correspondante. Comme beaucoup d'éléments sont en commun, nous allons même créer une classe de base qui factorise tous ces éléments. Ainsi chacune de ces sous-activités héritera de cette classe.

res/layout/radian.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:padding="3px">
   <EditText
       android:id="@id/degre"
       android:layout_width="0px" 
       android:layout_height="wrap_content" 
       android:layout_weight="1"
       android:inputType="number" />
   <Button  
       android:layout_width="0px" 
       android:layout_height="wrap_content" 
       android:layout_weight="1"
       android:text="Radian"      
       android:onClick="calcul" />
    <EditText
       android:id="@id/radian"       
       android:layout_width="0px" 
       android:layout_height="wrap_content" 
       android:layout_weight="1"
       android:editable="false" />      
</LinearLayout>

res/layout/degre.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:padding="3px">
   <EditText
       android:id="@+id/radian"         
       android:layout_width="0px" 
       android:layout_height="wrap_content" 
       android:layout_weight="1"
       android:inputType="numberDecimal" />
   <Button  
       android:layout_width="0px" 
       android:layout_height="wrap_content" 
       android:layout_weight="1"
       android:text="Degré"      
       android:onClick="calcul" />
   <EditText
       android:id="@+id/degre"       
       android:layout_width="0px" 
       android:layout_height="wrap_content" 
       android:layout_weight="1"
       android:editable="false" />      
</LinearLayout>

Ces deux fichiers se ressemblent beaucoup. Toutefois, remarquez bien que dans le descripteur degre.xml, nous avons la déclaration de nouveaux identifiants, respectivement radian et degre, alors que dans le descripteur radian.xml, nous utilisons simplement ces déclarations, sachant que degre.xml va être compilé en premier (ordre alphabétique).

Nous décrivons ensuite la classe de base abstraite Conversion qui représente la partie commune des deux activités filles, suivi des deux activités qui héritent de cette classe abstraite et qui redéfinissent la méthode calcul().

fr.btsiris.radian.Conversion.java

package fr.btsiris.radian;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import java.text.*;

public abstract class Conversion extends Activity {
   EditText degre, radian;
   NumberFormat formatRadian = new DecimalFormat("0.00");
   NumberFormat formatDegre= new DecimalFormat("0 °");   
   
   @Override
   public void onCreate(Bundle icicle) {
      super.onCreate(icicle);
      degre = (EditText) findViewById(R.id.degre);
      radian =  (EditText) findViewById(R.id.radian);  
      degre.setText(formatDegre.format(0));
      radian.setText(formatRadian.format(0));       
   }
   
   public abstract void calcul(View vue);
}

fr.btsiris.radian.Radian.java

package fr.btsiris.radian;

import android.os.Bundle;
import android.view.View;
import java.text.*;

public class Radian extends Conversion {

   @Override
   public void onCreate(Bundle icicle) {
      setContentView(R.layout.radian);
      super.onCreate(icicle);    
   }
 
   @Override  
   public void calcul(View vue) {
      try {
         Number valeur = formatDegre.parse(degre.getText().toString());
         radian.setText(formatRadian.format(valeur.doubleValue() * Math.PI / 360));
      } 
      catch (ParseException ex) { }   
   }
}

fr.btsiris.radian.Degre.java

package fr.btsiris.radian;

import android.os.Bundle;
import android.view.View;
import java.text.*;

public class Degre extends Conversion {

   @Override
   public void onCreate(Bundle icicle) {
      setContentView(R.layout.degre); 
      super.onCreate(icicle);     
   }
   
   @Override
   public void calcul(View vue) {
      try {
         Number valeur = formatRadian.parse(radian.getText().toString());
         degre.setText(formatDegre.format(valeur.doubleValue() * 360 / Math.PI));
      } 
      catch (ParseException ex) { }         
   }
}

Lancement simplifiée des sous-activités avec des onglets

Les onglets peuvent contenir une vue ou une activité. Lors de l'étude précédente, nous avons mis en oeuvre les onglets avec des vues distinctes. C'était d'ailleurs relativement complexe à mettre en place, d'une part côté descripteur XML et d'autre part dans le code Java. Toutefois, dans le cas où chaque onglet représente une activité fille, c'est beaucoup plus simple à réaliser.

Vous n'avez plus à générer de descripteur, il suffit de fournir l'intention qui lancera l'activité souhaitée ; le framework de gestion des onglets placera alors automatiquement l'interface utilisateur de cette activité dans l'onglet.

Je vous propose de modifier le projet précédent, en supprimant la première page avec les deux boutons qui réalisent le choix de conversion, et de la remplacer par une gestion des onglets qui effectueront le même type de choix :

Dans ce cas de figure, nous n'avons plus du tout besoin du fichier de description principal main.xml. Toute la mise oeuvre des onglets se fait uniquement dans le code Java au travers de l'activité principale Choix.java.

fr.btsiris.radian.Choix.java

package fr.btsiris.radian;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.TabHost;

public class Choix extends TabActivity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        TabHost onglets = getTabHost();
        onglets.addTab(onglets.newTabSpec("radian")
                                            .setIndicator("Radian")
                                            .setContent(new Intent(this, Radian.class)));
        onglets.addTab(onglets.newTabSpec("degre")
                                            .setIndicator("Degré")
                                            .setContent(new Intent(this, Degre.class)));       
    }
}

Comme vous pouvez le constater, notre classe hérite de TabActivity : nous n'avons donc pas besoin de créer de fichier de description XML car TabActivity s'en occupe pour nous. Nous nous contentons d'accéder au TabHost et de lui ajouter deux onglets, chacun précisant une intention qui fait directement référence à une autre classe. Ici, nos deux onglets hébergeront respectivement un Radian et un Degre.

Vous remarquez également que le bouton de soumission se nomme maintenant tout simplement calcul puisque l'onglet nous précise sur quel traitement nous sommes. Du coup cette description du bouton est identique pour les deux fichiers de description. Je préfère du coup en faire un fichier à part entière que je nomme calcul.xml. Enfin, il n'est plus nécessaire de proposer un intitulé particulier pour chacune de ces sous-activité, je vais donc simplifier le manifeste en conséquence.

res/layout/calcul.xml

<?xml version="1.0" encoding="UTF-8"?>
<Button xmlns:android="http://schemas.android.com/apk/res/android"  
    android:layout_width="0px" 
    android:layout_height="wrap_content" 
    android:layout_weight="1"
    android:text="Calcul"      
    android:onClick="calcul" 
 />

res/layout/radian.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:padding="3px"
>
   <EditText
       android:id="@id/degre"
       android:layout_width="0px" 
       android:layout_height="wrap_content" 
       android:layout_weight="1"
       android:inputType="number"
     />
    <include layout="@layout/calcul" />
    <EditText
       android:id="@id/radian"       
       android:layout_width="0px"
       android:layout_height="wrap_content" 
       android:layout_weight="1"
       android:editable="false"
    />      
</LinearLayout>

res/layout/degre.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:padding="3px"
>
   <EditText
       android:id="@+id/radian"         
       android:layout_width="0px" 
       android:layout_height="wrap_content" 
       android:layout_weight="1"
       android:inputType="numberDecimal"
    />    
   <include layout="@layout/calcul" />
   <EditText
       android:id="@+id/degre"       
       android:layout_width="0px" 
       android:layout_height="wrap_content" 
       android:layout_weight="1"
       android:editable="false"
    />      
</LinearLayout>

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.radian"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="Angles" android:icon="@drawable/icon">
        <activity android:name="Choix" android:label="Conversion des angles">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name="Radian"  />
        <activity android:name="Degre"  />
    </application>
</manifest>

Démarrer une activité et obtenir un retour

Comme nous venons de le voir, la méthode startActivity() de la classe Activity permet de démarrer une autre activité "activité enfant". Cette méthode, bien que très utile dans son usage courant, ne propose cependant aucun mécanisme de retour d'infromation vers l'activité "parent" qui a démarré l'activité enfant. En d'autres termes, vous ne serez jamais averti de l'état de l'activité enfant que vous aurez lancée.

Prenons comme exemple une activité enfant proposant à l'utilisateur un formulaire de réponse sur le nombre de chiffres après la virgule pour le calcul des radians. Comment récupérer la valeur saisie par l'uilisateur dans l'activité enfant depuis l'activité principale ?

Pour gérer ce type de scénario, à savoir lancer une activité enfant et en connaître sa valeur de retour, il est possible d'utiliser la méthode startActivityForResult() prévue à cet effet. Avec cette méthode, lorsque l'activité enfant aura terminé sa tâche, elle en avertira l'activité parent.

1. Spécificité de la méthode d'appel : La méthode startActivityForResult() a besoin de deux paramètres. Le premier correspond à l'intention, le deuxième à une valeur numérique correspondant au code de l'activité parente qui est à votre libre choix. Si la valeur est inférieure à 0, l'activité parent n'attend pas de retour, ce qui équivaut à utiliser la méthode startActivity().
2. Renvoyer une valeur de retour : Pour renvoyer la valeur de retour à l'activité principale, appelez la méthode setResult() de la classe Activity en indiquant en paramètre le code de retour. Android prévoit plusieurs valeurs par défaut telles que RESULT_OK et RESULT_CANCELED, etc.
3. Arrêter l'activité enfant : Pour arrêter explicitement une activité enfant afin de revenir sur l'activité parent qui l'a démarré, il suffit de faire appel à la méthode finish() de la classe Activity.
4. Récupérer la valeur de retour : Pour récupérer la valeur de retour envoyé par une activité enfant, utiliser la méthode onActivityResult() de l'activité parent, depuis laquelle vous avez appelé la méthode startActivityForResult().

La méthode onActivityResult() utilise trois paramètres pour identifier l'activité et ses valeurs de retour :

1. int requestCode : valeur identifiant quelle activité a appelé la méthode. Cette même valeur a été spécifiée comme deuxième paramètre de la méthode startActivityForResult() lors du démarrage de la sous-activité.
2. int resultCode : représente la valeur de retour envoyée par la sous-activité pour signaler normalement son état à la fin de la transaction. C'est une constante définie dans la class Activity (RESULT_OK, RESULT_CANCELED, etc.) ou par le développeur.
3. Intent data : cet objet permet d'échanger des données comme nous le verrons bientôt.

Encore une fois, je vous propose de modifier le projet précédent. Cette fois-ci, nous disposons d'une activité principale qui permet de faire la conversion des angles dans les deux sens et dispose d'un bouton supplémentaire qui permet de choisir le nombre de chiffres après la virgule pour la visualisation des radians. Ce réglage est effectué au moyen d'une activité enfant spécifique :

Dans ce cas de figure, nous disposons maintenant de deux fichiers de descriptions, respectivement main.xml et reglage.xml. Par ailleurs, les deux activités sont représentées par les classes Conversion pour l'activité principale et Reglage pour l'activité enfant. Vous devez donc modifier le manifeste afin de respecter tous ces changements.

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical"
    android:padding="3px">
    <LinearLayout
         android:layout_width="fill_parent"
         android:layout_height="wrap_content"
         android:padding="2px">   
         <EditText
             android:id="@+id/radian"         
             android:layout_width="0px" 
             android:layout_height="wrap_content" 
             android:layout_weight="2"
             android:inputType="numberDecimal"/>
         <Button 
             android:layout_width="0px" 
             android:layout_height="wrap_content" 
             android:layout_weight="1"
             android:text="Degré"      
             android:onClick="calculDegre" />
    </LinearLayout> 
    <LinearLayout
         android:layout_width="fill_parent"
         android:layout_height="wrap_content"
         android:padding="2px">        
         <EditText
             android:id="@+id/degre"       
             android:layout_width="0px" 
             android:layout_height="wrap_content" 
             android:layout_weight="2"
             android:inputType="number" />      
         <Button 
             android:layout_width="0px" 
             android:layout_height="wrap_content" 
             android:layout_weight="1"
             android:text="Radian"      
             android:onClick="calculRadian" />       
    </LinearLayout>  
    <Button 
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content" 
       android:text="Nombre de décimales"      
       android:onClick="reglage" />  
</LinearLayout>

res/layout/reglage.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:padding="3px">
   <EditText
       android:id="@+id/reglage"
       android:layout_width="0px" 
       android:layout_height="wrap_content" 
       android:layout_weight="1"
       android:text="2"
       android:selectAllOnFocus="true"
       android:inputType="number" />
   <Button 
       android:layout_width="0px" 
       android:layout_height="wrap_content" 
       android:layout_weight="1"
       android:text="Valider"      
       android:onClick="valider" 
    />    
</LinearLayout>

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.radian"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="Angles" android:icon="@drawable/icon">
        <activity android:name="Conversion" android:label="Conversion des angles">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name="Reglage"  android:label="Nombre de décimales (Radian)" />
    </application>
</manifest>

fr.btsiris.radian.Conversion.java

package fr.btsiris.radian;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import java.text.*;

public class Conversion extends Activity {
   EditText degre, radian;
   NumberFormat formatRadian = new DecimalFormat("0.00");
   NumberFormat formatDegre= new DecimalFormat("0 °");   
   
   @Override
   public void onCreate(Bundle icicle) {
      super.onCreate(icicle);
      setContentView(R.layout.main);
      degre = (EditText) findViewById(R.id.degre);
      radian =  (EditText) findViewById(R.id.radian);  
      degre.setText(formatDegre.format(0));
      radian.setText(formatRadian.format(0));       
   }
   
   public void calculRadian(View vue) {
      try {
         Number valeur = formatDegre.parse(degre.getText().toString());
         radian.setText(formatRadian.format(valeur.doubleValue() * Math.PI / 360));
      } 
      catch (ParseException ex) { }         
   }
   
   public void calculDegre(View vue) {
      try {
         Number valeur = formatRadian.parse(radian.getText().toString());
         degre.setText(formatDegre.format(valeur.doubleValue() * 360 / Math.PI));
      } 
      catch (ParseException ex) { }         
   }
   
   public void reglage(View vue) {
      startActivityForResult(new Intent(this, Reglage.class), 1); // 1 correspond au numéro d'identification de l'activité
   }

   @Override
   protected void onActivityResult(int requestCode, int resultCode, Intent data) {
      if (resultCode>0 && resultCode<=5) {
         try {
            Number valeur = formatRadian.parse(radian.getText().toString());
            String motif = "0";
            for (int i=1; i<resultCode; i++) motif +=  "0";
            formatRadian = new DecimalFormat("0."+motif);           
            radian.setText(formatRadian.format(valeur));
         } 
         catch (ParseException ex) { }
      }  
   }
}

fr.btsiris.radian.Reglage.java

package fr.btsiris.radian;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;

public class Reglage extends Activity {
   private EditText reglage;
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.reglage);
       reglage = (EditText) findViewById(R.id.reglage);
   }
   
   public void valider(View vue) {
      setResult(Integer.parseInt(reglage.getText().toString()));
      finish();
   }
}

Comme nous venons de l'évoquer, au travers de la méthode setResult(), nous devons spécifier si l'utilisateur accepte les réglages ou pas en donnant une valeur entière prédéfinie (RESULT_OK, RESULT_CANCELED, etc.). Comme, nous pouvons proposer une valeur entière avec cette méthode, je m'en sers pour envoyer le nombre de chiffres après la virgule pour les radians.

Exemple de mise en oeuvre

Dans ce type de scénario, l'activité lancée est plutôt un "pair" de l'activité qui l'a lancée. Elle sera donc lancée comme une activité classique. Votre activité ne sera pas informée de la fin de sa "fille" mais, encore une fois, elle n'a pas vraiment besoin de le savoir.

Afin de mieux comprendre le lancement d'une activité paire, je vous propose de réaliser un projet qui affiche la carte d'un lieu en spécifiant sa localisation à l'aide de la latitude et de la longitude.

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical"
    android:padding="3px">
    <LinearLayout
       android:layout_width="fill_parent"
       android:layout_height="wrap_content">
       <TextView  
          android:layout_width="0dp" 
          android:layout_height="wrap_content" 
          android:text="Lieu : "
          android:textStyle="bold"
          android:layout_weight="1"  />
       <EditText
          android:id="@+id/latitude"
          android:layout_width="0dp" 
          android:layout_height="wrap_content" 
          android:layout_weight="2"
          android:inputType="numberDecimal"  />          
       <EditText
          android:id="@+id/longitude"
          android:layout_width="0dp" 
          android:layout_height="wrap_content" 
          android:layout_weight="2"
          android:inputType="numberDecimal"   />                  
    </LinearLayout>
    <Button
        android:layout_width="fill_parent" 
        android:layout_height="wrap_content"  
        android:text="Visualiser !"
        android:onClick="visualiser"  />
</LinearLayout>

Ce fichier de description est assez simple puisqu'il contient deux champs pour la latitude et la longitude, ainsi qu'un bouton pour lancer l'activité paire.

fr.btsiris.geo.Geolocalisation.java

package fr.btsiris.geo;

import android.app.Activity;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;

public class Geolocalisation extends Activity {
   private EditText latitude, longitude;
   
   @Override
   public void onCreate(Bundle savedInstanceState)  {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.main);
       latitude = (EditText) findViewById(R.id.latitude);
       longitude = (EditText) findViewById(R.id.longitude);
   }
   
   public void visualiser(View vue) {
      String lat = latitude.getText().toString();
      String lon = longitude.getText().toString();
      Uri coord = Uri.parse("geo:"+lat+","+lon);
      startActivity(new Intent(Intent.ACTION_VIEW, coord));
   }
}

Lorsque nous cliquons sur le bouton de visualisation, l'activité de cartographie intégrée à Android est automatiquement lancée avec les coordonnées de géolocalisation (latitude et longitude). Pour cette application, nous n'avons pas eu besoin de créer une activité fille pour afficher cette carte. Nous utilisons les compétences de l'environnement.

Le script de création des applications Android (activityCreator ou son équivalent dans un IDE comme NetBeans) fournit des filtres d'intention à tous les projets. Voici ci-dessous le manifeste du dernier projet que nous avons mis en oeuvre :

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.tache"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="@string/app_name" android:icon="@drawable/icon">
        <activity android:name="Tache" android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

1. Notez la présence de l'élément <intent-filter> sous l'élément <activity>.
2. Il annonce que cette activité est l'activité principale de cette application.
3. De plus, elle appartient à la catégorie LAUNCHER, ce qui signifie qu'elle aura une icône dans le menu principal d'Android.

Cette activité étant l'activité principale de l'application, Android sait qu'elle est le composant qu'il devra lancer lorsqu'un utilisateur choisit cette application à partir du menu principal.

Vous pouvez bien sûr indiquer plusieurs actions ou catégories dans vos filtres d'intention afin de préciser que le composant associé (l'activité) gère plusieurs sortes d'intentions différentes.

Il est fort probable que vous voudrez également que vos activités secondaires (non principales) précisent le type MIME des données qu'elles manipulent. Ainsi, si une intention est destinée à ce type MIME, directement ou indirectement via une URI référençant une ressource de ce type, Android saura que le composant sait gérer ces données. Chaque élément de la balise <intent-filter> est important puisqu'il détermine le niveau de filtrage :

<activity ...>
    <intent-filter>
         <action android:name="android.intent.action.VIEW" />
         <category android:name="android.intent.category.DEFAULT" />
         <category android:name="android.intent.category.BROWSABLE" />
         <data android:scheme="demo" />
    </intent-filter>
</activity>

1. action : identifiant unique sous forme de chaîne de caractères. Il est d'usage d'utiliser la convention de nom Java. Utilise l'attribut android:name pour spécifier le nom de l'action à laquelle répondre.
2. category : premier niveau de filtrage de l'action. Cette balise indique dans quelle circonstance l'action va s'effectuer ou non. Il est possible d'ajouter plusieurs balises de catégorie. Utilise l'attribut android:name pour spécifier dans quelles circonstances une réponse doit être donnée à l'action.
3. data : filtre l'objet Intent au niveau des données elles-mêmes. Par exemple, en jouant avec l'attribut android:host, nous pouvons répondre à une action comportant un nom de domaine particulier, comme www.site.com. Cette balise vous permet ainsi de spécifier sur quels types de données vos composants peuvent agir. Vous pouvez inclure plusieurs balises <data> selon vos besoin.

Grâce à la définition de ce filtre, l'activité déclarée par le fichier de configuration de l'application ci-dessus réagira à l'action du code suivant :
.

Uri valeurs = Uri.parse("demo://Ceci est une chaîne de caractères");
Intent composerNuméro = new Intent(Intent.ACTION_VIEW, valeurs);
startActivity(composerNuméro);

Vous noterez qu'encore une fois, nous n'avons pas spécifié la classe du composant à utiliser pour cette action, ni explicitement quelle activité démarrer. C'est le système qui détermine seul le composant le mieux adapté en interrogeant les filtres définis dans les différents fichiers de configuration des applications installées.

Toutes les catégories associéesà la balise <category>

1. ALTERNATIVE : Cette catégorie spécifie que l'action doit être disponible comme une alternative à l'action par défaut effectuée sur un élément de ce type de données. Par exemple, si l'action par défaut sur un contact est de l'affiché, l'alternative pourraît être de l'éditer.
2. SELECTED_ALTERNATIVE : Semblable à la catégorie précédente mais, alors que cette dernière effectuera toujours la résolution en une seule action en utilisant la résolution de l'Intent décrite à la suite, SELECTED_ALTERNATIVE sera utilisée lorsque plusieurs possibilités seront requises. Comme nous le verrons ultérieurement, l'un des usages est d'aider à remplir dynamiquement les menus contextuels à l'aide d'actions.
3. BROWSABLE : Spécifie une action disponible dans le navigateur. Lorsqu'un Intent est déclenché depuis celui-ci, il comprend toujours cette catégorie. Vous devez inclure cette catégorie si vous voulez que votre application réponde aux actions déclenchées dans le navigateur (intercepter les liens vers un site web particulier, par exemple).
4. DEFAULT : Fait d'un composant l'action par défaut pour le type de données spécifié. Ceci est nécessaire pour les activités lancées en utilisant un Intent explicite.
5. GADGET : En utilisant cette catégorie, vous spécifiez que l'activité peut être exécutée au sein d'une autre activité.
6. HOME : En utilisant cette catégorie sans spécifier d'action, vous la présentez comme une alternative à l'écran d'accueil natif.
7. LAUNCHER : L'utilisation de cette catégorie fait apparaître l'activité dans le lanceur d'applications.

Tous les attributs possibles associés à la balise <data>

1. android:host : Spécifie un nom d'hôte valide (www.site.fr, par exemple).
2. android:mimetype : Vous permet de spécifier le type de données que votre composant est capable de prendre en charge.
3. android:path : Spécifie les valeurs du chemin valides pour l'URI.
4. android:port : Spécifie les ports valides pour l'hôte.
5. android:scheme : En utilisant cette catégorie, vous spécifiez que l'activité peut être exécutée au sein d'une autre activité.

Exploiter l'objet Intent de l'activité

Une fois le filtre de l'Intent défini et opérationnel, quelques lignes de code suffiront pour traiter l'Intent transmis. Si le composant n'est pas démarré, le système s'occupe de créer automatiquement une nouvelle instance du composant pour traiter l'intention. La classe Intent possède deux méthodes intéressantes pour récupérer les données envoyées sous forme d'URI :

1. La méthode getDataString() où nous pouvons consulter la chaîne de caractères au complet représentant l'URI.
2. La méthode getData() qui nous renvoie cette fois-ci un objet de type Uri. Cette classe est généralement plus intéressante à utiliser puisqu'elle même dispose de méthodes plus spécifique pour récupérer une partie de l'URI soumise. Elle ressemble à ce sujet à la classe URL du Java standard que nous connaissons bien.

Exemple de mise en oeuvre

Afin de valider cette notion de filtre, je vous propose d'en créer un sur une sous-activité. Nous allons reprendre le projet sur le calcul des angles et nous allons élaborer un filtre uniquement sur l'activité Radian. Cette sous-activité sera donc automatiquement affichée avec la valeur en degré soumise par une autre application qui servira au calcul et qui sera également automatiquement lancée.

Vous avez ci-dessous un exemple très rudimentaire d'une autre application qui veut utiliser cette sous-activité pour calculer la valeur en radian d'un angle exprimé en degré.

fr.btsiris.test.LancerAutreActivite.java

package fr.btsiris.test;

import android.app.Activity;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;

public class LancerAutreActivite extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Uri commande = Uri.parse("radian://?degre=60");
        Intent radian = new Intent(Intent.ACTION_EDIT, commande);
        startActivity(radian);
    }
}  

1. Lorsque je soumets ma nouvelle intention dans cette application au travers de l'activité LancerAutreActivite, je demande à lancer l'action d'édition à l'aide de la constante Intent.ACTION_EDIT.
2. J'aurais tout-à-fait pu demander plutôt une action de simple visualisation à l'aide de la constante Intent.ACTION_VIEW.
3. L'Uri radian://?degre=60 proposée pour soumettre les données est à la fois standard, mais également personnalisée. Effectivement le schéma est un schéma personnel et se nomme "radian". Pour le reste de l'Uri, nous retrouvons une écriture plus classique avec le point d'intérogation, un paramètre (degre) ainsi que sa valeur (60).
4. La particularité dans cette Uri, c'est que nous n'avons aucune action proposée avant le point d'interrogation. Il est tout-à-fait possible de proposer alors l'Uri suivante en ayant exactement la même réaction au niveau de la sous-activité : radian://calcul?degre=60.
5. A ce sujet, nous aurions pu prendre un autre exemple où c'est l'activité principale, le calcul des angles, qui prend en compte l'intention et qui redirige la requête vers la bonne sous-activité pour réaliser le traitement souhaité. Dans ce cas, il aurait été judicieux de proposer une Uri de la forme suivante pour effectuer un calcul qui permet de connaître une valeur en radian en partir d'un angle en degré : angle://radian?degre=60.
6. Cela vous montre toutes les possibilités. Android est vraiment très riche à ce sujet et ouvre plein de perspectives intéressantes.

Voici toutes les modifications à apporter, d'une part dans le manifeste de l'application concernant le calcul des angles et dans le code Java propre à la sous-activité Radian.

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.radian"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="Angles" android:icon="@drawable/icon">
        <activity android:name="Choix" android:label="Conversion des angles">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name="Radian" android:label="Recherche du radian">
            <intent-filter>
                <action android:name="android.intent.action.EDIT" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:scheme="radian" />
            </intent-filter>           
        </activity>
        <activity android:name="Degre"  />
    </application>
</manifest>

Remarquez bien la présence du filtre d'intention sur la sous-activité Radian. Ce filtre stipule que la sous-activité sera automatiquement démarrée qu'à partir d'action de type Edit avec une catégorie par défaut (vous devez proposer impérativement une catégorie) et un schéma personnalisé nommé radian.

fr.btsiris.radian.Radian.java

package fr.btsiris.radian;

import android.os.Bundle;
import android.view.View;
import java.text.*;

public class Radian extends Conversion {

   @Override
   public void onCreate(Bundle icicle) {
      setContentView(R.layout.radian);
      super.onCreate(icicle);  
      Uri requete = getIntent().getData();     
      if (requete!=null) {
         String valeur = requete.getQueryParameter("degre");
         degre.setText(valeur+" °");
         calcul(degre);
      }  
   }
 
   @Override  
   public void calcul(View vue) {
      try {
         Number valeur = formatDegre.parse(degre.getText().toString());
         radian.setText(formatRadian.format(valeur.doubleValue() * Math.PI / 360));
      } 
      catch (ParseException ex) { }   
   }
}

1. Cette activité peut être appelée normalement par son activité principale ou même par une autre activité d'une autre application. Il est donc nécessaire de savoir comment cette sous-activité a été générée.
2. Il faut donc connaître l'intention de l'activité, au moyen de la méthode getIntent() et aussi savoir si une Uri a été proposée, au moyen de la méthode getData(). Dans l'affirmative, c'est une autre application extérieure qui réclame son service.
3. Dans ce dernier cas de figure, il faut récupérer la valeur de l'angle en degré donné par l'Uri au moyen de la méthode getQueryParameter() et soumettre cette valeur pour le calcul, après avoir formaté correctement la zone de saisie des degrés.

Intent intention = new Intent(this, ServiceDemarrer.class);
startService(intention);

Je vous propose de reprendre un des projets sur le calcul des angles en faisant en sorte que lorsque nous sortons d'un type de calcul, par exemple les radians, nous récupérons automatiquement la valeur calculée pour la soumettre à l'autre type de calcul, par exemple les degrées :

Beaucoup de fichiers ne change pas. Ceux qui sont à prendre en compte pour respecter ce nouveau cahier des charges concerne l'activité principale Choix et les deux sous-activités permettant de réaliser les conversions, savoir Radian et Degre.

fr.btsiris.radian.Choix.java

package fr.btsiris.radian;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;

public class Choix extends Activity {
   private Intent radian, degre;
   private final int CALCUL_RADIAN =  1;
   private final int CALCUL_DEGRE = 2;
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);   
      radian = new Intent(this, Radian.class);
      degre = new Intent(this, Degre.class);        
    }
    
    public void calculRadian(View vue) {
       radian.putExtra("degre", degre.getIntExtra("degre", 0));
       startActivityForResult(radian, CALCUL_RADIAN);    
    }

    public void calculDegre(View vue) {
       degre.putExtra("radian", radian.getDoubleExtra("radian", 0.0)); 
       startActivityForResult(degre, CALCUL_DEGRE);           
    }

   @Override
   protected void onActivityResult(int requestCode, int resultCode, Intent data) {
      if (resultCode==RESULT_OK) 
         switch (requestCode) {
            case CALCUL_RADIAN : radian = data; break;
            case CALCUL_DEGRE  : degre = data;  break;
         }
   }
}    

1. Dans les méthodes calculRadian() et calculDegre(), nous envoyons dans l'intention concernée la valeur supplémentaire, au moyen de la méthode putExtra(), qui tient compte du calcul effectué dans l'autre type de calcul, au moyen des méthodes respectives getIntExtra() et getDoubleExtra().
2. Pour ces deux dernières méthodes, si aucun calcul antérieur n'a pas encore été proposé, une valeur par défaut est alors fournie.
3. Toujours à l'intérieur de ces deux méthodes de calcul, le lancement de la sous-activité requise est ensuite effectué avec une attente d'un résultat possible, au moyen de la méthode startActivityForResult().
4. La méthode onActivityResult() est alors redéfinie afin de permettre la récupération de la valeur de retour de la sous-activité qui se traduit tout simplement par la prise en compte de la nouvelle intention qui sera générée dans la sous-activité.

fr.btsiris.radian.Radian.java

package fr.btsiris.radian;

import android.os.Bundle;
import android.view.View;
import java.text.*;

public class Radian extends Conversion {
   
   @Override
   public void onCreate(Bundle icicle) {
      setContentView(R.layout.radian);
      super.onCreate(icicle);    
   }

   @Override
   protected void onResume() { 
      super.onResume();
      int valeur =getIntent().getIntExtra("degre", 0);
      degre.setText(formatDegre.format(valeur));
      radian.setText(formatRadian.format(valeur * Math.PI / 360)); 
   }
   
   @Override  
   public void calcul(View vue) {
      try {
         Number valeur = formatDegre.parse(degre.getText().toString());
         double resultat = valeur.doubleValue() * Math.PI / 360;
         radian.setText(formatRadian.format(resultat));       
         getIntent().putExtra("radian", resultat);
         setResult(RESULT_OK, getIntent());    
      } 
      catch (ParseException ex) { setResult(RESULT_CANCELED);  }   
   }
}

fr.btsiris.radian.Degre.java

package fr.btsiris.radian;

import android.os.Bundle;
import android.view.View;
import java.text.*;

public class Degre extends Conversion {

   @Override
   public void onCreate(Bundle icicle) {
      setContentView(R.layout.degre); 
      super.onCreate(icicle);     
   }

   @Override
   protected void onResume() {   
      super.onResume();
      double valeur = getIntent().getDoubleExtra("radian", 0.0);
      radian.setText(formatRadian.format(valeur));
      degre.setText(formatDegre.format(valeur * 360 / Math.PI));
   }

   @Override
   public void calcul(View vue) {
      try {
         Number valeur = formatRadian.parse(radian.getText().toString());
         int resultat = (int) (valeur.doubleValue() * 360 / Math.PI);
         degre.setText(formatDegre.format(resultat));
         getIntent().putExtra("degre", resultat);
         setResult(RESULT_OK, getIntent());        
      } 
      catch (ParseException ex) { setResult(RESULT_CANCELED); }         
   }
}  

1. A chaque fois que la sous-activité doit repassée en premier plan, la méthode onResume(), intégrée dans le cycle de vie d'une activité, est appelée.
2. Nous profitons de l'occasion pour récupérer la valeur supplémentaire proposée avec l'intention, au moyen des méthodes respectives getDoubleExtra() et getIntExtra().
3. A chaque fois qu'un calcul est demandé, nous mettons à jour l'intention avec la prise en compte du nouveau calcul au moyen de la méthode putExtra(), et nous soumettons cette intention comme résultat de la sous-activité au moyen de la méthode setResult().

Intent intention = getIntent();     
Uri données = intention.getData();     
if (données!=null) {
   startNextMatchingActivity(intention);
   ...
}  

Intent intention = new Intent(this, Récepteur.VIEW);
intention.putExtra("maclé", valeur);
sendBroadcast(intention);

public final class Récepteur extends BroadcastReceiver {
   private static final String VIEW = "btsiris.intent.action.VIEW";

   @Override
   public void onReceive(Context contexte, Intent intention) {
		...
   }
}  

<application ...>
   <receiver android:name="android.intent.action.VIEW">
      <intent-filter>
         <action android:name="btsiris.intent.action.VIEW" />
         <category android:name="android.intent.category.DEFAULT" />
      </intent-filter>
   </receiver>
</application>

BroadcastReceiver récepteur = new Récepteur();
IntentFilter filtre = new IntentFilter(Récepteur.CALL);
registerReceiver(récepteur, filtre);

gestionnaire.cancel(NOTIFICATION_ID);

notification.number = 2;

Uri sonnerie = Uri.parse(getResources().getResourceName(R.raw.bart_hi_caramba)); 
notification.sound = sonnerie;

notification.vibrate = new long[] {500, 1000, 500, 1000};

Attention, avant de pouvoir utiliser les vibrations dans votre application, vous devez demander l'autorisation. Ajoutez un <uses-permission> à votre application pour cela.

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

notification.ledARGB = Color.RED;
notification.ledOffMS = 500;
notification.ledOnMS = 500;
notification.defaults = Notification.DEFAULT_SOUND | Notification.DEFAULT_VIBRATE; 

A titre d'exemple, je vous propose de réaliser une application simple dont l'activité principale fournit deux boutons, un pour lancer une notification après un délai de 5 secondes, l'autre pour annuler cette notification si elle est active :

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.notifier"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="@string/app_name" android:icon="@drawable/icon">
        <activity android:name="Notifier" android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
    <uses-permission android:name="android.permission.VIBRATE" />
</manifest>

res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:padding="5px"
    >
   <Button
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content" 
       android:text="Notification dans 5 secondes"
       android:onClick="notifier"
    />
   <Button
       android:layout_width="fill_parent" 
       android:layout_height="wrap_content" 
       android:text="Supprimer la notification"
       android:onClick="supprimer"
    />    
</LinearLayout>

fr.btsiris.notifier.Notifier.java

package fr.btsiris.notifier;

import android.app.*;
import android.content.Intent;
import android.graphics.Color;
import android.os.Bundle;
import android.view.View;
import java.util.*;

public class Notifier extends Activity {
   private static final int NOTIFICATION_ID = 1234;
   private Timer temps = new Timer();
   private int compteur = 0;
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
   }
   
   public void notifier(View vue) {
      TimerTask tache = new TimerTask() {
         @Override
         public void run() {
            notifier();
         }
      };
      temps.schedule(tache, 5000);
   }
   
   public void supprimer(View vue) {
      NotificationManager mgr = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
      mgr.cancel(NOTIFICATION_ID);
      compteur = 0;
   }
   
   private void notifier() {
      NotificationManager mgr = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
      Notification notification = new Notification(R.drawable.icon, "Message !!!", System.currentTimeMillis());
      PendingIntent retour = PendingIntent.getActivity(this, 0, new Intent(this, Notifier.class), 0);   
      notification.setLatestEventInfo(this, "Titre de la notification", "Message de notification", retour);
      notification.number = ++compteur;
      alerte(notification);
      mgr.notify(NOTIFICATION_ID, notification);
   }
   
   private void alerte(Notification notification) {
      notification.defaults = Notification.DEFAULT_SOUND;
      notification.vibrate = new long[] {1000, 500, 200, 500};   
      notification.ledARGB = Color.GREEN;
      notification.ledOnMS = 500;
      notification.ledOffMS = 500;
      notification.flags |= Notification.FLAG_SHOW_LIGHTS;
   }
}