Un intent vous permet de démarrer une activité dans une autre application en décrivant une action que vous souhaitez effectuer, comme "afficher une carte" ou "prendre une photo", dans un objet Intent
. Ce type d'intent est appelé intent implicite, car il ne spécifie pas le composant d'application à démarrer, mais spécifie plutôt une action et fournit des données pour effectuer l'action.
Lorsque vous appelez startActivity()
ou startActivityForResult()
et que vous lui transmettez un intent implicite, le système résout l'intent en une application capable de le gérer et démarre son Activity
correspondant. Si plusieurs applications peuvent gérer l'intent, le système présente à l'utilisateur une boîte de dialogue lui permettant de choisir l'application à utiliser.
Cette page décrit plusieurs intents implicites que vous pouvez utiliser pour effectuer des actions courantes, organisés par type d'application qui gère l'intent. Chaque section montre également comment créer un filtre d'intent pour promouvoir la capacité de votre application à effectuer l'action.
Attention : S'il n'y a aucune application sur l'appareil qui puisse recevoir une intention implicite, une application plante lorsqu'elle appelle startActivity()
. Pour vérifier d'abord qu'une application existe pour recevoir l'intent, appelez resolveActivity()
sur votre objet Intent
. Si le résultat n'est pas nul, cela signifie qu'au moins une application peut gérer l'intention et que vous pouvez appeler startActivity()
sans risque. Si le résultat est nul, n'utilisez pas l'intention et, si possible, désactivez la fonctionnalité qui l'appelle.
Si vous ne savez pas comment créer des intents ni des filtres d'intent, commencez par lire Intents et filtres d'intent.
Pour savoir comment déclencher les intents listés sur cette page depuis votre hôte de développement, consultez la section Valider les intents avec Android Debug Bridge.
Actions Google Voice
Les actions Google Voice déclenchent certaines des intentions listées sur cette page en réponse à des commandes vocales. Pour en savoir plus, consultez Premiers pas avec les actions vocales système.
Réveil
Vous trouverez ci-dessous les actions courantes pour les applications d'horloge, ainsi que les informations dont vous avez besoin pour créer un filtre d'intent afin de promouvoir la capacité de votre application à effectuer chaque action.
Créer une alarme
Pour créer une alarme, utilisez l'action ACTION_SET_ALARM
et spécifiez les détails de l'alarme, tels que l'heure et le message, à l'aide des extras suivants.
Remarque : Seuls l'heure, les minutes et les extras de message sont disponibles dans Android 2.3 (niveau d'API 9) et versions antérieures. Les autres options sont disponibles dans les versions supérieures de la plate-forme.
- Action
ACTION_SET_ALARM
- URI de données
- Aucun
- Type MIME
- Aucun
- Extras
-
EXTRA_HOUR
- Heure de l'alarme.
EXTRA_MINUTES
- : minutes de l'alarme.
EXTRA_MESSAGE
- Message personnalisé pour identifier l'alarme.
EXTRA_DAYS
- :
ArrayList
incluant chaque jour de la semaine où cette alarme se répète. Chaque jour doit être déclaré avec un nombre entier de la classeCalendar
, tel queMONDAY
.Pour une alarme ponctuelle, ne spécifiez pas cet extra.
EXTRA_RINGTONE
- URI
content:
spécifiant une sonnerie à utiliser avec l'alarme, ouVALUE_RINGTONE_SILENT
pour aucune sonnerie.Pour utiliser la sonnerie par défaut, ne spécifiez pas cet extra.
EXTRA_VIBRATE
- Valeur booléenne indiquant si la montre doit vibrer pour cette alarme.
EXTRA_SKIP_UI
- Valeur booléenne indiquant si l'application qui répond doit ignorer son interface utilisateur lors du réglage de l'alarme. Si la valeur est "true", l'application doit ignorer toute UI de confirmation et définir l'alarme spécifiée.
Exemple d'intention :
Kotlin
fun createAlarm(message: String, hour: Int, minutes: Int) { val intent = Intent(AlarmClock.ACTION_SET_ALARM).apply { putExtra(AlarmClock.EXTRA_MESSAGE, message) putExtra(AlarmClock.EXTRA_HOUR, hour) putExtra(AlarmClock.EXTRA_MINUTES, minutes) } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void createAlarm(String message, int hour, int minutes) { Intent intent = new Intent(AlarmClock.ACTION_SET_ALARM) .putExtra(AlarmClock.EXTRA_MESSAGE, message) .putExtra(AlarmClock.EXTRA_HOUR, hour) .putExtra(AlarmClock.EXTRA_MINUTES, minutes); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Pour appeler l'intent ACTION_SET_ALARM
, votre application doit disposer de l'autorisation SET_ALARM
:
<uses-permission android:name="com.android.alarm.permission.SET_ALARM" />
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="android.intent.action.SET_ALARM" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </activity>
Créer un minuteur
Pour créer un minuteur, utilisez l'action ACTION_SET_TIMER
et spécifiez les détails du minuteur, comme la durée, à l'aide des extras suivants.
Remarque : Cet intent est disponible dans Android 4.4 (niveau d'API 19) et versions ultérieures.
- Action
ACTION_SET_TIMER
- URI de données
- Aucun
- Type MIME
- Aucun
- Extras
-
EXTRA_LENGTH
- Durée du minuteur en secondes.
EXTRA_MESSAGE
- Message personnalisé pour identifier le minuteur.
EXTRA_SKIP_UI
- Valeur booléenne indiquant si l'application répondante doit ignorer son interface utilisateur lors de la définition du minuteur. Si la valeur est "true", l'application doit ignorer toute UI de confirmation et démarrer le minuteur spécifié.
Exemple d'intention :
Kotlin
fun startTimer(message: String, seconds: Int) { val intent = Intent(AlarmClock.ACTION_SET_TIMER).apply { putExtra(AlarmClock.EXTRA_MESSAGE, message) putExtra(AlarmClock.EXTRA_LENGTH, seconds) putExtra(AlarmClock.EXTRA_SKIP_UI, true) } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void startTimer(String message, int seconds) { Intent intent = new Intent(AlarmClock.ACTION_SET_TIMER) .putExtra(AlarmClock.EXTRA_MESSAGE, message) .putExtra(AlarmClock.EXTRA_LENGTH, seconds) .putExtra(AlarmClock.EXTRA_SKIP_UI, true); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Pour appeler l'intent ACTION_SET_TIMER
, votre application doit disposer de l'autorisation SET_ALARM
:
<uses-permission android:name="com.android.alarm.permission.SET_ALARM" />
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="android.intent.action.SET_TIMER" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </activity>
Aff. toutes alarmes
Pour afficher la liste des alarmes, utilisez l'action ACTION_SHOW_ALARMS
.
Bien que peu d'applications invoquent cette intention, car elle est principalement utilisée par les applications système, toute application qui se comporte comme un réveil peut implémenter ce filtre d'intention et répondre en affichant la liste des alarmes actuelles.
Remarque : Cet intent est disponible dans Android 4.4 (niveau d'API 19) et versions ultérieures.
- Action
ACTION_SHOW_ALARMS
- URI de données
- Aucun
- Type MIME
- Aucun
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="android.intent.action.SHOW_ALARMS" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </activity>
Agenda
L'ajout d'un événement est une action courante pour les applications d'agenda. Créez un filtre d'intent pour annoncer la capacité de votre application à effectuer cette action à l'aide des informations de la section suivante.
Ajouter un événement d'agenda
Pour ajouter un événement à l'agenda de l'utilisateur, utilisez l'action ACTION_INSERT
et spécifiez l'URI de données à l'aide de Events.CONTENT_URI
.
Vous pouvez ensuite spécifier différents détails d'événement à l'aide des extras suivants.
- Action
ACTION_INSERT
- URI de données
Events.CONTENT_URI
- Type MIME
"vnd.android.cursor.dir/event"
- Extras
-
EXTRA_EVENT_ALL_DAY
- Valeur booléenne indiquant s'il s'agit d'un événement d'une journée complète.
EXTRA_EVENT_BEGIN_TIME
- Heure de début de l'événement (en millisecondes depuis l'epoch).
EXTRA_EVENT_END_TIME
- Heure de fin de l'événement (en millisecondes depuis l'epoch).
TITLE
- Titre de l'événement.
DESCRIPTION
- Description de l'événement.
EVENT_LOCATION
- Lieu de l'événement.
EXTRA_EMAIL
- Liste d'adresses e-mail séparées par une virgule, qui spécifient les invités.
Vous pouvez spécifier de nombreux autres détails d'événement à l'aide des constantes définies dans la classe
CalendarContract.EventsColumns
.
Exemple d'intention :
Kotlin
fun addEvent(title: String, location: String, begin: Long, end: Long) { val intent = Intent(Intent.ACTION_INSERT).apply { data = Events.CONTENT_URI putExtra(Events.TITLE, title) putExtra(Events.EVENT_LOCATION, location) putExtra(CalendarContract.EXTRA_EVENT_BEGIN_TIME, begin) putExtra(CalendarContract.EXTRA_EVENT_END_TIME, end) } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void addEvent(String title, String location, long begin, long end) { Intent intent = new Intent(Intent.ACTION_INSERT) .setData(Events.CONTENT_URI) .putExtra(Events.TITLE, title) .putExtra(Events.EVENT_LOCATION, location) .putExtra(CalendarContract.EXTRA_EVENT_BEGIN_TIME, begin) .putExtra(CalendarContract.EXTRA_EVENT_END_TIME, end); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="android.intent.action.INSERT" /> <data android:mimeType="vnd.android.cursor.dir/event" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </activity>
Appareil photo
Vous trouverez ci-dessous les actions courantes pour les applications d'appareil photo, ainsi que les informations dont vous avez besoin pour créer un filtre d'intent afin de promouvoir la capacité de votre application à effectuer chaque action.
Prendre une photo ou enregistrer une vidéo et la renvoyer
Pour ouvrir une application d'appareil photo et recevoir la photo ou la vidéo obtenue, utilisez l'action ACTION_IMAGE_CAPTURE
ou ACTION_VIDEO_CAPTURE
. Spécifiez également l'URI où vous souhaitez que l'appareil photo enregistre la photo ou la vidéo, dans l'extra EXTRA_OUTPUT
.
- Action
ACTION_IMAGE_CAPTURE
ou
ACTION_VIDEO_CAPTURE
- Schéma d'URI de données
- Aucun
- Type MIME
- Aucun
- Extras
-
EXTRA_OUTPUT
- : emplacement de l'URI où l'application Appareil photo enregistre le fichier photo ou vidéo (en tant qu'objet
Uri
).
Lorsque l'application de l'appareil photo renvoie correctement le focus sur votre activité (en d'autres termes, votre application reçoit le rappel onActivityResult()
), vous pouvez accéder à la photo ou à la vidéo à l'URI que vous avez spécifié avec la valeur EXTRA_OUTPUT
.
Remarque : Lorsque vous utilisez ACTION_IMAGE_CAPTURE
pour prendre une photo, l'appareil photo peut également renvoyer une copie réduite, ou miniature, de la photo dans le résultat Intent
, enregistrée en tant que Bitmap
dans un champ supplémentaire nommé "data"
.
Exemple d'intention :
Kotlin
const val REQUEST_IMAGE_CAPTURE = 1 val locationForPhotos: Uri = ... fun capturePhoto(targetFilename: String) { val intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE).apply { putExtra(MediaStore.EXTRA_OUTPUT, Uri.withAppendedPath(locationForPhotos, targetFilename)) } if (intent.resolveActivity(packageManager) != null) { startActivityForResult(intent, REQUEST_IMAGE_CAPTURE) } } override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) { if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == Activity.RESULT_OK) { val thumbnail: Bitmap = data.getParcelableExtra("data") // Do other work with full size photo saved in locationForPhotos. ... } }
Java
static final int REQUEST_IMAGE_CAPTURE = 1; static final Uri locationForPhotos; public void capturePhoto(String targetFilename) { Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.withAppendedPath(locationForPhotos, targetFilename)); if (intent.resolveActivity(getPackageManager()) != null) { startActivityForResult(intent, REQUEST_IMAGE_CAPTURE); } } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == RESULT_OK) { Bitmap thumbnail = data.getParcelableExtra("data"); // Do other work with full size photo saved in locationForPhotos. ... } }
Pour ce faire, lorsque vous travaillez sur Android 12 (niveau d'API 31) ou version ultérieure, consultez l'exemple d'intent suivant.
Exemple d'intention :
Kotlin
val REQUEST_IMAGE_CAPTURE = 1 private fun dispatchTakePictureIntent() { val takePictureIntent = Intent(MediaStore.ACTION_IMAGE_CAPTURE) try { startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE) } catch (e: ActivityNotFoundException) { // Display error state to the user. } }
Java
static final int REQUEST_IMAGE_CAPTURE = 1; private void dispatchTakePictureIntent() { Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); try { startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE); } catch (ActivityNotFoundException e) { // Display error state to the user. } } </section></div>
Pour en savoir plus sur l'utilisation de cette intention pour prendre une photo, y compris sur la façon de créer un Uri
approprié pour l'emplacement de sortie, consultez Prendre des photos ou Prendre des vidéos.
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="android.media.action.IMAGE_CAPTURE" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </activity>
Lors du traitement de cet intent, votre activité doit rechercher l'élément supplémentaire EXTRA_OUTPUT
dans l'Intent
entrant, puis enregistrer l'image ou la vidéo capturée à l'emplacement spécifié par cet élément supplémentaire et appeler setResult()
avec un Intent
qui inclut une miniature compressée dans un élément supplémentaire nommé "data"
.
Démarrer une application Appareil photo en mode image fixe
Pour ouvrir une application d'appareil photo en mode image fixe, utilisez l'action INTENT_ACTION_STILL_IMAGE_CAMERA
.
- Action
INTENT_ACTION_STILL_IMAGE_CAMERA
- Schéma d'URI de données
- Aucun
- Type MIME
- Aucun
- Extras
- Aucun
Exemple d'intention :
Kotlin
private fun dispatchTakePictureIntent() { val takePictureIntent = Intent(MediaStore.ACTION_IMAGE_CAPTURE) try { startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE) } catch (e: ActivityNotFoundException) { // Display error state to the user. } }
Java
public void capturePhoto(String targetFilename) { Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.withAppendedPath(locationForPhotos, targetFilename)); if (intent.resolveActivity(getPackageManager()) != null) { startActivityForResult(intent, REQUEST_IMAGE_CAPTURE); } }
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="android.media.action.STILL_IMAGE_CAMERA" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </activity>
Démarrer une application Appareil photo en mode vidéo
Pour ouvrir une application d'appareil photo en mode vidéo, utilisez l'action INTENT_ACTION_VIDEO_CAMERA
.
- Action
INTENT_ACTION_VIDEO_CAMERA
- Schéma d'URI de données
- Aucun
- Type MIME
- Aucun
- Extras
- Aucun
Exemple d'intention :
Kotlin
fun capturePhoto() { val intent = Intent(MediaStore.INTENT_ACTION_VIDEO_CAMERA) if (intent.resolveActivity(packageManager) != null) { startActivityForResult(intent, REQUEST_IMAGE_CAPTURE) } }
Java
public void capturePhoto() { Intent intent = new Intent(MediaStore.INTENT_ACTION_VIDEO_CAMERA); if (intent.resolveActivity(getPackageManager()) != null) { startActivityForResult(intent, REQUEST_IMAGE_CAPTURE); } }
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="android.media.action.VIDEO_CAMERA" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </activity>
Application Contacts/Personnes
Vous trouverez ci-dessous les actions courantes pour les applications de gestion des contacts, y compris les informations dont vous avez besoin pour créer un filtre d'intent afin de promouvoir la capacité de votre application à effectuer chaque action.
Sélectionner un contact
Pour que l'utilisateur sélectionne un contact et accorde à votre application l'accès à toutes les informations de contact, utilisez l'action ACTION_PICK
et spécifiez le type MIME sur Contacts.CONTENT_TYPE
.
Le résultat Intent
fourni à votre rappel onActivityResult()
contient l'URI content:
pointant vers le contact sélectionné. La réponse accorde à votre application des autorisations temporaires pour lire ce contact à l'aide de l'API Contacts Provider, même si votre application n'inclut pas l'autorisation READ_CONTACTS
.
Remarque : Si vous n'avez besoin d'accéder qu'à une information de contact spécifique, comme un numéro de téléphone ou une adresse e-mail, consultez la section suivante pour savoir comment sélectionner des données de contact spécifiques.
- Action
ACTION_PICK
- Schéma d'URI de données
- Aucun
- Type MIME
Contacts.CONTENT_TYPE
Exemple d'intention :
Kotlin
const val REQUEST_SELECT_CONTACT = 1 fun selectContact() { val intent = Intent(Intent.ACTION_PICK).apply { type = ContactsContract.Contacts.CONTENT_TYPE } if (intent.resolveActivity(packageManager) != null) { startActivityForResult(intent, REQUEST_SELECT_CONTACT) } } override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) { if (requestCode == REQUEST_SELECT_CONTACT && resultCode == RESULT_OK) { val contactUri: Uri = data.data // Do something with the selected contact at contactUri. //... } }
Java
static final int REQUEST_SELECT_CONTACT = 1; public void selectContact() { Intent intent = new Intent(Intent.ACTION_PICK); intent.setType(ContactsContract.Contacts.CONTENT_TYPE); if (intent.resolveActivity(getPackageManager()) != null) { startActivityForResult(intent, REQUEST_SELECT_CONTACT); } } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == REQUEST_SELECT_CONTACT && resultCode == RESULT_OK) { Uri contactUri = data.getData(); // Do something with the selected contact at contactUri. ... } }
Pour savoir comment récupérer les coordonnées d'un contact une fois que vous avez son URI, consultez Récupérer les coordonnées d'un contact.
Lorsque vous récupérez l'URI du contact à l'aide de cette intention, vous n'avez généralement pas besoin de l'autorisation READ_CONTACTS
pour lire les informations de base de ce contact, telles que le nom à afficher et si le contact est favori. Toutefois, si vous essayez de lire des données plus spécifiques sur un contact donné, comme son numéro de téléphone ou son adresse e-mail, vous avez besoin de l'autorisation READ_CONTACTS
.
Sélectionner des données de contact spécifiques
Pour que l'utilisateur sélectionne une information spécifique d'un contact, comme un numéro de téléphone, une adresse e-mail ou un autre type de données, utilisez l'action ACTION_PICK
et spécifiez le type MIME sur l'un des types de contenu suivants, comme CommonDataKinds.Phone.CONTENT_TYPE
pour obtenir le numéro de téléphone du contact.
Remarque : Dans de nombreux cas, votre application doit disposer de l'autorisation READ_CONTACTS
pour afficher des informations spécifiques sur un contact particulier.
Si vous n'avez besoin de récupérer qu'un seul type de données à partir d'un contact, cette technique avec un CONTENT_TYPE
des classes ContactsContract.CommonDataKinds
est plus efficace que l'utilisation de Contacts.CONTENT_TYPE
, comme indiqué dans la section précédente. Le résultat vous donne un accès direct aux données souhaitées, sans que vous ayez à effectuer une requête plus complexe auprès du fournisseur de contacts.
Le résultat Intent
transmis à votre rappel onActivityResult()
contient l'URI content:
pointant vers les données de contact sélectionnées. La réponse accorde à votre application des autorisations temporaires pour lire ces données de contact, même si votre application n'inclut pas l'autorisation READ_CONTACTS
.
- Action
ACTION_PICK
- Schéma d'URI de données
- Aucun
- Type MIME
-
CommonDataKinds.Phone.CONTENT_TYPE
- Sélectionnez un contact disposant d'un numéro de téléphone.
CommonDataKinds.Email.CONTENT_TYPE
- Sélectionnez des contacts ayant une adresse e-mail.
CommonDataKinds.StructuredPostal.CONTENT_TYPE
- Sélectionnez des contacts ayant une adresse postale.
ou l'une des nombreuses autres valeurs
CONTENT_TYPE
sousContactsContract
.
Exemple d'intention :
Kotlin
const val REQUEST_SELECT_PHONE_NUMBER = 1 fun selectContact() { // Start an activity for the user to pick a phone number from contacts. val intent = Intent(Intent.ACTION_PICK).apply { type = CommonDataKinds.Phone.CONTENT_TYPE } if (intent.resolveActivity(packageManager) != null) { startActivityForResult(intent, REQUEST_SELECT_PHONE_NUMBER) } } override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) { if (requestCode == REQUEST_SELECT_PHONE_NUMBER && resultCode == Activity.RESULT_OK) { // Get the URI and query the content provider for the phone number. val contactUri: Uri = data.data val projection: Array<String> = arrayOf(CommonDataKinds.Phone.NUMBER) contentResolver.query(contactUri, projection, null, null, null).use { cursor -> // If the cursor returned is valid, get the phone number. if (cursor.moveToFirst()) { val numberIndex = cursor.getColumnIndex(CommonDataKinds.Phone.NUMBER) val number = cursor.getString(numberIndex) // Do something with the phone number. ... } } } }
Java
static final int REQUEST_SELECT_PHONE_NUMBER = 1; public void selectContact() { // Start an activity for the user to pick a phone number from contacts. Intent intent = new Intent(Intent.ACTION_PICK); intent.setType(CommonDataKinds.Phone.CONTENT_TYPE); if (intent.resolveActivity(getPackageManager()) != null) { startActivityForResult(intent, REQUEST_SELECT_PHONE_NUMBER); } } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == REQUEST_SELECT_PHONE_NUMBER && resultCode == RESULT_OK) { // Get the URI and query the content provider for the phone number. Uri contactUri = data.getData(); String[] projection = new String[]{CommonDataKinds.Phone.NUMBER}; Cursor cursor = getContentResolver().query(contactUri, projection, null, null, null); // If the cursor returned is valid, get the phone number. if (cursor != null && cursor.moveToFirst()) { int numberIndex = cursor.getColumnIndex(CommonDataKinds.Phone.NUMBER); String number = cursor.getString(numberIndex); // Do something with the phone number. //... } } }
Afficher un contact
Pour afficher les détails d'un contact connu, utilisez l'action ACTION_VIEW
et spécifiez le contact avec un URI content:
comme données d'intent.
Il existe deux méthodes principales pour récupérer l'URI du contact :
- Utilisez l'URI de contact renvoyé par l'action
ACTION_PICK
indiquée dans la section précédente. Cette approche ne nécessite aucune autorisation d'application. - Accédez directement à la liste de tous les contacts, comme décrit dans Récupérer une liste de contacts. Cette approche nécessite l'autorisation
READ_CONTACTS
.
- Action
ACTION_VIEW
- Schéma d'URI de données
content:<URI>
- Type MIME
- Aucun. Le type est déduit de l'URI du contact.
Exemple d'intention :
Kotlin
fun viewContact(contactUri: Uri) { val intent = Intent(Intent.ACTION_VIEW, contactUri) if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void viewContact(Uri contactUri) { Intent intent = new Intent(Intent.ACTION_VIEW, contactUri); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Modifier un contact existant
Pour modifier un contact connu, utilisez l'action ACTION_EDIT
, spécifiez le contact avec un URI content:
comme données d'intent, et incluez toutes les informations de contact connues dans les extras spécifiés par les constantes de ContactsContract.Intents.Insert
.
Il existe deux méthodes principales pour récupérer l'URI du contact :
- Utilisez l'URI de contact renvoyé par l'action
ACTION_PICK
indiquée dans la section précédente. Cette approche ne nécessite aucune autorisation d'application. - Accédez directement à la liste de tous les contacts, comme décrit dans Récupérer une liste de contacts. Cette approche nécessite l'autorisation
READ_CONTACTS
.
- Action
ACTION_EDIT
- Schéma d'URI de données
content:<URI>
- Type MIME
- Le type est déduit de l'URI du contact.
- Extras
- Un ou plusieurs extras définis dans
ContactsContract.Intents.Insert
pour que vous puissiez renseigner les champs des coordonnées.
Exemple d'intention :
Kotlin
fun editContact(contactUri: Uri, email: String) { val intent = Intent(Intent.ACTION_EDIT).apply { data = contactUri putExtra(ContactsContract.Intents.Insert.EMAIL, email) } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void editContact(Uri contactUri, String email) { Intent intent = new Intent(Intent.ACTION_EDIT); intent.setData(contactUri); intent.putExtra(Intents.Insert.EMAIL, email); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Pour savoir comment modifier un contact, consultez Modifier des contacts à l'aide d'intents.
Insérer un contact
Pour insérer un contact, utilisez l'action ACTION_INSERT
, spécifiez Contacts.CONTENT_TYPE
comme type MIME et incluez toutes les informations de contact connues dans les extras spécifiés par les constantes de ContactsContract.Intents.Insert
.
- Action
ACTION_INSERT
- Schéma d'URI de données
- Aucun
- Type MIME
Contacts.CONTENT_TYPE
- Extras
- Un ou plusieurs extras définis dans
ContactsContract.Intents.Insert
.
Exemple d'intention :
Kotlin
fun insertContact(name: String, email: String) { val intent = Intent(Intent.ACTION_INSERT).apply { type = ContactsContract.Contacts.CONTENT_TYPE putExtra(ContactsContract.Intents.Insert.NAME, name) putExtra(ContactsContract.Intents.Insert.EMAIL, email) } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void insertContact(String name, String email) { Intent intent = new Intent(Intent.ACTION_INSERT); intent.setType(Contacts.CONTENT_TYPE); intent.putExtra(Intents.Insert.NAME, name); intent.putExtra(Intents.Insert.EMAIL, email); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Pour savoir comment insérer un contact, consultez Modifier des contacts à l'aide d'intents.
Adresse e-mail
La rédaction d'un e-mail avec des pièces jointes facultatives est une action courante pour les applications de messagerie. Créez un filtre d'intent pour annoncer la capacité de votre application à effectuer cette action à l'aide des informations de la section suivante.
Rédiger un e-mail avec des pièces jointes facultatives
Pour rédiger un e-mail, utilisez l'une des actions suivantes selon que vous incluez ou non des pièces jointes, et ajoutez les détails de l'e-mail, tels que le destinataire et l'objet, à l'aide des touches supplémentaires listées.
- Action
ACTION_SENDTO
(pour aucune pièce jointe) ou
ACTION_SEND
(pour une pièce jointe) ou
ACTION_SEND_MULTIPLE
(pour plusieurs pièces jointes)- Schéma d'URI de données
- Aucun
- Type MIME
-
"text/plain"
"*/*"
- Extras
-
Intent.EXTRA_EMAIL
- Tableau de chaînes contenant toutes les adresses e-mail des destinataires "À".
Intent.EXTRA_CC
- Tableau de chaînes contenant toutes les adresses e-mail des destinataires en copie.
Intent.EXTRA_BCC
- Tableau de chaînes contenant toutes les adresses e-mail des destinataires en "Cci".
Intent.EXTRA_SUBJECT
- Chaîne contenant l'objet de l'e-mail.
Intent.EXTRA_TEXT
- Chaîne contenant le corps de l'e-mail.
Intent.EXTRA_STREAM
- Un
Uri
pointant vers la pièce jointe. Si vous utilisez l'actionACTION_SEND_MULTIPLE
, il s'agit plutôt d'unArrayList
contenant plusieurs objetsUri
.
Exemple d'intention :
Kotlin
fun composeEmail(addresses: Array<String>, subject: String, attachment: Uri) { val intent = Intent(Intent.ACTION_SEND).apply { type = "*/*" putExtra(Intent.EXTRA_EMAIL, addresses) putExtra(Intent.EXTRA_SUBJECT, subject) putExtra(Intent.EXTRA_STREAM, attachment) } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void composeEmail(String[] addresses, String subject, Uri attachment) { Intent intent = new Intent(Intent.ACTION_SEND); intent.setType("*/*"); intent.putExtra(Intent.EXTRA_EMAIL, addresses); intent.putExtra(Intent.EXTRA_SUBJECT, subject); intent.putExtra(Intent.EXTRA_STREAM, attachment); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Si vous souhaitez vous assurer que votre intention n'est traitée que par une application de messagerie électronique, et non par une application de messagerie texte ou sociale, utilisez l'action ACTION_SENDTO
et incluez le schéma de données "mailto:"
comme indiqué dans l'exemple suivant :
Kotlin
fun composeEmail(addresses: Array<String>, subject: String) { val intent = Intent(Intent.ACTION_SENDTO).apply { data = Uri.parse("mailto:") // Only email apps handle this. putExtra(Intent.EXTRA_EMAIL, addresses) putExtra(Intent.EXTRA_SUBJECT, subject) } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void composeEmail(String[] addresses, String subject) { Intent intent = new Intent(Intent.ACTION_SENDTO); intent.setData(Uri.parse("mailto:")); // Only email apps handle this. intent.putExtra(Intent.EXTRA_EMAIL, addresses); intent.putExtra(Intent.EXTRA_SUBJECT, subject); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="android.intent.action.SEND" /> <data android:type="*/*" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> <intent-filter> <action android:name="android.intent.action.SENDTO" /> <data android:scheme="mailto" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </activity>
Stockage de fichiers
Vous trouverez ci-dessous les actions courantes pour les applications de stockage de fichiers, ainsi que les informations dont vous avez besoin pour créer un filtre d'intent afin de promouvoir la capacité de votre application à effectuer chaque action.
Récupérer un type de fichier spécifique
Pour demander à l'utilisateur de sélectionner un fichier tel qu'un document ou une photo et de renvoyer une référence à votre application, utilisez l'action ACTION_GET_CONTENT
et spécifiez le type MIME souhaité. La référence de fichier renvoyée à votre application est transitoire par rapport au cycle de vie actuel de votre activité. Par conséquent, si vous souhaitez y accéder ultérieurement, vous devez importer une copie que vous pourrez lire plus tard.
Cette intention permet également à l'utilisateur de créer un fichier au cours du processus. Par exemple, au lieu de sélectionner une photo existante, l'utilisateur peut en prendre une nouvelle avec l'appareil photo.
L'intent de résultat transmis à votre méthode onActivityResult()
inclut des données avec un URI pointant vers le fichier.
L'URI peut être n'importe quoi, comme un URI http:
, file:
ou content:
. Toutefois, si vous souhaitez limiter les fichiers sélectionnables à ceux qui sont accessibles à partir d'un fournisseur de contenu (un URI content:
) et qui sont disponibles en tant que flux de fichiers avec openFileDescriptor()
, ajoutez la catégorie CATEGORY_OPENABLE
à votre intent.
Sur Android 4.3 (niveau d'API 18) ou version ultérieure, vous pouvez également permettre à l'utilisateur de sélectionner plusieurs fichiers en ajoutant EXTRA_ALLOW_MULTIPLE
à l'intent et en le définissant sur true
.
Vous pouvez ensuite accéder à chacun des fichiers sélectionnés dans un objet ClipData
renvoyé par getClipData()
.
- Action
ACTION_GET_CONTENT
- Schéma d'URI de données
- Aucun
- Type MIME
- Type MIME correspondant au type de fichier que l'utilisateur doit sélectionner.
- Extras
-
EXTRA_ALLOW_MULTIPLE
- Booléen indiquant si l'utilisateur peut sélectionner plusieurs fichiers à la fois.
EXTRA_LOCAL_ONLY
- Valeur booléenne indiquant si le fichier renvoyé doit être disponible directement sur l'appareil, plutôt que de nécessiter un téléchargement à partir d'un service distant.
- Catégorie (facultatif)
-
CATEGORY_OPENABLE
- Pour ne renvoyer que les fichiers "ouvrables" qui peuvent être représentés sous forme de flux de fichiers avec
openFileDescriptor()
.
Exemple d'intention pour obtenir une photo :
Kotlin
const val REQUEST_IMAGE_GET = 1 fun selectImage() { val intent = Intent(Intent.ACTION_GET_CONTENT).apply { type = "image/*" } if (intent.resolveActivity(packageManager) != null) { startActivityForResult(intent, REQUEST_IMAGE_GET) } } override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) { if (requestCode == REQUEST_IMAGE_GET && resultCode == Activity.RESULT_OK) { val thumbnail: Bitmap = data.getParcelableExtra("data") val fullPhotoUri: Uri = data.data // Do work with photo saved at fullPhotoUri. ... } }
Java
static final int REQUEST_IMAGE_GET = 1; public void selectImage() { Intent intent = new Intent(Intent.ACTION_GET_CONTENT); intent.setType("image/*"); if (intent.resolveActivity(getPackageManager()) != null) { startActivityForResult(intent, REQUEST_IMAGE_GET); } } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == REQUEST_IMAGE_GET && resultCode == RESULT_OK) { Bitmap thumbnail = data.getParcelable("data"); Uri fullPhotoUri = data.getData(); // Do work with photo saved at fullPhotoUri. ... } }
Exemple de filtre d'intent pour renvoyer une photo :
<activity ...> <intent-filter> <action android:name="android.intent.action.GET_CONTENT" /> <data android:type="image/*" /> <category android:name="android.intent.category.DEFAULT" /> <!-- The OPENABLE category declares that the returned file is accessible from a content provider that supportsOpenableColumns
andContentResolver.openFileDescriptor()
. --> <category android:name="android.intent.category.OPENABLE" /> </intent-filter> </activity>
Ouvrir un type de fichier spécifique
Au lieu de récupérer une copie d'un fichier que vous devez importer dans votre application, vous pouvez, en utilisant l'action ACTION_GET_CONTENT
, demander à ouvrir un fichier géré par une autre application en utilisant l'action ACTION_OPEN_DOCUMENT
et en spécifiant un type MIME.
Pour permettre également à l'utilisateur de créer un document dans lequel votre application peut écrire, utilisez plutôt l'action ACTION_CREATE_DOCUMENT
.
Par exemple, au lieu de sélectionner des documents PDF existants, l'intention ACTION_CREATE_DOCUMENT
permet aux utilisateurs de choisir où ils souhaitent créer un document, par exemple dans une autre application qui gère le stockage du document. Votre application reçoit ensuite l'emplacement de l'URI où elle peut écrire le nouveau document.
Alors que l'intent transmis à votre méthode onActivityResult()
à partir de l'action ACTION_GET_CONTENT
peut renvoyer un URI de n'importe quel type, l'intent de résultat de ACTION_OPEN_DOCUMENT
et ACTION_CREATE_DOCUMENT
spécifie toujours le fichier choisi comme un URI content:
qui est soutenu par un DocumentsProvider
. Vous pouvez ouvrir le fichier avec openFileDescriptor()
et interroger ses détails à l'aide des colonnes de DocumentsContract.Document
.
L'URI renvoyé accorde à votre application un accès en lecture à long terme au fichier, éventuellement avec un accès en écriture. L'action ACTION_OPEN_DOCUMENT
est particulièrement utile lorsque vous souhaitez lire un fichier existant sans en créer de copie dans votre application ou lorsque vous souhaitez ouvrir et modifier un fichier sur place.
Vous pouvez également autoriser l'utilisateur à sélectionner plusieurs fichiers en ajoutant EXTRA_ALLOW_MULTIPLE
à l'intention, défini sur true
.
Si l'utilisateur ne sélectionne qu'un seul élément, vous pouvez le récupérer à partir de getData()
.
Si l'utilisateur sélectionne plusieurs éléments, getData()
renvoie la valeur "null". Vous devez alors récupérer chaque élément à partir d'un objet ClipData
renvoyé par getClipData()
.
Remarque : Votre intent doit spécifier un type MIME et doit déclarer la catégorie CATEGORY_OPENABLE
. Le cas échéant, vous pouvez spécifier plusieurs types MIME en ajoutant un tableau de types MIME avec l'extra EXTRA_MIME_TYPES
. Si vous le faites, vous devez définir le type MIME principal dans setType()
sur "*/*"
.
- Action
ACTION_OPEN_DOCUMENT
ou
ACTION_CREATE_DOCUMENT
- Schéma d'URI de données
- Aucun
- Type MIME
- Type MIME correspondant au type de fichier que l'utilisateur doit sélectionner.
- Extras
-
EXTRA_MIME_TYPES
- Tableau de types MIME correspondant aux types de fichiers demandés par votre application. Lorsque vous utilisez cet extra, vous devez définir le type MIME principal dans
setType()
sur"*/*"
. EXTRA_ALLOW_MULTIPLE
- Booléen indiquant si l'utilisateur peut sélectionner plusieurs fichiers à la fois.
EXTRA_TITLE
- À utiliser avec
ACTION_CREATE_DOCUMENT
pour spécifier un nom de fichier initial. EXTRA_LOCAL_ONLY
- Valeur booléenne indiquant si le fichier renvoyé doit être disponible directement sur l'appareil, plutôt que de nécessiter un téléchargement à partir d'un service distant.
- Catégorie
-
CATEGORY_OPENABLE
- Pour ne renvoyer que les fichiers "ouvrables" qui peuvent être représentés sous forme de flux de fichiers avec
openFileDescriptor()
.
Exemple d'intention pour obtenir une photo :
Kotlin
const val REQUEST_IMAGE_OPEN = 1 fun selectImage2() { val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply { type = "image/*" addCategory(Intent.CATEGORY_OPENABLE) } // Only the system receives the ACTION_OPEN_DOCUMENT, so no need to test. startActivityForResult(intent, REQUEST_IMAGE_OPEN) } override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) { if (requestCode == REQUEST_IMAGE_OPEN && resultCode == Activity.RESULT_OK) { val fullPhotoUri: Uri = data.data // Do work with full size photo saved at fullPhotoUri. ... } }
Java
static final int REQUEST_IMAGE_OPEN = 1; public void selectImage() { Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT); intent.setType("image/*"); intent.addCategory(Intent.CATEGORY_OPENABLE); // Only the system receives the ACTION_OPEN_DOCUMENT, so no need to test. startActivityForResult(intent, REQUEST_IMAGE_OPEN); } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == REQUEST_IMAGE_OPEN && resultCode == RESULT_OK) { Uri fullPhotoUri = data.getData(); // Do work with full size photo saved at fullPhotoUri. ... } }
Les applications tierces ne peuvent pas répondre à un intent avec l'action ACTION_OPEN_DOCUMENT
. Au lieu de cela, le système reçoit cette intention et affiche tous les fichiers disponibles à partir de différentes applications dans une interface utilisateur unifiée.
Pour fournir les fichiers de votre application dans cette UI et permettre à d'autres applications de les ouvrir, vous devez implémenter un DocumentsProvider
et inclure un filtre d'intent pour PROVIDER_INTERFACE
("android.content.action.DOCUMENTS_PROVIDER"
), comme indiqué dans l'exemple suivant :
<provider ... android:grantUriPermissions="true" android:exported="true" android:permission="android.permission.MANAGE_DOCUMENTS"> <intent-filter> <action android:name="android.content.action.DOCUMENTS_PROVIDER" /> </intent-filter> </provider>
Pour savoir comment rendre les fichiers gérés par votre application ouvrables à partir d'autres applications, consultez Ouvrir des fichiers à l'aide de Storage Access Framework.
Actions locales
Appeler une voiture est une action locale courante. Créez un filtre d'intent pour annoncer la capacité de votre application à effectuer cette action à l'aide des informations de la section suivante.
Appeler un taxi
Actions Google Voice
- "get me a taxi" (appelle-moi un taxi)
- "appelle-moi une voiture"
(Wear OS uniquement)
Pour appeler un taxi, utilisez l'action ACTION_RESERVE_TAXI_RESERVATION
.
Remarque : Les applications doivent demander une confirmation à l'utilisateur avant d'effectuer cette action.
- Action
ACTION_RESERVE_TAXI_RESERVATION
- URI de données
- Aucun
- Type MIME
- Aucun
- Extras
- Aucun
Exemple d'intention :
Kotlin
fun callCar() { val intent = Intent(ReserveIntents.ACTION_RESERVE_TAXI_RESERVATION) if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void callCar() { Intent intent = new Intent(ReserveIntents.ACTION_RESERVE_TAXI_RESERVATION); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="com.google.android.gms.actions.RESERVE_TAXI_RESERVATION" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </activity>
Maps
Afficher un lieu sur une carte est une action courante pour les applications de cartographie. Créez un filtre d'intent pour annoncer la capacité de votre application à effectuer cette action à l'aide des informations de la section suivante.
Afficher un lieu sur une carte
Pour ouvrir une carte, utilisez l'action ACTION_VIEW
et spécifiez les informations de localisation dans les données d'intent avec l'un des schémas suivants.
- Action
ACTION_VIEW
- Schéma d'URI de données
-
geo:latitude,longitude
- Affiche la carte à la longitude et à la latitude indiquées.
Exemple :
"geo:47.6,-122.3"
geo:latitude,longitude?z=zoom
- Affiche la carte à la longitude et à la latitude indiquées, à un certain niveau de zoom. Un niveau de zoom de 1 affiche la Terre entière, centrée sur les valeurs lat et lng fournies. Le niveau de zoom le plus élevé (le plus proche) est 23.
Exemple :
"geo:47.6,-122.3?z=11"
geo:0,0?q=lat,lng(label)
- Affiche la carte à la longitude et à la latitude données avec un libellé de chaîne.
Exemple :
"geo:0,0?q=34.99,-106.61(Treasure)"
geo:0,0?q=my+street+address
- Affiche l'emplacement de "mon adresse", qui peut être une adresse spécifique ou une requête d'emplacement.
Exemple :
"geo:0,0?q=1600+Amphitheatre+Parkway%2C+CA"
Remarque : Toutes les chaînes transmises dans l'URI
geo
doivent être encodées. Par exemple, la chaîne1st & Pike, Seattle
devient1st%20%26%20Pike%2C%20Seattle
. Les espaces de la chaîne sont encodés avec%20
ou remplacés par le signe plus (+
).
- Type MIME
- Aucun
Exemple d'intention :
Kotlin
fun showMap(geoLocation: Uri) { val intent = Intent(Intent.ACTION_VIEW).apply { data = geoLocation } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void showMap(Uri geoLocation) { Intent intent = new Intent(Intent.ACTION_VIEW); intent.setData(geoLocation); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="android.intent.action.VIEW" /> <data android:scheme="geo" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </activity>
Musique ou vidéo
Vous trouverez ci-dessous les actions courantes pour les applications de musique et de vidéo, ainsi que les informations dont vous avez besoin pour créer un filtre d'intent afin de promouvoir la capacité de votre application à effectuer chaque action.
Lire un fichier multimédia
Pour lire un fichier musical, utilisez l'action ACTION_VIEW
et spécifiez l'emplacement URI du fichier dans les données de l'intent.
- Action
ACTION_VIEW
- Schéma d'URI de données
-
file:<URI>
content:<URI>
http:<URL>
- Type MIME
-
"audio/*"
"application/ogg"
"application/x-ogg"
"application/itunes"
- ou toute autre information requise par votre application.
Exemple d'intention :
Kotlin
fun playMedia(file: Uri) { val intent = Intent(Intent.ACTION_VIEW).apply { data = file } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void playMedia(Uri file) { Intent intent = new Intent(Intent.ACTION_VIEW); intent.setData(file); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="android.intent.action.VIEW" /> <data android:type="audio/*" /> <data android:type="application/ogg" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </activity>
Écouter de la musique en fonction d'une requête de recherche
Pour lire de la musique en fonction d'une requête de recherche, utilisez l'intention INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH
. Une application peut déclencher cet intent en réponse à la commande vocale de l'utilisateur pour lire de la musique. L'application de réception de cette intention effectue une recherche dans son inventaire pour faire correspondre le contenu existant à la requête donnée et commence à lire ce contenu.
Dans cette intention, incluez l'extra de chaîne EXTRA_MEDIA_FOCUS
, qui spécifie le mode de recherche souhaité. Par exemple, le mode de recherche peut indiquer si la recherche porte sur le nom d'un artiste ou d'un titre.
- Action
INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH
- Schéma d'URI de données
- Aucun
- Type MIME
- Aucun
- Extras
-
MediaStore.EXTRA_MEDIA_FOCUS
(obligatoire)-
Indique le mode de recherche : si l'utilisateur recherche un artiste, un album, un titre ou une playlist en particulier. La plupart des modes de recherche nécessitent des extras supplémentaires. Par exemple, si l'utilisateur souhaite écouter un titre en particulier, l'intent peut comporter trois extras supplémentaires : le titre du morceau, l'artiste et l'album. Cette intention accepte les modes de recherche suivants pour chaque valeur de
EXTRA_MEDIA_FOCUS
:Tous :
"vnd.android.cursor.item/*"
-
Mets de la musique. L'application de réception lit de la musique en fonction d'un choix intelligent, comme la dernière playlist écoutée par l'utilisateur.
Autres avantages :
QUERY
(obligatoire) : chaîne vide. Cette option est toujours fournie pour assurer la rétrocompatibilité. Les applications existantes qui ne connaissent pas les modes de recherche peuvent traiter cette intention comme une recherche non structurée.
Non structuré :
"vnd.android.cursor.item/*"
-
Écoutez un titre, un album ou un genre spécifiques à partir d'une requête de recherche non structurée. Les applications peuvent générer un intent avec ce mode de recherche lorsqu'elles ne peuvent pas identifier le type de contenu que l'utilisateur souhaite écouter. Utilisez des modes de recherche plus spécifiques lorsque cela est possible.
Autres avantages :
QUERY
(obligatoire) : chaîne contenant n'importe quelle combinaison de l'artiste, de l'album, du titre ou du genre.
Genre :
Audio.Genres.ENTRY_CONTENT_TYPE
-
Mettre de la musique d'un genre spécifique
Autres avantages :
"android.intent.extra.genre"
(obligatoire) : genre.QUERY
(obligatoire) : genre. Cet extra est toujours fourni pour assurer la rétrocompatibilité. Les applications existantes qui ne connaissent pas les modes de recherche peuvent traiter cette intention comme une recherche non structurée.
Artiste :
Audio.Artists.ENTRY_CONTENT_TYPE
-
Mettre de la musique d'un artiste spécifique
Autres avantages :
EXTRA_MEDIA_ARTIST
(obligatoire) : artiste."android.intent.extra.genre"
: genre.QUERY
(obligatoire) : chaîne contenant n'importe quelle combinaison de l'artiste ou du genre. Cette option est toujours fournie pour assurer la rétrocompatibilité. Les applications existantes qui ne connaissent pas les modes de recherche peuvent traiter cette intention comme une recherche non structurée.
Album :
Audio.Albums.ENTRY_CONTENT_TYPE
-
Mettre de la musique d'un album spécifique
Autres avantages :
EXTRA_MEDIA_ALBUM
(obligatoire) : l'album.EXTRA_MEDIA_ARTIST
: artiste."android.intent.extra.genre"
: genre.QUERY
(obligatoire) : chaîne contenant n'importe quelle combinaison de l'album ou de l'artiste. Cette option est toujours fournie pour assurer la rétrocompatibilité. Les applications existantes qui ne connaissent pas les modes de recherche peuvent traiter cette intention comme une recherche non structurée.
Titre :
"vnd.android.cursor.item/audio"
-
Écouter un titre en particulier
Autres avantages :
EXTRA_MEDIA_ALBUM
: album.EXTRA_MEDIA_ARTIST
: artiste."android.intent.extra.genre"
: genre.EXTRA_MEDIA_TITLE
(obligatoire) : nom du titre.QUERY
(obligatoire) : chaîne contenant n'importe quelle combinaison de l'album, de l'artiste, du genre ou du titre. Cette option est toujours fournie pour assurer la rétrocompatibilité. Les applications existantes qui ne connaissent pas les modes de recherche peuvent traiter cette intention comme une recherche non structurée.
Playlist :
Audio.Playlists.ENTRY_CONTENT_TYPE
-
Lire une playlist spécifique ou une playlist correspondant à certains critères spécifiés par des extras supplémentaires.
Autres avantages :
EXTRA_MEDIA_ALBUM
: album.EXTRA_MEDIA_ARTIST
: artiste."android.intent.extra.genre"
: genre."android.intent.extra.playlist"
: playlist.EXTRA_MEDIA_TITLE
: nom du titre sur lequel la playlist est basée.QUERY
(obligatoire) : chaîne contenant n'importe quelle combinaison de l'album, de l'artiste, du genre, de la playlist ou du titre. Cette option est toujours fournie pour assurer la rétrocompatibilité. Les applications existantes qui ne connaissent pas les modes de recherche peuvent traiter cette intention comme une recherche non structurée.
Exemple d'intention :
Si l'utilisateur souhaite écouter de la musique d'un artiste en particulier, une application de recherche peut générer l'intent suivant :
Kotlin
fun playSearchArtist(artist: String) { val intent = Intent(MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH).apply { putExtra(MediaStore.EXTRA_MEDIA_FOCUS, MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE) putExtra(MediaStore.EXTRA_MEDIA_ARTIST, artist) putExtra(SearchManager.QUERY, artist) } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void playSearchArtist(String artist) { Intent intent = new Intent(MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH); intent.putExtra(MediaStore.EXTRA_MEDIA_FOCUS, MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE); intent.putExtra(MediaStore.EXTRA_MEDIA_ARTIST, artist); intent.putExtra(SearchManager.QUERY, artist); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="android.media.action.MEDIA_PLAY_FROM_SEARCH" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </activity>
Lorsque vous gérez cet intent dans votre activité, vérifiez la valeur de l'élément EXTRA_MEDIA_FOCUS
supplémentaire dans l'Intent
entrant pour déterminer le mode de recherche. Une fois que votre activité a identifié le mode de recherche, lisez les valeurs des extras supplémentaires pour ce mode de recherche spécifique.
Grâce à ces informations, votre application peut ensuite effectuer la recherche dans son inventaire pour lire le contenu correspondant à la requête de recherche. Ce processus est illustré dans l'exemple suivant.
Kotlin
override fun onCreate(savedInstanceState: Bundle?) { ... if (intent.action.compareTo(MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH) == 0) { val mediaFocus: String? = intent.getStringExtra(MediaStore.EXTRA_MEDIA_FOCUS) val query: String? = intent.getStringExtra(SearchManager.QUERY) // Some of these extras might not be available depending on the search mode. val album: String? = intent.getStringExtra(MediaStore.EXTRA_MEDIA_ALBUM) val artist: String? = intent.getStringExtra(MediaStore.EXTRA_MEDIA_ARTIST) val genre: String? = intent.getStringExtra("android.intent.extra.genre") val playlist: String? = intent.getStringExtra("android.intent.extra.playlist") val title: String? = intent.getStringExtra(MediaStore.EXTRA_MEDIA_TITLE) // Determine the search mode and use the corresponding extras. when { mediaFocus == null -> { // 'Unstructured' search mode (backward compatible) playUnstructuredSearch(query) } mediaFocus.compareTo("vnd.android.cursor.item/*") == 0 -> { if (query?.isNotEmpty() == true) { // 'Unstructured' search mode. playUnstructuredSearch(query) } else { // 'Any' search mode. playResumeLastPlaylist() } } mediaFocus.compareTo(MediaStore.Audio.Genres.ENTRY_CONTENT_TYPE) == 0 -> { // 'Genre' search mode. playGenre(genre) } mediaFocus.compareTo(MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE) == 0 -> { // 'Artist' search mode. playArtist(artist, genre) } mediaFocus.compareTo(MediaStore.Audio.Albums.ENTRY_CONTENT_TYPE) == 0 -> { // 'Album' search mode. playAlbum(album, artist) } mediaFocus.compareTo("vnd.android.cursor.item/audio") == 0 -> { // 'Song' search mode. playSong(album, artist, genre, title) } mediaFocus.compareTo(MediaStore.Audio.Playlists.ENTRY_CONTENT_TYPE) == 0 -> { // 'Playlist' search mode. playPlaylist(album, artist, genre, playlist, title) } } } }
Java
protected void onCreate(Bundle savedInstanceState) { //... Intent intent = this.getIntent(); if (intent.getAction().compareTo(MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH) == 0) { String mediaFocus = intent.getStringExtra(MediaStore.EXTRA_MEDIA_FOCUS); String query = intent.getStringExtra(SearchManager.QUERY); // Some of these extras might not be available depending on the search mode. String album = intent.getStringExtra(MediaStore.EXTRA_MEDIA_ALBUM); String artist = intent.getStringExtra(MediaStore.EXTRA_MEDIA_ARTIST); String genre = intent.getStringExtra("android.intent.extra.genre"); String playlist = intent.getStringExtra("android.intent.extra.playlist"); String title = intent.getStringExtra(MediaStore.EXTRA_MEDIA_TITLE); // Determine the search mode and use the corresponding extras. if (mediaFocus == null) { // 'Unstructured' search mode (backward compatible). playUnstructuredSearch(query); } else if (mediaFocus.compareTo("vnd.android.cursor.item/*") == 0) { if (query.isEmpty()) { // 'Any' search mode. playResumeLastPlaylist(); } else { // 'Unstructured' search mode. playUnstructuredSearch(query); } } else if (mediaFocus.compareTo(MediaStore.Audio.Genres.ENTRY_CONTENT_TYPE) == 0) { // 'Genre' search mode. playGenre(genre); } else if (mediaFocus.compareTo(MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE) == 0) { // 'Artist' search mode. playArtist(artist, genre); } else if (mediaFocus.compareTo(MediaStore.Audio.Albums.ENTRY_CONTENT_TYPE) == 0) { // 'Album' search mode. playAlbum(album, artist); } else if (mediaFocus.compareTo("vnd.android.cursor.item/audio") == 0) { // 'Song' search mode. playSong(album, artist, genre, title); } else if (mediaFocus.compareTo(MediaStore.Audio.Playlists.ENTRY_CONTENT_TYPE) == 0) { // 'Playlist' search mode. playPlaylist(album, artist, genre, playlist, title); } } }
Nouvelle note
La création d'une note est une action courante pour les applications de prise de notes. Créez un filtre d'intent pour annoncer la capacité de votre application à effectuer cette action à l'aide des informations de la section suivante.
Créer une note
Pour créer une note, utilisez l'action
ACTION_CREATE_NOTE
et spécifiez les détails de la note, tels que l'objet et le texte, à l'aide des extras suivants.
Remarque : Les applications doivent demander une confirmation à l'utilisateur avant d'effectuer cette action.
- Action
-
ACTION_CREATE_NOTE
- Schéma d'URI de données
- Aucun
- Type MIME
-
PLAIN_TEXT_TYPE
- "*/*"
- Extras
-
-
EXTRA_NAME
- Chaîne indiquant le titre ou l'objet de la note.
-
EXTRA_TEXT
- Chaîne indiquant le texte de la note.
-
- Action
-
ACTION_DIAL
: ouvre l'application Téléphone.ACTION_CALL
: permet de passer un appel téléphonique (nécessite l'autorisationCALL_PHONE
).
- Schéma d'URI de données
-
tel:<phone-number>
voicemail:<phone-number>
- Type MIME
- Aucun
tel:2125551212
tel:(212) 555 1212
- "search for cat videos on myvideoapp" (cherche des vidéos de chats sur myvideoapp)
- Action
-
"com.google.android.gms.actions.SEARCH_ACTION"
- Prise en charge des requêtes de recherche provenant des actions vocales Google Voice.
- Extras
-
QUERY
- : chaîne contenant la requête de recherche.
- Action
ACTION_WEB_SEARCH
- Schéma d'URI de données
- Aucun
- Type MIME
- Aucun
- Extras
-
SearchManager.QUERY
- Chaîne de recherche.
- Action
-
ACTION_SETTINGS
ACTION_WIRELESS_SETTINGS
ACTION_AIRPLANE_MODE_SETTINGS
ACTION_WIFI_SETTINGS
ACTION_APN_SETTINGS
ACTION_BLUETOOTH_SETTINGS
ACTION_DATE_SETTINGS
ACTION_LOCALE_SETTINGS
ACTION_INPUT_METHOD_SETTINGS
ACTION_DISPLAY_SETTINGS
ACTION_SECURITY_SETTINGS
ACTION_LOCATION_SOURCE_SETTINGS
ACTION_INTERNAL_STORAGE_SETTINGS
ACTION_MEMORY_CARD_SETTINGS
Pour en savoir plus sur les autres écrans de paramètres disponibles, consultez la documentation
Settings
. - Schéma d'URI de données
- Aucun
- Type MIME
- Aucun
- Action
ACTION_SENDTO
ou
ACTION_SEND
ou
ACTION_SEND_MULTIPLE
- Schéma d'URI de données
-
sms:<phone_number>
smsto:<phone_number>
mms:<phone_number>
mmsto:<phone_number>
Ces schémas sont tous traités de la même manière.
- Type MIME
-
"text/plain"
"image/*"
"video/*"
- Extras
-
"subject"
- Chaîne pour l'objet du message (généralement pour les MMS uniquement).
"sms_body"
- Chaîne du message texte.
EXTRA_STREAM
- A
Uri
pointant vers l'image ou la vidéo à joindre. Si vous utilisez l'actionACTION_SEND_MULTIPLE
, cet extra est unArrayList
d'objetsUri
pointant vers les images ou les vidéos à joindre.
- Action
ACTION_VIEW
- Schéma d'URI de données
http:<URL>
https:<URL>
- Type MIME
-
"text/plain"
"text/html"
"application/xhtml+xml"
"application/vnd.wap.xhtml+xml"
- Configurez un appareil Android pour le développement ou utilisez un appareil virtuel.
- Installez une version de votre application qui gère les intents que vous souhaitez prendre en charge.
- Déclenchez un intent à l'aide de
adb
:adb shell am start -a <ACTION> -t <MIME_TYPE> -d <DATA> \ -e <EXTRA_NAME> <EXTRA_VALUE> -n <ACTIVITY>
Exemple :
adb shell am start -a android.intent.action.DIAL \ -d tel:555-5555 -n org.example.MyApp/.MyActivity
- Si vous définissez les filtres d'intent requis, gérez l'intent.
Exemple d'intention :
Kotlin
fun createNote(subject: String, text: String) { val intent = Intent(NoteIntents.ACTION_CREATE_NOTE).apply { putExtra(NoteIntents.EXTRA_NAME, subject) putExtra(NoteIntents.EXTRA_TEXT, text) } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void createNote(String subject, String text) { Intent intent = new Intent(NoteIntents.ACTION_CREATE_NOTE) .putExtra(NoteIntents.EXTRA_NAME, subject) .putExtra(NoteIntents.EXTRA_TEXT, text); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="com.google.android.gms.actions.CREATE_NOTE" /> <category android:name="android.intent.category.DEFAULT" /> <data android:mimeType="*/*" /> </intent-filter> </activity>
Téléphone
L'initiation d'un appel est une action courante pour les applications téléphoniques. Créez un filtre d'intent pour annoncer la capacité de votre application à effectuer cette action à l'aide des informations de la section suivante.
Appel téléphonique
Pour ouvrir l'application Téléphone et composer un numéro de téléphone, utilisez l'action ACTION_DIAL
et spécifiez un numéro de téléphone à l'aide du schéma d'URI suivant. Lorsque l'application Téléphone s'ouvre, elle affiche le numéro de téléphone. L'utilisateur doit appuyer sur le bouton Appeler pour lancer l'appel.
Pour passer un appel téléphonique directement, utilisez l'action ACTION_CALL
et spécifiez un numéro de téléphone à l'aide du schéma d'URI suivant. Lorsque l'application Téléphone s'ouvre, l'appel téléphonique commence. L'utilisateur n'a pas besoin d'appuyer sur le bouton Appeler.
L'action ACTION_CALL
nécessite que vous ajoutiez l'autorisation CALL_PHONE
à votre fichier manifeste :
<uses-permission android:name="android.permission.CALL_PHONE" />
Les numéros de téléphone valides sont ceux définis dans la RFC 3966 de l'IETF. Voici quelques exemples valides :
Le clavier de l'application Téléphone est efficace pour normaliser les schémas, tels que les numéros de téléphone. Le schéma décrit n'est donc pas strictement requis dans la méthode Uri.parse()
.
Toutefois, si vous n'avez pas essayé de schéma ou si vous n'êtes pas sûr qu'il puisse être géré, utilisez plutôt la méthode Uri.fromParts()
.
Exemple d'intention :
Kotlin
fun dialPhoneNumber(phoneNumber: String) { val intent = Intent(Intent.ACTION_DIAL).apply { data = Uri.parse("tel:$phoneNumber") } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void dialPhoneNumber(String phoneNumber) { Intent intent = new Intent(Intent.ACTION_DIAL); intent.setData(Uri.parse("tel:" + phoneNumber)); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Recherche
Vous trouverez ci-dessous les actions courantes pour les applications de recherche, ainsi que les informations dont vous avez besoin pour créer un filtre d'intent afin de promouvoir la capacité de votre application à effectuer chacune de ces actions.
Effectuer une recherche à l'aide d'une application spécifique
Actions Google Voice
Pour prendre en charge la recherche dans le contexte de votre application, déclarez un filtre d'intent dans votre application avec l'action SEARCH_ACTION
, comme illustré dans l'exemple de filtre d'intent suivant.
Remarque : Nous vous déconseillons d'utiliser SEARCH_ACTION
pour la recherche d'applications.
Implémentez plutôt l'action GET_THING
pour tirer parti de la compatibilité intégrée de l'Assistant Google avec la recherche dans l'application. Pour en savoir plus, consultez la documentation sur les actions d'application de l'Assistant Google.
Exemple de filtre d'intent :
<activity android:name=".SearchActivity"> <intent-filter> <action android:name="com.google.android.gms.actions.SEARCH_ACTION"/> <category android:name="android.intent.category.DEFAULT"/> </intent-filter> </activity>
Effectuer une recherche sur le Web
Pour lancer une recherche sur le Web, utilisez l'action ACTION_WEB_SEARCH
et spécifiez la chaîne de recherche dans l'extra SearchManager.QUERY
.
Exemple d'intention :
Kotlin
fun searchWeb(query: String) { val intent = Intent(Intent.ACTION_WEB_SEARCH).apply { putExtra(SearchManager.QUERY, query) } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void searchWeb(String query) { Intent intent = new Intent(Intent.ACTION_WEB_SEARCH); intent.putExtra(SearchManager.QUERY, query); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Paramètres
Pour ouvrir un écran dans l'application Paramètres système lorsque votre application exige que l'utilisateur modifie quelque chose, utilisez l'une des actions d'intent suivantes :
Exemple d'intention :
Kotlin
fun openWifiSettings() { val intent = Intent(Settings.ACTION_WIFI_SETTINGS) if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void openWifiSettings() { Intent intent = new Intent(Settings.ACTION_WIFI_SETTINGS); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Envoi de SMS
Composer un message SMS/MMS avec une pièce jointe est une action courante pour les applications de messagerie. Créez un filtre d'intent pour annoncer la capacité de votre application à effectuer cette action à l'aide des informations de la section suivante.
Rédiger un message SMS/MMS avec une pièce jointe
Pour envoyer un SMS ou un MMS, utilisez l'une des actions d'intent suivantes et spécifiez les détails du message, tels que le numéro de téléphone, l'objet et le corps du message, à l'aide des clés supplémentaires suivantes.
Exemple d'intention :
Kotlin
fun composeMmsMessage(message: String, attachment: Uri) { val intent = Intent(Intent.ACTION_SENDTO).apply { type = HTTP.PLAIN_TEXT_TYPE putExtra("sms_body", message) putExtra(Intent.EXTRA_STREAM, attachment) } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void composeMmsMessage(String message, Uri attachment) { Intent intent = new Intent(Intent.ACTION_SENDTO); intent.setType(HTTP.PLAIN_TEXT_TYPE); intent.putExtra("sms_body", message); intent.putExtra(Intent.EXTRA_STREAM, attachment); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Si vous souhaitez vous assurer que votre intention n'est traitée que par une application de messagerie texte, et non par d'autres applications de messagerie électronique ou de réseaux sociaux, utilisez l'action ACTION_SENDTO
et incluez le schéma de données "smsto:"
comme indiqué dans l'exemple suivant :
Kotlin
fun composeMmsMessage(message: String, attachment: Uri) { val intent = Intent(Intent.ACTION_SEND).apply { data = Uri.parse("smsto:") // Only SMS apps respond to this. putExtra("sms_body", message) putExtra(Intent.EXTRA_STREAM, attachment) } if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void composeMmsMessage(String message, Uri attachment) { Intent intent = new Intent(Intent.ACTION_SEND); intent.setData(Uri.parse("smsto:")); // Only SMS apps respond to this. intent.putExtra("sms_body", message); intent.putExtra(Intent.EXTRA_STREAM, attachment); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="android.intent.action.SEND" /> <data android:type="text/plain" /> <data android:type="image/*" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </activity>
Remarque : Si vous développez une application de messagerie SMS/MMS, vous devez implémenter des filtres d'intent pour plusieurs actions supplémentaires afin d'être disponible en tant qu'application de SMS par défaut sur Android 4.4 et versions ultérieures. Pour en savoir plus, consultez la documentation sur Telephony
.
Navigateur Web
Le chargement d'une URL Web est une action courante pour les applications de navigateur Web. Créez un filtre d'intent pour annoncer la capacité de votre application à effectuer cette action à l'aide des informations de la section suivante.
Charger une URL Web
Pour ouvrir une page Web, utilisez l'action ACTION_VIEW
et spécifiez l'URL Web dans les données de l'intent.
Exemple d'intention :
Kotlin
fun openWebPage(url: String) { val webpage: Uri = Uri.parse(url) val intent = Intent(Intent.ACTION_VIEW, webpage) if (intent.resolveActivity(packageManager) != null) { startActivity(intent) } }
Java
public void openWebPage(String url) { Uri webpage = Uri.parse(url); Intent intent = new Intent(Intent.ACTION_VIEW, webpage); if (intent.resolveActivity(getPackageManager()) != null) { startActivity(intent); } }
Exemple de filtre d'intent :
<activity ...> <intent-filter> <action android:name="android.intent.action.VIEW" /> <!-- Include the host attribute if you want your app to respond only to URLs with your app's domain. --> <data android:scheme="http" android:host="www.example.com" /> <category android:name="android.intent.category.DEFAULT" /> <!-- The BROWSABLE category is required to get links from web pages. --> <category android:name="android.intent.category.BROWSABLE" /> </intent-filter> </activity>
Conseil : Si votre application Android offre des fonctionnalités similaires à celles de votre site Web, incluez un filtre d'intent pour les URL qui pointent vers votre site Web. Ensuite, si les utilisateurs ont installé votre application, les liens provenant d'e-mails ou d'autres pages Web pointant vers votre site Web ouvrent votre application Android au lieu de votre page Web. Pour en savoir plus, consultez Gestion des liens d'application Android.
À partir d'Android 12 (niveau d'API 31), une intention Web générique n'est résolue en activité dans votre application que si celle-ci est approuvée pour le domaine spécifique contenu dans cette intention Web. Si votre application n'est pas approuvée pour le domaine, l'intention Web est résolue dans l'application de navigateur par défaut de l'utilisateur.
Valider les intents avec Android Debug Bridge
Pour vérifier que votre application répond aux intents que vous souhaitez prendre en charge, vous pouvez utiliser l'outil adb
pour déclencher des intents spécifiques en procédant comme suit :
Pour en savoir plus, consultez Émettre des commandes shell.