Intents courants

Un intent vous permet de démarrer une activité dans une autre application en décrivant l'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 une action et fournit des données avec lesquelles effectuer l'action.

Lorsque vous appelez startActivity() ou startActivityForResult() et que vous lui transmettez un intent implicite, le système résolve l'intent à une application capable de gérer l'intent et lance le 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 en fonction du type d'application qui gère l'intent. Chaque section montre également comment créer un filtre d'intent pour annoncer la capacité de votre application à effectuer l'action.

Attention:Si aucune application de l'appareil ne peut recevoir un intent implicite, l'application plante lorsqu'elle appelle startActivity(). Pour vérifier qu'une application existe pour recevoir l'intent, appelez resolveActivity() sur votre objet Intent. Si le résultat n'est pas nul, au moins une application peut gérer l'intent. Vous pouvez appeler startActivity() en toute sécurité. Si le résultat est nul, n'utilisez pas l'intent et, si possible, désactivez la fonctionnalité qui appelle l'intent.

Si vous ne savez pas comment créer des intents ou des filtres d'intent, consultez d'abord Intents et filtres d'intent.

Pour savoir comment déclencher les intents répertoriés sur cette page à partir de votre hôte de développement, consultez la section Vérifier les intents avec Android Debug Bridge.

Commandes vocales Google

Les commandes vocales Google déclenchent certains des intents répertoriés sur cette page en réponse à des commandes vocales. Pour en savoir plus, consultez Premiers pas avec les commandes vocales système.

Réveil

Vous trouverez ci-dessous des actions courantes pour les applications de réveil, 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.

Créer une alarme

Commandes vocales Google

  • "Règle une alarme sur 7h"

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 les éléments supplémentaires concernant les heures, les minutes et les messages sont disponibles dans Android 2.3 (niveau d'API 9) ou version antérieure. Les autres extras sont disponibles dans les versions supérieures de la plate-forme.

Action
ACTION_SET_ALARM
URI de données
Aucune
Type MIME
Aucun
Extras
EXTRA_HOUR
Heure de l'alarme.
EXTRA_MINUTES
Minutes de l'alarme.
EXTRA_MESSAGE
Message personnalisé permettant d'identifier l'alarme.
EXTRA_DAYS
Un ArrayList comprenant chaque jour de la semaine pendant lequel l'alarme se répète. Chaque jour doit être déclaré avec un entier de la classe Calendar, tel que MONDAY.

Pour une alarme unique, n'indiquez pas ce supplément.

EXTRA_RINGTONE
URI content: spécifiant la sonnerie à utiliser avec l'alarme, ou VALUE_RINGTONE_SILENT s'il n'y a pas de sonnerie.

Pour utiliser la sonnerie par défaut, ne spécifiez pas ce supplément.

EXTRA_VIBRATE
Valeur booléenne indiquant si le vibreur doit être activé pour cette alarme.
EXTRA_SKIP_UI
Valeur booléenne indiquant si l'application qui répond doit ignorer son UI lors de la définition de l'alarme. Si la valeur est "true", l'application doit contourner toute UI de confirmation et définir l'alarme spécifiée.

Exemple d'intent:

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);
    }
}
Remarque :

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

Commandes vocales Google

  • "règle le minuteur sur 5 minutes"

Pour créer un compte à rebours, utilisez l'action ACTION_SET_TIMER et spécifiez les détails du minuteur, tels que la durée, à l'aide des éléments supplémentaires suivants.

Remarque:Cet intent est disponible sur Android 4.4 (niveau d'API 19) ou version ultérieure.

Action
ACTION_SET_TIMER
URI de données
Aucune
Type MIME
Aucun
Extras
EXTRA_LENGTH
Durée du minuteur en secondes.
EXTRA_MESSAGE
Message personnalisé identifiant le minuteur.
EXTRA_SKIP_UI
Valeur booléenne indiquant si l'application qui répond doit ignorer son UI lors du réglage du minuteur. Si la valeur est "true", l'application doit contourner toute UI de confirmation et démarrer le minuteur spécifié.

Exemple d'intent:

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);
    }
}
Remarque :

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 appellent cet intent, car il est principalement utilisé par les applications système, toute application qui se comporte comme un réveil peut implémenter ce filtre d'intent et y répondre en affichant la liste des alarmes actuelles.

Remarque:Cet intent est disponible sur Android 4.4 (niveau d'API 19) ou version ultérieure.

Action
ACTION_SHOW_ALARMS
URI de données
Aucune
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 dans 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 divers 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 entière.
EXTRA_EVENT_BEGIN_TIME
Heure de début de l'événement (millisecondes depuis l'epoch).
EXTRA_EVENT_END_TIME
Heure de fin de l'événement (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 indiquant les invités, séparées par une virgule.

De nombreux autres détails d'événement peuvent être spécifiés à l'aide des constantes définies dans la classe CalendarContract.EventsColumns.

Exemple d'intent:

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 des actions courantes pour les applications d'appareil photo, y compris les informations dont vous avez besoin pour créer un filtre d'intent afin d'annoncer la capacité de votre application à effectuer chaque action.

Prendre une photo ou 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'emplacement de l'URI dans lequel 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 de l'URI de données
Aucune
Type MIME
Aucune
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 d'appareil photo parvient à renvoyer la mise au point sur votre activité (en d'autres termes, elle 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 une vignette, de la photo dans le résultat Intent, enregistré en tant que Bitmap dans un champ supplémentaire nommé "data".

Exemple d'intent:

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 sous Android 12 (niveau d'API 31) ou version ultérieure, consultez l'exemple d'intent suivant.

Exemple d'intent:

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 cet intent pour prendre une photo, y compris sur la création d'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 de la gestion de cet intent, demandez à votre activité de rechercher l'extra EXTRA_OUTPUT dans l'élément Intent entrant, puis enregistrez l'image ou la vidéo capturée à l'emplacement spécifié par cet intent et appelez setResult() avec un Intent contenant une vignette compressée dans un élément supplémentaire nommé "data".

Démarrer une application d'appareil photo en mode Image fixe

Commandes vocales Google

  • "prendre une photo"

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 de l'URI de données
Aucune
Type MIME
Aucune
Extras
Aucun

Exemple d'intent:

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 d'appareil photo en mode vidéo

Commandes vocales Google

  • "enregistre une 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 de l'URI de données
Aucune
Type MIME
Aucune
Extras
Aucun

Exemple d'intent:

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/Contacts

Vous trouverez ci-dessous des 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 d'annoncer la capacité de votre application à effectuer chaque action.

Sélectionner un contact

Pour que l'utilisateur sélectionne un contact et permette à votre application d'accéder à toutes les informations de contact, utilisez l'action ACTION_PICK et spécifiez le type MIME Contacts.CONTENT_TYPE.

Le résultat Intent envoyé à votre rappel onActivityResult() contient l'URI content: pointant vers le contact sélectionné. La réponse accorde à votre application des autorisations temporaires lui permettant de lire ce contact à l'aide de l'API Contacts Provider, même si votre application n'inclut pas l'autorisation READ_CONTACTS.

Conseil:Si vous n'avez besoin d'accéder qu'à des coordonnées spécifiques, telles qu'un numéro de téléphone ou une adresse e-mail, consultez la section suivante, qui explique comment sélectionner des données de contact spécifiques.

Action
ACTION_PICK
Schéma de l'URI de données
Aucune
Type MIME
Contacts.CONTENT_TYPE

Exemple d'intent:

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 disposez de l'URI de contact, consultez Récupérer les coordonnées d'un contact.

Lorsque vous récupérez l'URI de contact à l'aide de cet intent, vous n'avez généralement pas besoin de l'autorisation READ_CONTACTS pour lire les informations de base de ce contact, telles que son nom à afficher et s'il a été ajouté aux favoris. Toutefois, si vous essayez de lire des données plus spécifiques sur un contact donné, telles que son numéro de téléphone ou son adresse e-mail, vous devez disposer 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, telle qu'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 dans l'un des types de contenu suivants (par exemple, 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 ne devez 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 d'utiliser Contacts.CONTENT_TYPE, comme indiqué dans la section précédente. Vous bénéficiez ainsi d'un accès direct aux données souhaitées sans avoir à exécuter une requête plus complexe auprès du fournisseur de contacts.

Le résultat Intent envoyé à 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 lui permettant de lire ces données de contact, même si elle n'inclut pas l'autorisation READ_CONTACTS.

Action
ACTION_PICK
Schéma de l'URI de données
Aucune
Type MIME
CommonDataKinds.Phone.CONTENT_TYPE
Sélectionnez un contact parmi vos contacts disposant d'un numéro de téléphone.
CommonDataKinds.Email.CONTENT_TYPE
Faites votre choix parmi les contacts disposant d'une adresse e-mail.
CommonDataKinds.StructuredPostal.CONTENT_TYPE
Choisissez parmi vos contacts ayant une adresse postale.

ou l'une des nombreuses autres valeurs CONTENT_TYPE sous ContactsContract.

Exemple d'intent:

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: en tant que données d'intent.

Il existe deux méthodes principales pour récupérer initialement l'URI du contact:

  • Utilisez l'URI de contact renvoyé par l'action ACTION_PICK présenté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 la section Récupérer une liste de contacts. Cette approche nécessite l'autorisation READ_CONTACTS.
Action
ACTION_VIEW
Schéma de l'URI de données
content:<URI>
Type MIME
Aucun Le type est déduit de l'URI du contact.

Exemple d'intent:

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: en tant que données d'intent et incluez toutes les coordonnées connues dans les éléments supplémentaires spécifiés par les constantes dans ContactsContract.Intents.Insert.

Il existe deux méthodes principales pour récupérer initialement l'URI du contact:

  • Utilisez l'URI de contact renvoyé par l'action ACTION_PICK présenté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 la section Récupérer une liste de contacts. Cette approche nécessite l'autorisation READ_CONTACTS.
Action
ACTION_EDIT
Schéma de l'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 afin de pouvoir renseigner les champs des coordonnées.

Exemple d'intent:

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 en savoir plus sur la modification d'un contact, consultez Modifier des contacts à l'aide d'intents.

Insérer un contact

Pour insérer un nouveau contact, utilisez l'action ACTION_INSERT, spécifiez Contacts.CONTENT_TYPE comme type MIME et incluez toutes les coordonnées connues dans les extras spécifiés par les constantes dans ContactsContract.Intents.Insert.

Action
ACTION_INSERT
Schéma de l'URI de données
Aucune
Type MIME
Contacts.CONTENT_TYPE
Extras
Un ou plusieurs extras définis dans ContactsContract.Intents.Insert.

Exemple d'intent:

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 en savoir plus sur l'insertion d'un contact, consultez Modifier des contacts à l'aide d'intents.

Adresse e-mail

Dans les applications de messagerie, il est courant de composer un e-mail avec des pièces jointes facultatives. 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, effectuez l'une des actions suivantes selon que vous souhaitez inclure des pièces jointes ou non, et ajoutez des informations telles que le destinataire et l'objet à l'aide des clés supplémentaires indiqué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 de l'URI de données
Aucune
Type MIME
"text/plain"
"*/*"
Extras
Intent.EXTRA_EMAIL
Tableau de chaînes de toutes les adresses e-mail des destinataires "À".
Intent.EXTRA_CC
Tableau de chaînes de toutes les adresses e-mail des destinataires en copie.
Intent.EXTRA_BCC
Tableau de chaînes de toutes les adresses e-mail de destinataires en Cci.
Intent.EXTRA_SUBJECT
Chaîne avec l'objet de l'e-mail.
Intent.EXTRA_TEXT
Chaîne comprenant le corps de l'e-mail.
Intent.EXTRA_STREAM
Uri pointant vers la pièce jointe. Si vous utilisez l'action ACTION_SEND_MULTIPLE, il s'agit plutôt d'un ArrayList contenant plusieurs objets Uri.

Exemple d'intent:

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 intent n'est géré que par une application de messagerie, et non par une application de messagerie texte ou de réseau social, utilisez l'action ACTION_SENDTO et incluez le schéma de données "mailto:", comme illustré 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 des actions courantes pour les applications de stockage de fichiers, y compris les informations dont vous avez besoin pour créer un filtre d'intent afin d'annoncer 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 temporaire 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.

Cet intent 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 envoyé à votre méthode onActivityResult() inclut des données avec un URI pointant vers le fichier. L'URI peut être n'importe quel élément, 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 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 autoriser l'utilisateur à sélectionner plusieurs fichiers en ajoutant EXTRA_ALLOW_MULTIPLE à l'intent, défini 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 de l'URI de données
Aucune
Type MIME
Type MIME correspondant au type de fichier que l'utilisateur doit sélectionner.
Extras
EXTRA_ALLOW_MULTIPLE
Valeur booléenne 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 depuis l'appareil, au lieu de nécessiter un téléchargement depuis un service distant.
Catégorie (facultatif)
CATEGORY_OPENABLE
Pour renvoyer uniquement les fichiers "ouverts" pouvant être représentés sous forme de flux de fichiers avec openFileDescriptor().

Exemple d'intent 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 afficher 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 supports OpenableColumns
             and ContentResolver.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, à l'aide de l'action ACTION_GET_CONTENT, si vous exécutez Android 4.4 ou version ultérieure, vous pouvez 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'intent ACTION_CREATE_DOCUMENT permet aux utilisateurs de choisir l'emplacement où ils souhaitent créer un document, comme dans une autre application qui gère le stockage du document. Votre application reçoit ensuite l'emplacement URI de l'emplacement d'écriture du 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 en tant qu'URI content: reposant sur 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, également é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'intent, 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 une valeur nulle et vous devez 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. Si nécessaire, vous pouvez spécifier plusieurs types MIME en ajoutant un tableau de types MIME avec l'extra EXTRA_MIME_TYPES. Dans ce cas, vous devez définir le type MIME principal dans setType() sur "*/*".

Action
ACTION_OPEN_DOCUMENT ou
ACTION_CREATE_DOCUMENT
Schéma de l'URI de données
Aucune
Type MIME
Type MIME correspondant au type de fichier que l'utilisateur doit sélectionner.
Extras
EXTRA_MIME_TYPES
Tableau des 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
Valeur booléenne 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 depuis l'appareil, au lieu de nécessiter un téléchargement depuis un service distant.
Catégorie
CATEGORY_OPENABLE
Pour renvoyer uniquement les fichiers "ouverts" pouvant être représentés sous forme de flux de fichiers avec openFileDescriptor().

Exemple d'intent 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 cet intent 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 illustré 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 autoriser l'ouverture des fichiers gérés par votre application à partir d'autres applications, consultez Ouvrir des fichiers à l'aide du framework d'accès au stockage.

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

Commandes vocales Google

  • "Prends-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 la confirmation de l'utilisateur avant d'effectuer cette action.

Action
ACTION_RESERVE_TAXI_RESERVATION
URI de données
Aucune
Type MIME
Aucune
Extras
Aucun

Exemple d'intent:

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 dans 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 de l'URI de données
geo:latitude,longitude
Afficher la carte à la longitude et à la latitude données

Exemple : "geo:47.6,-122.3"

geo:latitude,longitude?z=zoom
Afficher la carte à la longitude et à la latitude données, à un certain niveau de zoom Un niveau de zoom de 1 affiche la Terre entière, centrée à la position lat,lng donnée. 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)
Afficher 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
Affichez le lieu correspondant à "mon adresse postale", qui peut être une adresse spécifique ou une requête de lieu.

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îne 1st & Pike, Seattle devient 1st%20%26%20Pike%2C%20Seattle. Dans la chaîne, les espaces sont encodés avec %20 ou remplacés par le signe plus (+).

Type MIME
Aucun

Exemple d'intent:

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 musicales et vidéo, 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.

Lire un fichier multimédia

Pour lire un fichier musical, utilisez l'action ACTION_VIEW et spécifiez l'emplacement de l'URI du fichier dans les données d'intent.

Action
ACTION_VIEW
Schéma de l'URI de données
file:<URI>
content:<URI>
http:<URL>
Type MIME
"audio/*"
"application/ogg"
"application/x-ogg"
"application/itunes"
Ou tout autre élément requis par votre application.

Exemple d'intent:

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>

Lire de la musique en fonction d'une requête de recherche

Commandes vocales Google

  • "jouer à michael jackson blie jean"

Pour écouter de la musique en fonction d'une requête de recherche, utilisez l'intent INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH. Une application peut déclencher cet intent en réponse à la commande vocale de l'utilisateur concernant la lecture de musique. L'application réceptrice de cet intent effectue une recherche dans son inventaire pour faire correspondre le contenu existant à la requête donnée et commence à lire ce contenu.

Dans cet intent, incluez l'extra de chaîne EXTRA_MEDIA_FOCUS qui spécifie le mode de recherche souhaité. Par exemple, le mode de recherche peut spécifier si la recherche porte sur un nom d'artiste ou de chanson.

Action
INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH
Schéma de l'URI de données
Aucune
Type MIME
Aucune
Extras
MediaStore.EXTRA_MEDIA_FOCUS (obligatoire)

Indique le mode de recherche, c'est-à-dire si l'utilisateur recherche un artiste, un album, un titre ou une playlist en particulier. La plupart des modes de recherche nécessitent des options supplémentaires. Par exemple, si l'utilisateur souhaite écouter une chanson spécifique, l'intent peut avoir trois extras supplémentaires : le titre de la chanson, l'artiste et l'album. Cet intent est compatible avec les modes de recherche suivants pour chaque valeur de EXTRA_MEDIA_FOCUS:

N'importe lequel"vnd.android.cursor.item/*"

Écoutez n'importe quelle musique. L'application de réception lit de la musique en fonction d'un choix judicieux, comme la dernière playlist écoutée par l'utilisateur.

Autres avantages:

  • QUERY (obligatoire): chaîne vide. Cet extra est toujours fourni pour assurer la rétrocompatibilité. Les applications existantes qui ne connaissent pas les modes de recherche peuvent traiter cet intent comme une recherche non structurée.

Données non structurées"vnd.android.cursor.item/*"

Écouter un titre, un album ou un genre spécifique à 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 parviennent 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 une combinaison quelconque de l'artiste, de l'album, du nom du titre ou du genre.

Genre : Audio.Genres.ENTRY_CONTENT_TYPE

Lire 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 cet intent comme une recherche non structurée.

ArtisteAudio.Artists.ENTRY_CONTENT_TYPE

Écouter la musique d'un artiste en particulier

Autres avantages:

  • EXTRA_MEDIA_ARTIST (obligatoire): l'artiste.
  • "android.intent.extra.genre": genre.
  • QUERY (obligatoire): chaîne contenant une combinaison de l'artiste ou du genre. Cet extra est toujours fourni pour assurer la rétrocompatibilité. Les applications existantes qui ne connaissent pas les modes de recherche peuvent traiter cet intent comme une recherche non structurée.

AlbumAudio.Albums.ENTRY_CONTENT_TYPE

Lire la musique d'un album spécifique

Autres avantages:

  • EXTRA_MEDIA_ALBUM (obligatoire): album.
  • EXTRA_MEDIA_ARTIST: artiste.
  • "android.intent.extra.genre": genre.
  • QUERY (obligatoire): chaîne contenant une combinaison de l'album ou de l'artiste. Cet extra est toujours fourni pour assurer la rétrocompatibilité. Les applications existantes qui ne connaissent pas les modes de recherche peuvent traiter cet intent comme une recherche non structurée.

Titre"vnd.android.cursor.item/audio"

Écouter un titre particulier.

Autres avantages:

  • EXTRA_MEDIA_ALBUM: album
  • EXTRA_MEDIA_ARTIST: artiste.
  • "android.intent.extra.genre": genre.
  • EXTRA_MEDIA_TITLE (obligatoire): nom de la chanson.
  • QUERY (obligatoire): chaîne contenant une combinaison de l'album, de l'artiste, du genre ou du titre. Cet extra est toujours fourni pour assurer la rétrocompatibilité. Les applications existantes qui ne connaissent pas les modes de recherche peuvent traiter cet intent comme une recherche non structurée.

PlaylistAudio.Playlists.ENTRY_CONTENT_TYPE

Lire une playlist spécifique ou une playlist qui correspond à certains critères spécifiés par des éléments 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 une combinaison de l'album, de l'artiste, du genre, de la playlist ou du titre. Cet extra est toujours fourni pour assurer la rétrocompatibilité. Les applications existantes qui ne connaissent pas les modes de recherche peuvent traiter cet intent comme une recherche non structurée.

Exemple d'intent:

Si l'utilisateur souhaite écouter la musique d'un artiste 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'extra EXTRA_MEDIA_FOCUS 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 particulier. 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 éléments supplémentaires suivants.

Remarque:Les applications doivent demander la confirmation de l'utilisateur avant d'effectuer cette action.

Action
ACTION_CREATE_NOTE
Schéma de l'URI de données
Aucune
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.

Exemple d'intent:

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

Lancer un appel est une action courante pour les applications pour téléphone. 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 pour téléphone s'ouvre, elle affiche le numéro de téléphone, et l'utilisateur doit appuyer sur le bouton Call (Appeler) pour démarrer l'appel téléphonique.

Commandes vocales Google

  • "Appeler le 01 23 45 67 89"
  • "Appelle Bob"
  • "appeler la messagerie vocale"

Pour passer directement un appel téléphonique, 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 l'ajout de l'autorisation CALL_PHONE à votre fichier manifeste:

<uses-permission android:name="android.permission.CALL_PHONE" />
Action
  • ACTION_DIAL : ouvre l'application Téléphone ou Téléphone.
  • ACTION_CALL : passe un appel téléphonique (nécessite l'autorisation CALL_PHONE)
Schéma de l'URI de données
  • tel:<phone-number>
  • voicemail:<phone-number>
Type MIME
Aucun

Les numéros de téléphone valides sont ceux définis dans le document RFC 3966 de l'IETF. Voici quelques exemples valides:

  • tel:2125551212
  • tel:(212) 555 1212

Le clavier de l'application Téléphone est efficace pour normaliser des schémas, tels que les numéros de téléphone. Par conséquent, le schéma décrit n'est pas strictement obligatoire dans la méthode Uri.parse(). Toutefois, si vous n'avez pas essayé un schéma ou si vous ne savez pas s'il peut être géré, utilisez plutôt la méthode Uri.fromParts().

Exemple d'intent:

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);
    }
}

Vous trouverez ci-dessous les actions courantes pour les applications de recherche, 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.

Effectuer une recherche à l'aide d'une application spécifique

Commandes vocales Google

  • "recherche des vidéos de chats sur monapplivideo"

Pour permettre 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 profiter de la compatibilité intégrée de l'Assistant Google avec la recherche dans l'application. Pour en savoir plus, consultez la documentation de l'Assistant Google sur les actions dans les applications.

Action
"com.google.android.gms.actions.SEARCH_ACTION"
Prenez en charge les requêtes de recherche provenant des commandes vocales Google.
Extras
QUERY
Chaîne contenant la requête de recherche.

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.

Action
ACTION_WEB_SEARCH
Schéma de l'URI de données
Aucune
Type MIME
Aucune
Extras
SearchManager.QUERY
Chaîne de recherche.

Exemple d'intent:

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 du système lorsque votre application demande à l'utilisateur de modifier quelque chose, utilisez l'une des actions d'intent suivantes:

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 connaître les autres écrans des paramètres disponibles, consultez la documentation de Settings .

Schéma de l'URI de données
Aucune
Type MIME
Aucun

Exemple d'intent:

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);
    }
}

SMS

Dans les applications de messagerie, il est courant de composer un SMS/MMS avec une pièce jointe. 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 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 touches supplémentaires suivantes.

Action
ACTION_SENDTO ou
ACTION_SEND ou
ACTION_SEND_MULTIPLE
Schéma de l'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 pour le message textuel.
EXTRA_STREAM
Uri pointant vers l'image ou la vidéo à joindre. Si vous utilisez l'action ACTION_SEND_MULTIPLE, cet extra est un ArrayList d'objets Uri pointant vers les images ou les vidéos à joindre.

Exemple d'intent:

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 intent n'est géré que par une application de messagerie et non par d'autres applications de messagerie ou de réseaux sociaux, utilisez l'action ACTION_SENDTO et incluez le schéma de données "smsto:", comme illustré 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 SMS/MMS, vous devez implémenter des filtres d'intent pour plusieurs actions supplémentaires afin d'être disponible comme application de SMS par défaut sur Android 4.4 ou version ultérieure. 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

Commandes vocales Google

  • "ouvre example.com"

Pour ouvrir une page Web, utilisez l'action ACTION_VIEW et spécifiez l'URL Web dans les données d'intent.

Action
ACTION_VIEW
Schéma de l'URI de données
http:<URL>
https:<URL>
Type MIME
"text/plain"
"text/html"
"application/xhtml+xml"
"application/vnd.wap.xhtml+xml"

Exemple d'intent:

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 semblables à celles de votre site Web, incluez un filtre d'intent pour les URL qui renvoient vers votre site Web. Ensuite, si les utilisateurs ont installé votre application, les liens d'e-mails ou d'autres pages Web qui redirigent vers votre site Web ouvrent votre application Android au lieu de votre page Web. Pour en savoir plus, consultez Gérer Android App Links.

À partir d'Android 12 (niveau d'API 31), un intent Web générique ne résout une activité dans votre application que si celle-ci est approuvée pour le domaine spécifique contenu dans cet intent Web. Si votre application n'est pas approuvée pour le domaine, l'intent Web est associé à l'application de navigateur par défaut de l'utilisateur.

Vérifier 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:

  1. Configurez un appareil Android pour le développement ou utilisez un appareil virtuel.
  2. Installez une version de votre application qui gère les intents que vous souhaitez prendre en charge.
  3. Déclencher un intent à l'aide de adb :
    adb shell am start -a <ACTION> -t <MIME_TYPE> -d <DATA> \
      -e <EXTRA_NAME> <EXTRA_VALUE> -n <ACTIVITY>
    

    Par exemple :

    adb shell am start -a android.intent.action.DIAL \
      -d tel:555-5555 -n org.example.MyApp/.MyActivity
    
  4. Si vous définissez les filtres d'intent requis, gérez l'intent.

Pour en savoir plus, consultez la section Émettre des commandes shell.