Intentions sous Android

Les Intents sont des messages asynchrones qui permettent aux composants d'une application de demander des fonctionnalités à d'autres composants Android. Les Intents vous permettent d'interagir avec vos propres composants ou des composants d'autres applications. Par exemple, une activité peut démarrer une autre activité pour prendre une photo.

Les Intents sont des objets de type android.content.Intent. Votre code peut les envoyer au système Android pour définir les composants que vous ciblez. Par exemple à travers la méthode startActivity(), vous pouvez définir que cet Intent doit être utilisé pour démarrer une activité.

Un Intent peut avoir des données dans un Bundle. Ces données peuvent être utilisées par le composant qui traite l'Intent.

Pour démarrer une activité(2), utilisez la méthode startActivity(Intent). Cette méthode est définie par l'objet Context hérité par l'activité.

Le code suivant montre comment démarrer une activité avec un Intent.

# Start the activity connect to the
# specified class

Intent i = new Intent(this, ActivityTwo.class);
startActivity(i);

Les activités qui sont démarrées par d'autres activités Android sont appelées sous-activités. Cette formulation permet de mieux décrire ce que l'on souhaite dire.

Vous pouvez aussi démarrer un service à l'aide d'un Intent. Utilisez la méthode startService(Intent) pour cela.

Les Intents sont aussi utilisés pour signaler au système Android qu'un événement particulier est survenu. Les Intents décrivent souvent l'action qui doit être effectuée et fournissent les données sur lesquelles cette action doit être faite. Par exemple, votre application peut démarrer, avec une intention, un des composants du navigateur pour une certaine URL. Cela est montré par l'exemple suivant.

String url = "http://www.vogella.com";
Intent i = new Intent(Intent.ACTION_VIEW);
i.setData(Uri.parse(url));
startActivity(i);

Mais comment fait le système Android pour identifier les composants qui doivent réagir avec quel Intent?

Pour cela, le concept d'Intent Filter est utilisé. Un Intent Filter précise les types d'intentions auxquelles cette activité, ce service ou ce récepteur de diffusion peuvent répondre. Il déclare donc les capacités d'un composant.

Les composants Android enregistrent leurs Intent Filter soit statiquement dans le fichier AndroidManifest.xml soit, dans le cas d'un récepteur de diffusion, dynamiquement dans le code. Un filtre d'intentions est défini par sa catégorie, son action et ses filtres de données. Il peut également contenir des métadonnées supplémentaires.

Si un Intent est envoyé au système Android, la plate-forme Android initie la détermination du récepteur en utilisant les données contenues dans l'objet Intent. En cela, elle détermine les composants qui sont enregistrés pour les données de l'Intent. Si plusieurs composants sont enregistrés pour le même Intent Filter, l'utilisateur peut alors décider quel composant doit être lancé.

Android supporte les Intents explicites et implicites.

Une application peut définir les composants cibles directement dans l'Intent (Intent explicite) ou demander au système Android de rechercher le composant adéquat en se basant sur les données de l'Intent (Intent implicite).

Les Intents explicites définissent explicitement le composant qui doit être appelé par le système Android en utilisant le nom de classe Java comme identifiant.

L'exemple suivant montre comment créer un Intent explicite et comment l'envoyer au système Android. Si cette classe représente une activité, le système Android la démarrera.

Intent i = new Intent(this, ActivityTwo.class);
i.putExtra("Value1", "This value one for ActivityTwo ");
i.putExtra("Value2", "This value two ActivityTwo");

Les Intents explicites sont généralement utilisés au sein d'une application, car les classes de cette application sont contrôlées par le développeur de l'application.

Les Intents implicites précisent l'action qui devrait être effectuée avec éventuellement les données pour cette action.

Par exemple, ce qui suit indique au système Android d'afficher une page Web. Tous les navigateurs Web installés doivent être enregistrés avec l'Intent correspondant en utilisant un Intent Filter.

Intent i = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.vogella.com"));
startActivity(i);

Si un Intent explicite est envoyé au système Android, il recherche tous les composants qui sont enregistrés avec l'action spécifique et le type de données approprié.

Si un seul composant est trouvé, Android démarre directement ce composant. Si plusieurs composants sont identifiés par le système Android, l'utilisateur devra indiquer quel composant utiliser à l'aide d'une boîte de dialogue de sélection.

Un Intent contient l'action et éventuellement des données complémentaires. Le composant qui crée l'Intent peut y ajouter des données avec la méthode surchargée putExtra(). Les données supplémentaires sont des paires clé/valeur, la clé est toujours une chaîne. En valeur, vous pouvez utiliser les types de données primitifs (int, float, ..) ainsi que les types String, Bundle, Parcelable et Serializable.

Le composant récepteur peut accéder à ces informations avec les méthodes getAction() et getData() sur l'objet Intent. Cet objet Intent peut être récupéré avec la méthode getIntent().

Le composant qui reçoit l'Intent peut utiliser la méthode getIntent().getExtras () pour obtenir les données supplémentaires.

Bundle extras = getIntent().getExtras();
if (extras == null) {
    return;
    }
// Get data via the key
String value1 = extras.getString(Intent.EXTRA_TEXT);
if (value1 != null) {
  // do something with the data
}

Beaucoup d'applications Android vous permettent de partager des données avec d'autres personnes, par exemple les applications Facebook, Google+, Gmail et Twitter. Vous pouvez aussi envoyer des données à l'un de ces composants. Le morceau de code suivant vous montre comment faire :

Intent intent = new Intent(Intent.ACTION_SEND);
intent.setType("text/plain");
intent.putExtra(android.content.Intent.EXTRA_TEXT, "News for you!");
startActivity(intent);

Une activité peut être fermée avec le bouton « back » sur le téléphone. Dans ce cas, la méthode finish() est appelée. Si l'activité a été lancée avec la méthode startActivity(Intent), l'appelant ne requiert pas de résultat ou de retour de l'activité qui est maintenant terminée.

Si vous lancez l'activité avec la méthode startActivityForResult(), vous attendez un retour de la sous-activité. Dès que la sous-activité se termine, la méthode onActivityResult() de la sous-activité est appelée et vous pouvez exécuter des actions suivant le résultat.

Dans la méthode startActivityForResult() vous pouvez spécifier le code de retour pour déterminer quelle activité vous avez démarrée. Ce code vous est retourné. L'activité démarrée peut aussi positionner un résultat que l'appelant peut utiliser afin de déterminer si l'activité a été abandonnée ou pas.

La sous-activité utilise la méthode finish() pour créer un Intent et mettre des données dedans. Cela mettra également une donnée de retour via l'appel de la fonction setResult().

L'exemple de code suivant montre comment déclencher un Intent avec la méthode startActivityForResult().

public void onClick(View view) {
  Intent i = new Intent(this, ActivityTwo.class);
  i.putExtra("Value1", "This value one for ActivityTwo ");
  i.putExtra("Value2", "This value two ActivityTwo");
  // Set the request code to any code you like, you can identify the
  // callback via this code
  startActivityForResult(i, REQUEST_CODE);
}

Si vous utilisez la méthode startActivityForResult() alors l'activité démarrée est appelée sous-activité.

Quand la sous-activité se termine, elle retourne des données à l'appelant avec une intention. Ceci est fait dans la méthode finish().

@Override
public void finish() {
  // Prepare data intent 
  Intent data = new Intent();
  data.putExtra("returnKey1", "Swinging on a star. ");
  data.putExtra("returnKey2", "You could be better then you are. ");
  // Activity finished ok, return the data
  setResult(RESULT_OK, data);
  super.finish();
}

Dès que la sous-activité est terminée, la méthode onActivityResult() de l'activité appelante est exécutée.

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  if (resultCode == RESULT_OK && requestCode == REQUEST_CODE) {
    if (data.hasExtra("returnKey1")) {
      Toast.makeText(this, data.getExtras().getString("returnKey1"),
        Toast.LENGTH_SHORT).show();
    }
  }
}

Vous pouvez enregistrer vos propres composants avec des Intent Filter. Si un composant n'en définit pas, il ne peut être appelé par un Intent explicite. Ce chapitre donne quelques exemples pour enregistrer un composant avec une intention. La clé de cette inscription, c'est que votre composant s'enregistre pour l'action correcte et précise le type mime et les métadonnées correctes.

Le code suivant enregistre une activité avec un Intent qui est déclenchée lorsque quelqu'un veut afficher une page Web.

<activity android:name=".BrowserActivitiy" 
          android:label="@string/app_name">
  <intent-filter>
     <action android:name="android.intent.action.VIEW" />
     <category android:name="android.intent.category.DEFAULT" />
     <data android:scheme="http"/> 
  </intent-filter>
</activity>

L'exemple suivant enregistre une activité pour l'intention ACTION_SEND. Il se déclare lui-même comme acceptant le type mime text/plain.

<activity
  android:name=".ActivityTest"
    android:label="@string/app_name" >
    <intent-filter>
      <action android:name="android.intent.action.SEND" />
      
      <category android:name="android.intent.category.DEFAULT" />

      <data android:mimeType="text/plain" />
    
    </intent-filter>

</activity>

Si un composant ne définit pas d'Intent Filter, il peut être appelé uniquement par un Intent explicite.

L'exercice suivant montre comment utiliser un Intent explicite pour démarrer une sous-activité et comment lui envoyer des données.

C'est la première partie d'un exercice qui se poursuit au paragraphe 9.1. Une solution peut être vue dans le chapitre 10.

Créez un nouveau projet Android nommé com.vogella.android.intent.explicit avec une activité nommée MainActivity.

Modifier la mise en page(3) de la première activité avec le code suivant :

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".MainActivity" >

    <EditText
        android:id="@+id/inputforintent"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:minHeight="60dip"
        android:text="First Activity"
        android:textSize="20sp" >
    </EditText>

    <Button
        android:id="@+id/startintent"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/inputforintent"
        android:layout_below="@+id/inputforintent"
        android:onClick="onClick"
        android:text="Calling an intent" />

</RelativeLayout>

Créez une nouvelle mise en page appelée activity_result.xml qui sera utilisée dans notre seconde activité.

Pour créer un nouveau fichier de mise en page, sélectionnez votre projet, faites un clic droit et sélectionnez « File ? New ? Other… ? Android ? Android XML File » et sélectionnez l'option Layout.

Entrez activity_result.xml comme nom de fichier et appuyez sur le bouton Finish. Modifiez votre mise en page pour qu'elle ressemble à ce qui suit :

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <TextView
        android:id="@+id/displayintentextra"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Input"
        android:textAppearance="?android:attr/textAppearanceLarge" />

    <EditText
        android:id="@+id/returnValue"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" >

        <requestFocus />
    </EditText>

</LinearLayout>

Ajoutez une nouvelle activité au fichier AndroidManifest.xml.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.vogella.android.first"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk android:minSdkVersion="14" />

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name" >
        <activity
            android:label="@string/app_name"
            android:name=".MainActivity" >
            <intent-filter >
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity
            android:label="Result Activity"
            android:name=".ResultActivity" >
        </activity>
    </application>

</manifest>

Créez la classe ResultActivity correspondante basée sur le code suivant :

package com.vogella.android.intent.explicit;

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

public class ResultActivity extends Activity {

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

La nouvelle activité sera démarrée par la première activité, c'est pourquoi elle est appelée sous-activité.

Démarrez la sous-activité avec un bouton à partir de la classe MainActivity. Le code suivant vous montre comment faire :

package com.vogella.android.intent.explicit;

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

public class MainActivity extends Activity {

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

  public void onClick(View view) {
    EditText text = (EditText) findViewById(R.id.inputforintent);
    // used later
    String value = text.getText().toString();
    // TODO 1 create new explicit Intent
    // based on "ResultActivity.class"

    // TODO 2 start second Activity with
    // startActivity(intent);
  }

}

Modifiez les TODO dans le code source de sorte que l'activité de ResultActivity soit lancée à partir de la méthode onClick().

Une fois que cette partie de l'exercice est terminée, démarrez votre application et vérifiez que vous pouvez lancer la seconde activité.

La classe MainActivity doit passer la valeur du champ EditText à la sous-activité. Pour cela, utilisez la méthode putExtra(« yourKey », string) sur l'objet Intent.

Dans votre sous-activité ResultActivity, récupérez le Bundle avec les données de l'intention en utilisant la méthode getIntent().getExtras().

Lisez la valeur extra avec la méthode getExtra(« yourKey ») sur le Bundle récupéré avec la méthode getExtras().

Cette valeur doit être stockée dans le TextView dont l'identifiant est displayintentextra.

Ceci est la deuxième partie de l'exercice commencé dans le paragraphe 8.1. Un exemple de solution pour l'activité peut être vu dans le chapitre 10.

Continuez à utiliser le projet com.vogella.android.intent.explicit.

Dans l'exercice suivant, vous allez transférer des données depuis votre sous-activité vers l'activité principale quand l'utilisateur appuiera sur le bouton Back.

Ajoutez le code suivant à la méthode finish() de la classe ResultActivity.

@Override
public void finish() {
    
  // TODO 1 create new Intent 
  // Intent intent = new Intent();
    
  // TODO 2 read the data of the EditText field
  // with the id returnValue
  
  // TODO 3 put the text from EditText
  // as String extra into the intent
  // use editText.getText().toString();
    
  // TODO 4 use setResult(RESULT_OK, intent); 
  // to return the Intent to the application
  
  super.finish();
}

Modifiez les TODO.

Utilisez dans MainActivity la méthode startActivityForResult() pour démarrer la sous-activité. Cela vous permet d'utiliser la méthode onActivityResult() pour recevoir des données en retour de la sous-activité. Extrayez les données reçues dans le Bundle.

Affichez un Toast avec les données extraites pour valider que vous les avez correctement reçues. Le code suivant contient le début de la solution pour cela :

package com.vogella.android.intent.explicit;

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

public class MainActivity extends Activity {
  
  // constant to determine which sub-activity returns
  private static final int REQUEST_CODE = 10;

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

  public void onClick(View view) {
    EditText text = (EditText) findViewById(R.id.inputforintent);
    String string = text.getText().toString();
    Intent i = new Intent(this, ResultActivity.class);
    i.putExtra("yourkey", string);
    // TODO 2.. now use 
    // startActivityForResult(i, REQUEST_CODE);
  }

  // TODO 3 Implement this method
  // assumes that "returnkey" is used as key to return the result
  @Override
  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (resultCode == RESULT_OK && requestCode == REQUEST_CODE) {
      if (data.hasExtra("returnkey")) {
        String result = data.getExtras().getString("returnkey");
        if (result != null && result.length() > 0) {
          Toast.makeText(this, result, Toast.LENGTH_SHORT).show();
        }
      }
    }
  }
}

Après avoir fini l'exercice du paragraphe 9.1, le code de votre activité devrait ressemble à cela :

• Codes source d'exemple

• Android Homepage
• Android Issues / Bugs
• Android Google Groups