Intenti comuni

Un intent consente di avviare un'attività in un'altra app descrivendo un'azione che vuoi eseguire, ad esempio "visualizzare una mappa" o "scattare una foto" in un oggetto Intent. Questo tipo di intent è chiamato intent implicito perché non specifica il componente dell'app da avviare, ma specifica un'azione e fornisce alcuni dati con cui eseguire l'azione.

Quando chiami startActivity() o startActivityForResult() e passi agli intent impliciti, il sistema risolve l'intent a un'app in grado di gestire l'intent e avvia l'intent Activity corrispondente. Se più app sono in grado di gestire l'intent, il sistema presenta all'utente una finestra di dialogo per scegliere l'app da utilizzare.

In questa pagina vengono descritti diversi intent impliciti che puoi utilizzare per eseguire azioni comuni, organizzati per tipo di app che gestisce l'intent. Ogni sezione mostra inoltre come creare un filtro di intent per pubblicizzare la capacità della tua app di eseguire l'azione.

Attenzione: se sul dispositivo non ci sono app che possono ricevere un intent implicito, un'app si arresta in modo anomalo quando chiama startActivity(). Per verificare innanzitutto che un'app esista per ricevere l'intent, chiama resolveActivity() sull'oggetto Intent. Se il risultato è diverso da null, esiste almeno un'app in grado di gestire l'intent ed è possibile chiamare startActivity() in sicurezza. Se il risultato è nullo, non utilizzare l'intent e, se possibile, disabilita la funzionalità che richiama l'intent.

Se non sai come creare filtri di intent o di intent, consulta prima l'articolo Filtri per intent e intent.

Per scoprire come attivare gli intent elencati in questa pagina dall'host di sviluppo, consulta la sezione Verificare gli intent con Android Debug Bridge.

Azioni vocali di Google

Azioni vocali di Google attiva alcuni degli intent elencati in questa pagina in risposta a comandi vocali. Per ulteriori informazioni, consulta la sezione Iniziare a utilizzare le azioni vocali di sistema.

Sveglia

Di seguito sono riportate le azioni comuni per le app sveglia, incluse le informazioni necessarie per creare un filtro per intent in modo da pubblicizzare la capacità della tua app di eseguire ogni azione.

Crea una sveglia

Azioni vocali di Google

  • "imposta una sveglia per le 7:00"

Per creare una nuova sveglia, utilizza l'azione ACTION_SET_ALARM e specifica i dettagli della sveglia, come ora e messaggio, usando i seguenti extra.

Nota: solo le ore, i minuti e gli extra dei messaggi sono disponibili in Android 2.3 (livello API 9) e versioni precedenti. Gli altri extra sono disponibili nelle versioni superiori della piattaforma.

Azione
ACTION_SET_ALARM
URI dati
Nessuno
Tipo MIME
Nessuno
Extra
EXTRA_HOUR
L'ora della sveglia.
EXTRA_MINUTES
I minuti della sveglia.
EXTRA_MESSAGE
Un messaggio personalizzato per identificare la sveglia.
EXTRA_DAYS
Un ArrayList che include ogni giorno della settimana in cui viene ripetuta la sveglia. Ogni giorno deve essere dichiarato con un numero intero della classe Calendar, ad esempio MONDAY.

Per una sveglia una tantum, non specificare questo extra.

EXTRA_RINGTONE
Un URI content: che specifica una suoneria da utilizzare per la sveglia o VALUE_RINGTONE_SILENT se non c'è suoneria.

Per utilizzare la suoneria predefinita, non specificare questo extra.

EXTRA_VIBRATE
Un valore booleano che specifica se attivare o meno la vibrazione per questa sveglia.
EXTRA_SKIP_UI
Un valore booleano che specifica se l'app che risponde deve saltare la propria UI quando imposta la sveglia. Se il valore è true, l'app deve bypassare qualsiasi UI di conferma e impostare l'allarme specificato.

Esempio di intenzione:

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

Per richiamare l'intent ACTION_SET_ALARM, la tua app deve avere l'autorizzazione SET_ALARM:

<uses-permission android:name="com.android.alarm.permission.SET_ALARM" />

Esempio di filtro per intent:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.SET_ALARM" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Creare un timer

Azioni vocali di Google

  • "imposta un timer di 5 minuti"

Per creare un timer con conto alla rovescia, utilizza l'azione ACTION_SET_TIMER e specifica i dettagli del timer, come la durata, utilizzando i seguenti extra.

Nota: questo intent è disponibile in Android 4.4 (livello API 19) e versioni successive.

Azione
ACTION_SET_TIMER
URI dati
Nessuno
Tipo MIME
Nessuno
Extra
EXTRA_LENGTH
La durata del timer in secondi.
EXTRA_MESSAGE
Un messaggio personalizzato per identificare il timer.
EXTRA_SKIP_UI
Un valore booleano che specifica se l'app rispondente deve saltare la propria UI durante l'impostazione del timer. Se il valore è true, l'app deve bypassare qualsiasi UI di conferma e avviare il timer specificato.

Esempio di intenzione:

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

Per richiamare l'intent ACTION_SET_TIMER, la tua app deve avere l'autorizzazione SET_ALARM:

<uses-permission android:name="com.android.alarm.permission.SET_ALARM" />

Esempio di filtro per intent:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.SET_TIMER" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Tutte le sveglie

Per visualizzare l'elenco di sveglie, usa l'azione ACTION_SHOW_ALARMS.

Anche se non molte app richiamano questo intent, poiché viene utilizzato principalmente dalle app di sistema, qualsiasi app che si comporta come una sveglia può implementare questo filtro per intent e rispondere mostrando l'elenco di sveglie correnti.

Nota: questo intent è disponibile in Android 4.4 (livello API 19) e versioni successive.

Azione
ACTION_SHOW_ALARMS
URI dati
Nessuno
Tipo MIME
Nessuno

Esempio di filtro per intent:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.SHOW_ALARMS" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Calendar

L'aggiunta di un evento è un'azione comune per le app di calendario. Crea un filtro per intent per pubblicizzare la capacità della tua app di eseguire questa azione utilizzando le informazioni riportate nella sezione seguente.

Aggiungere un evento nel calendario

Per aggiungere un nuovo evento al calendario dell'utente, utilizza l'azione ACTION_INSERT e specifica l'URI dei dati utilizzando Events.CONTENT_URI. Puoi quindi specificare vari dettagli dell'evento utilizzando i seguenti extra.

Azione
ACTION_INSERT
URI dati
Events.CONTENT_URI
Tipo MIME
"vnd.android.cursor.dir/event"
Extra
EXTRA_EVENT_ALL_DAY
Un valore booleano che specifica se si tratta di un evento che dura tutto il giorno.
EXTRA_EVENT_BEGIN_TIME
L'ora di inizio dell'evento (in millisecondi dall'epoca).
EXTRA_EVENT_END_TIME
L'ora di fine dell'evento (in millisecondi dall'epoca).
TITLE
Il titolo dell'evento.
DESCRIPTION
La descrizione dell'evento.
EVENT_LOCATION
Il luogo dell'evento.
EXTRA_EMAIL
Un elenco di indirizzi email separati da virgole in cui sono specificati gli invitati.

È possibile specificare molti altri dettagli dell'evento utilizzando le costanti definite nella classe CalendarContract.EventsColumns.

Esempio di intenzione:

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

Esempio di filtro per 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>

Fotocamera

Di seguito sono riportate le azioni comuni eseguite dalle app della fotocamera, incluse le informazioni necessarie per creare un filtro per intent in modo da pubblicizzare la capacità della tua app di eseguire ogni azione.

Acquisisci un'immagine o un video e restituiscili

Per aprire un'app Fotocamera e ricevere la foto o il video risultante, utilizza l'azione ACTION_IMAGE_CAPTURE o ACTION_VIDEO_CAPTURE. Specifica anche la posizione dell'URI in cui vuoi che la fotocamera salvi la foto o il video, nell' EXTRA_OUTPUT aggiuntivo.

Azione
ACTION_IMAGE_CAPTURE oppure
ACTION_VIDEO_CAPTURE
Schema dell'URI dei dati
Nessuno
Tipo MIME
Nessuno
Extra
EXTRA_OUTPUT
La posizione URI in cui l'app Fotocamera salva il file di foto o video (come oggetto Uri).

Quando l'app Fotocamera reimposta correttamente lo stato attivo sulla tua attività, in altre parole, l'app riceve il callback onActivityResult(), puoi accedere alla foto o al video all'URI specificato con il valore EXTRA_OUTPUT.

Nota: quando utilizzi ACTION_IMAGE_CAPTURE per scattare una foto, la fotocamera potrebbe anche restituire una copia ridimensionata o una miniatura della foto nel risultato Intent, salvata come Bitmap in un campo aggiuntivo denominato "data".

Esempio di intenzione:

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.
        ...
    }
}

Per farlo quando lavori su Android 12 (livello API 31) o versioni successive, fai riferimento all'esempio di intent che segue.

Esempio di intenzione:

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>

Per ulteriori informazioni su come utilizzare questo intent per scattare una foto, ad esempio come creare un Uri appropriato per la posizione di output, consulta Scattare foto o Scattare video.

Esempio di filtro per intent:

<activity ...>
    <intent-filter>
        <action android:name="android.media.action.IMAGE_CAPTURE" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Quando gestisci questo intent, fai in modo che la tua attività controlli l'elemento EXTRA_OUTPUT in più nell'elemento Intent in arrivo, quindi salva l'immagine o il video acquisiti nella posizione specificata dall'elemento aggiuntivo e chiama setResult() con un Intent che include una miniatura compressa in un elemento extra denominato "data".

Avvia un'app Fotocamera in modalità immagine fissa

Azioni vocali di Google

  • "scatta una foto"

Per aprire un'app della fotocamera in modalità immagine fissa, usa l'azione INTENT_ACTION_STILL_IMAGE_CAMERA.

Azione
INTENT_ACTION_STILL_IMAGE_CAMERA
Schema dell'URI dei dati
Nessuno
Tipo MIME
Nessuno
Extra
Nessuno

Esempio di intenzione:

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

Esempio di filtro per intent:

<activity ...>
    <intent-filter>
        <action android:name="android.media.action.STILL_IMAGE_CAMERA" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Avvia un'app della fotocamera in modalità video

Azioni vocali di Google

  • "registra un video"

Per aprire un'app della fotocamera in modalità video, usa l'azione INTENT_ACTION_VIDEO_CAMERA.

Azione
INTENT_ACTION_VIDEO_CAMERA
Schema dell'URI dei dati
Nessuno
Tipo MIME
Nessuno
Extra
Nessuno

Esempio di intenzione:

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

Esempio di filtro per intent:

<activity ...>
    <intent-filter>
        <action android:name="android.media.action.VIDEO_CAMERA" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

App per contatti/persone

Di seguito sono riportate le azioni comuni per le app di gestione dei contatti, incluse le informazioni necessarie per creare un filtro per intent in modo da pubblicizzare la capacità dell'app di eseguire ogni azione.

Seleziona un contatto

Per fare in modo che l'utente selezioni un contatto e fornire alla tua app l'accesso a tutte le informazioni di contatto, utilizza l'azione ACTION_PICK e specifica il tipo MIME in Contacts.CONTENT_TYPE.

Il risultato Intent consegnato al callback onActivityResult() contiene l'URI content: che rimanda al contatto selezionato. La risposta concede all'app le autorizzazioni temporanee alla lettura del contatto utilizzando l'API Contacts Provider, anche se la tua app non include l'autorizzazione READ_CONTACTS.

Suggerimento: se hai bisogno di accedere solo a un dato di contatto, ad esempio un numero di telefono o un indirizzo email, consulta la sezione successiva su come selezionare dati di contatto specifici.

Azione
ACTION_PICK
Schema dell'URI dei dati
Nessuno
Tipo MIME
Contacts.CONTENT_TYPE

Esempio di intenzione:

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.
        ...
    }
}

Per informazioni su come recuperare i dettagli di contatto una volta ottenuto l'URI del contatto, consulta Recuperare i dettagli di un contatto.

Quando recuperi l'URI del contatto utilizzando questo intent, in genere non è necessaria l'autorizzazione READ_CONTACTS per leggere i dettagli di base del contatto, come il nome visualizzato e se il contatto è stato aggiunto a Speciali. Tuttavia, se vuoi leggere dati più specifici su un determinato contatto, ad esempio il numero di telefono o l'indirizzo email, devi avere l'autorizzazione READ_CONTACTS.

Seleziona dati di contatto specifici

Per fare in modo che l'utente selezioni un'informazione specifica di un contatto, ad esempio un numero di telefono, un indirizzo email o un altro tipo di dati, utilizza l'azione ACTION_PICK e specifica il tipo MIME in uno dei seguenti tipi di contenuti, ad esempio CommonDataKinds.Phone.CONTENT_TYPE, per ottenere il numero di telefono del contatto.

Nota: in molti casi, l'app deve disporre dell'autorizzazione READ_CONTACTS per visualizzare informazioni specifiche su un determinato contatto.

Se devi recuperare un solo tipo di dati da un contatto, questa tecnica con CONTENT_TYPE delle classi ContactsContract.CommonDataKinds è più efficiente rispetto all'utilizzo di Contacts.CONTENT_TYPE, come mostrato nella sezione precedente. Il risultato ti consente di accedere direttamente ai dati desiderati senza che tu debba eseguire una query più complessa al provider di contatti.

Il risultato Intent consegnato al callback onActivityResult() contiene l'URI content: che rimanda ai dati di contatto selezionati. La risposta concede all'app le autorizzazioni temporanee per leggere i dati dei contatti, anche se l'app non include l'autorizzazione READ_CONTACTS.

Azione
ACTION_PICK
Schema dell'URI dei dati
Nessuno
Tipo MIME
CommonDataKinds.Phone.CONTENT_TYPE
Scegli dai contatti con un numero di telefono.
CommonDataKinds.Email.CONTENT_TYPE
Scegli dai contatti con un indirizzo email.
CommonDataKinds.StructuredPostal.CONTENT_TYPE
Scegli tra i contatti con un indirizzo postale.

O uno dei molti altri valori CONTENT_TYPE in ContactsContract.

Esempio di intenzione:

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.
            //...
        }
    }
}

Visualizzare un contatto

Per visualizzare i dettagli di un contatto noto, utilizza l'azione ACTION_VIEW e specifica il contatto con un URI content: come dati sull'intent.

Esistono due modi principali per recuperare inizialmente l'URI del contatto:

  • Utilizza l'URI di contatto restituito dall'azione ACTION_PICK mostrata nella sezione precedente. Questo approccio non richiede alcuna autorizzazione app.
  • Accedi direttamente all'elenco di tutti i contatti, come descritto in Recuperare un elenco di contatti. Questo approccio richiede l'autorizzazione READ_CONTACTS.
Azione
ACTION_VIEW
Schema dell'URI dei dati
content:<URI>
Tipo MIME
Nessuno. Il tipo viene dedotto dall'URI del contatto.

Esempio di intenzione:

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

Modificare un contatto esistente

Per modificare un contatto noto, utilizza l'azione ACTION_EDIT, specifica il contatto con un URI content: come dati sull'intent e includi eventuali informazioni di contatto note negli extra specificati dalle costanti in ContactsContract.Intents.Insert.

Esistono due modi principali per recuperare inizialmente l'URI del contatto:

  • Utilizza l'URI di contatto restituito dall'azione ACTION_PICK mostrata nella sezione precedente. Questo approccio non richiede alcuna autorizzazione app.
  • Accedi direttamente all'elenco di tutti i contatti, come descritto in Recuperare un elenco di contatti. Questo approccio richiede l'autorizzazione READ_CONTACTS.
Azione
ACTION_EDIT
Schema dell'URI dei dati
content:<URI>
Tipo MIME
Il tipo viene dedotto dall'URI del contatto.
Extra
Uno o più degli extra definiti in ContactsContract.Intents.Insert per permetterti di compilare i campi dei dettagli di contatto.

Esempio di intenzione:

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

Per ulteriori informazioni su come modificare un contatto, leggi Modificare i contatti utilizzando gli intent.

Inserisci un contatto

Per inserire un nuovo contatto, utilizza l'azione ACTION_INSERT, specifica Contacts.CONTENT_TYPE come tipo MIME e includi eventuali informazioni di contatto note negli extra specificati dalle costanti in ContactsContract.Intents.Insert.

Azione
ACTION_INSERT
Schema dell'URI dei dati
Nessuno
Tipo MIME
Contacts.CONTENT_TYPE
Extra
Uno o più dei servizi extra definiti in ContactsContract.Intents.Insert.

Esempio di intenzione:

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

Per ulteriori informazioni su come inserire un contatto, leggi Modificare i contatti utilizzando gli intent.

Email

La scrittura di un'email con allegati facoltativi è un'azione comune per le app email. Crea un filtro per intent per pubblicizzare la capacità della tua app di eseguire questa azione utilizzando le informazioni riportate nella sezione seguente.

Scrivere un'email con allegati facoltativi

Per scrivere un'email, esegui una delle azioni seguenti, a seconda che tu includa o meno gli allegati, e includi i dettagli dell'email, come il destinatario e l'oggetto, usando le chiavi aggiuntive elencate.

Azione
ACTION_SENDTO (per nessun allegato) o
ACTION_SEND (per un allegato) o
ACTION_SEND_MULTIPLE (per più allegati)
Schema dell'URI dei dati
Nessuno
Tipo MIME
"text/plain"
"*/*"
Extra
Intent.EXTRA_EMAIL
Un array di stringhe di tutti gli indirizzi email dei destinatari indicati nel campo "A".
Intent.EXTRA_CC
Un array di stringhe di tutti gli indirizzi email dei destinatari in "Cc".
Intent.EXTRA_BCC
Un array di stringhe di tutti gli indirizzi email dei destinatari in "Ccn".
Intent.EXTRA_SUBJECT
Una stringa con l'oggetto dell'email.
Intent.EXTRA_TEXT
Una stringa con il corpo dell'email.
Intent.EXTRA_STREAM
Un Uri che rimanda all'allegato. Se utilizzi l'azione ACTION_SEND_MULTIPLE, si tratta di un ArrayList contenente più oggetti Uri.

Esempio di intenzione:

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

Se vuoi assicurarti che il tuo intent sia gestito solo da un'app email e non da un'app di messaggistica di testo o social, utilizza l'azione ACTION_SENDTO e includi lo schema di dati "mailto:" come mostrato nell'esempio seguente:

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

Esempio di filtro per 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>

Archivio file

Di seguito sono riportate le azioni comuni eseguite dalle app di archiviazione file, incluse le informazioni necessarie per creare un filtro per intent in modo da pubblicizzare la capacità della tua app di eseguire ogni azione.

Recupera un tipo specifico di file

Per richiedere all'utente di selezionare un file, ad esempio un documento o una foto, e restituire un riferimento alla tua app, utilizza l'azione ACTION_GET_CONTENT e specifica il tipo MIME desiderato. Il riferimento al file restituito all'app è temporaneo al ciclo di vita attuale dell'attività, quindi se vuoi accedervi in seguito devi importare una copia che potrai leggere in seguito.

Questo intent consente inoltre all'utente di creare un nuovo file durante il processo. Ad esempio, invece di selezionare una foto esistente, l'utente può scattare una nuova foto con la fotocamera.

L'intent risultato consegnato al tuo metodo onActivityResult() include dati con un URI che rimanda al file. L'URI può essere qualsiasi cosa, ad esempio un URI http:, un URI file: o un URI content:. Tuttavia, se vuoi limitare i file selezionabili solo a quelli accessibili da un fornitore di contenuti (un URI content:) e che sono disponibili come stream di file con openFileDescriptor(), aggiungi la categoria CATEGORY_OPENABLE al tuo intent.

Su Android 4.3 (livello API 18) e versioni successive, puoi anche consentire all'utente di selezionare più file aggiungendo EXTRA_ALLOW_MULTIPLE all'intent, impostato su true. Puoi quindi accedere a ciascuno dei file selezionati in un oggetto ClipData restituito da getClipData().

Azione
ACTION_GET_CONTENT
Schema dell'URI dei dati
Nessuno
Tipo MIME
Il tipo MIME corrispondente al tipo di file che l'utente deve selezionare.
Extra
EXTRA_ALLOW_MULTIPLE
Un valore booleano che dichiara se l'utente può selezionare più di un file alla volta.
EXTRA_LOCAL_ONLY
Un valore booleano che dichiara se il file restituito deve essere disponibile direttamente dal dispositivo, anziché richiedere un download da un servizio remoto.
Categoria (facoltativa)
CATEGORY_OPENABLE
Per restituire solo file "apribili" che possono essere rappresentati come uno stream di file con openFileDescriptor().

Esempio di intenzione per ottenere una foto:

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.
        ...
    }
}

Esempio di filtro per intent per restituire una foto:

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

Aprire un tipo di file specifico

Utilizzando l'azione ACTION_GET_CONTENT su Android 4.4 o versioni successive, anziché recuperare una copia di un file che devi importare nell'app, puoi richiedere di aprire un file gestito da un'altra app utilizzando l'azione ACTION_OPEN_DOCUMENT e specificando un tipo MIME. Per consentire all'utente di creare un nuovo documento in cui la tua app può scrivere, utilizza invece l'azione ACTION_CREATE_DOCUMENT.

Ad esempio, invece di selezionare da documenti PDF esistenti, l'intent ACTION_CREATE_DOCUMENT consente agli utenti di scegliere dove creare un nuovo documento, ad esempio all'interno di un'altra app che gestisce lo spazio di archiviazione del documento. L'app riceve quindi la posizione dell'URI in cui può scrivere il nuovo documento.

Mentre l'intent fornito al tuo metodo onActivityResult() dall'azione ACTION_GET_CONTENT potrebbe restituire un URI di qualsiasi tipo, l'intent risultato di ACTION_OPEN_DOCUMENT e ACTION_CREATE_DOCUMENT specificano sempre il file scelto come URI content: supportato da DocumentsProvider. Puoi aprire il file con openFileDescriptor() ed eseguire query sui relativi dettagli utilizzando le colonne di DocumentsContract.Document.

L'URI restituito concede alla tua app l'accesso in lettura a lungo termine al file, anche con accesso in scrittura. L'azione ACTION_OPEN_DOCUMENT è particolarmente utile quando vuoi leggere un file esistente senza crearne una copia nella tua app o quando vuoi aprire e modificare un file esistente.

Puoi anche consentire all'utente di selezionare più file aggiungendo EXTRA_ALLOW_MULTIPLE all'intent, impostato su true. Se l'utente seleziona un solo elemento, puoi recuperarlo da getData(). Se l'utente seleziona più elementi, getData() restituisce null e devi recuperare ogni elemento da un oggetto ClipData restituito da getClipData().

Nota: il tuo intent deve specificare un tipo MIME e deve dichiarare la categoria CATEGORY_OPENABLE. Se opportuno, puoi specificare più di un tipo MIME aggiungendo un array di tipi MIME con EXTRA_MIME_TYPES in più: in questo caso, devi impostare il tipo MIME principale in setType() su "*/*".

Azione
ACTION_OPEN_DOCUMENT oppure
ACTION_CREATE_DOCUMENT
Schema dell'URI dei dati
Nessuno
Tipo MIME
Il tipo MIME corrispondente al tipo di file che l'utente deve selezionare.
Extra
EXTRA_MIME_TYPES
Un array di tipi MIME corrispondenti ai tipi di file richiesti dalla tua app. Quando utilizzi questo extra, devi impostare il tipo MIME principale in setType() su "*/*".
EXTRA_ALLOW_MULTIPLE
Un valore booleano che dichiara se l'utente può selezionare più di un file alla volta.
EXTRA_TITLE
Da utilizzare con ACTION_CREATE_DOCUMENT per specificare un nome file iniziale.
EXTRA_LOCAL_ONLY
Un valore booleano che dichiara se il file restituito deve essere disponibile direttamente dal dispositivo, anziché richiedere un download da un servizio remoto.
Categoria
CATEGORY_OPENABLE
Per restituire solo file "apribili" che possono essere rappresentati come uno stream di file con openFileDescriptor().

Esempio di intenzione per ottenere una foto:

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.
        ...
    }
}

Le app di terze parti non possono rispondere a un intent con l'azione ACTION_OPEN_DOCUMENT. Il sistema riceve invece questo intent e visualizza tutti i file disponibili da varie app in un'interfaccia utente unificata.

Per fornire i file della tua app in questa UI e consentire ad altre app di aprirli, devi implementare DocumentsProvider e includere un filtro per intent per PROVIDER_INTERFACE ("android.content.action.DOCUMENTS_PROVIDER"), come mostrato nell'esempio seguente:

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

Per ulteriori informazioni su come rendere i file gestiti dalla tua app apribili da altre app, vedi Aprire i file utilizzando Storage Access Framework.

Azioni locali

Chiamare un'auto è un'azione comune a livello locale. Crea un filtro per intent per pubblicizzare la capacità della tua app di eseguire questa azione utilizzando le informazioni riportate nella sezione seguente.

Chiama un taxi

Azioni vocali di Google

  • "prendimi un taxi"
  • "chiamami un'auto"

(Solo Wear OS)

Per chiamare un taxi, utilizza l'azione ACTION_RESERVE_TAXI_RESERVATION.

Nota: le app devono chiedere la conferma all'utente prima di completare questa azione.

Azione
ACTION_RESERVE_TAXI_RESERVATION
URI dati
Nessuno
Tipo MIME
Nessuno
Extra
Nessuno

Esempio di intenzione:

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

Esempio di filtro per 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

Mostrare una posizione su una mappa è un'azione comune per le app sulle mappe. Crea un filtro per intent per pubblicizzare la capacità della tua app di eseguire questa azione utilizzando le informazioni riportate nella sezione seguente.

Mostra una posizione su una mappa

Per aprire una mappa, utilizza l'azione ACTION_VIEW e specifica le informazioni sulla posizione nei dati sull'intent con uno dei seguenti schemi.

Azione
ACTION_VIEW
Schema dell'URI dei dati
geo:latitude,longitude
Mostra la mappa alla longitudine e alla latitudine specificate.

Esempio: "geo:47.6,-122.3"

geo:latitude,longitude?z=zoom
Mostra la mappa alla longitudine e alla latitudine specificate a un determinato livello di zoom. Un livello di zoom pari a 1 mostra l'intera Terra, centrata nel valore lat,lng specificato. Il livello di zoom più alto (più vicino) è 23.

Esempio: "geo:47.6,-122.3?z=11"

geo:0,0?q=lat,lng(label)
Mostra la mappa alla longitudine e alla latitudine specificate con un'etichetta stringa.

Esempio: "geo:0,0?q=34.99,-106.61(Treasure)"

geo:0,0?q=my+street+address
Mostra la località relativa a "la mia via", che può essere un indirizzo specifico o una query sulla posizione.

Esempio: "geo:0,0?q=1600+Amphitheatre+Parkway%2C+CA"

Nota: tutte le stringhe passate nell'URI geo devono essere codificate. Ad esempio, la stringa 1st & Pike, Seattle diventa 1st%20%26%20Pike%2C%20Seattle. Gli spazi nella stringa sono codificati con %20 o sostituiti con il segno più (+).

Tipo MIME
Nessuno

Esempio di intenzione:

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

Esempio di filtro per 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>

Musica o video

Di seguito sono riportate le azioni comuni per le app di musica e video, incluse le informazioni necessarie per creare un filtro per intent in modo da pubblicizzare la capacità dell'app di eseguire ogni azione.

Riprodurre un file multimediale

Per riprodurre un file musicale, utilizza l'azione ACTION_VIEW e specifica la posizione URI del file nei dati dell'intent.

Azione
ACTION_VIEW
Schema dell'URI dei dati
file:<URI>
content:<URI>
http:<URL>
Tipo MIME
"audio/*"
"application/ogg"
"application/x-ogg"
"application/itunes"
O qualsiasi altra richiesta dalla tua app.

Esempio di intenzione:

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

Esempio di filtro per 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>

Riprodurre musica in base a una query di ricerca

Azioni vocali di Google

  • "fammi sentire michael jackson billie jean"

Per riprodurre musica in base a una query di ricerca, utilizza l'intent INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH. Un'app potrebbe attivare questo intent in risposta al comando vocale dell'utente di riprodurre musica. L'app ricevente per questa finalità esegue una ricerca all'interno del suo inventario per trovare corrispondenze tra i contenuti esistenti e la query specificata e avvia la riproduzione di tali contenuti.

In questo intent, includi la stringa EXTRA_MEDIA_FOCUS extra, che specifica la modalità di ricerca prevista. Ad esempio, la modalità di ricerca può specificare se la ricerca riguarda il nome di un artista o di un brano.

Azione
INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH
Schema dell'URI dei dati
Nessuno
Tipo MIME
Nessuno
Extra
MediaStore.EXTRA_MEDIA_FOCUS (obbligatorio)

Indica la modalità di ricerca: se l'utente sta cercando un artista, un album, un brano o una playlist in particolare. La maggior parte delle modalità di ricerca richiede ulteriori opzioni. Ad esempio, se l'utente è interessato ad ascoltare un determinato brano, l'intent potrebbe avere tre extra aggiuntivi: il titolo del brano, l'artista e l'album. Questo intent supporta le seguenti modalità di ricerca per ogni valore di EXTRA_MEDIA_FOCUS:

Qualsiasi: "vnd.android.cursor.item/*"

Riproduci qualsiasi brano musicale. L'app ricevente riproduce alcuni brani in base a una scelta intelligente, ad esempio l'ultima playlist ascoltata dall'utente.

Ulteriori extra:

  • QUERY (obbligatorio): una stringa vuota. Questo extra è sempre fornito per garantire la compatibilità con le versioni precedenti. Le app esistenti che non conoscono le modalità di ricerca possono elaborare questo intento come ricerca non strutturata.

Non strutturati - "vnd.android.cursor.item/*"

Riprodurre un brano, un album o un genere specifico da una query di ricerca non strutturata. Le app possono generare un intent con questa modalità di ricerca quando non sono in grado di identificare il tipo di contenuti che l'utente vuole ascoltare. Se possibile, utilizza modalità di ricerca più specifiche.

Ulteriori extra:

  • QUERY (obbligatorio): una stringa contenente qualsiasi combinazione di artista, album, titolo del brano o genere.

Genere - Audio.Genres.ENTRY_CONTENT_TYPE

Riprodurre musica di un genere particolare.

Ulteriori extra:

  • "android.intent.extra.genre" (obbligatorio): il genere.
  • QUERY (obbligatorio): il genere. Questo extra è sempre fornito per la compatibilità con le versioni precedenti. Le app esistenti che non conoscono le modalità di ricerca possono elaborare questo intento come ricerca non strutturata.

Artista - Audio.Artists.ENTRY_CONTENT_TYPE

Ascoltare musica di un determinato artista.

Ulteriori extra:

  • EXTRA_MEDIA_ARTIST (obbligatorio): l'artista.
  • "android.intent.extra.genre": il genere.
  • QUERY (obbligatorio): una stringa contenente qualsiasi combinazione dell'artista o del genere. Questo extra è sempre fornito per la compatibilità con le versioni precedenti. Le app esistenti che non conoscono le modalità di ricerca possono elaborare questo intent come ricerca non strutturata.

Album - Audio.Albums.ENTRY_CONTENT_TYPE

Riprodurre musica di un album specifico.

Ulteriori extra:

  • EXTRA_MEDIA_ALBUM (obbligatorio): l'album.
  • EXTRA_MEDIA_ARTIST: l'artista.
  • "android.intent.extra.genre": il genere.
  • QUERY (obbligatorio): una stringa contenente qualsiasi combinazione dell'album o dell'artista. Questo extra è sempre fornito per garantire la compatibilità con le versioni precedenti. Le app esistenti che non conoscono le modalità di ricerca possono elaborare questo intent come ricerca non strutturata.

Brano - "vnd.android.cursor.item/audio"

Riproduci una canzone specifica.

Ulteriori extra:

  • EXTRA_MEDIA_ALBUM: l'album.
  • EXTRA_MEDIA_ARTIST: l'artista.
  • "android.intent.extra.genre": il genere.
  • EXTRA_MEDIA_TITLE (obbligatorio): il nome del brano.
  • QUERY (obbligatorio): una stringa contenente qualsiasi combinazione di album, artista, genere o titolo. Questo extra è sempre fornito per garantire la compatibilità con le versioni precedenti. Le app esistenti che non conoscono le modalità di ricerca possono elaborare questo intento come ricerca non strutturata.

Playlist - Audio.Playlists.ENTRY_CONTENT_TYPE

Riprodurre una playlist particolare o una playlist che soddisfi alcuni criteri specificati da extra.

Ulteriori extra:

  • EXTRA_MEDIA_ALBUM: l'album.
  • EXTRA_MEDIA_ARTIST: l'artista.
  • "android.intent.extra.genre": il genere.
  • "android.intent.extra.playlist": la playlist.
  • EXTRA_MEDIA_TITLE: il nome del brano su cui si basa la playlist.
  • QUERY (obbligatorio): una stringa contenente qualsiasi combinazione di album, artista, genere, playlist o titolo. Questo extra è sempre fornito per garantire la compatibilità con le versioni precedenti. Le app esistenti che non conoscono le modalità di ricerca possono elaborare questo intento come ricerca non strutturata.

Esempio di intenzione:

Se l'utente vuole ascoltare la musica di un determinato artista, un'app di ricerca potrebbe generare il seguente intento:

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

Esempio di filtro per intent:

<activity ...>
    <intent-filter>
        <action android:name="android.media.action.MEDIA_PLAY_FROM_SEARCH" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Quando gestisci questo intent nella tua attività, controlla il valore dell'elemento EXTRA_MEDIA_FOCUS extra nell'elemento Intent in arrivo per determinare la modalità di ricerca. Una volta che l'attività ha identificato la modalità di ricerca, leggi i valori degli extra aggiuntivi per quella specifica modalità di ricerca. Con queste informazioni, la tua app può quindi eseguire una ricerca all'interno del suo inventario per riprodurre i contenuti corrispondenti alla query di ricerca. Questa situazione è illustrata nell'esempio seguente.

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

Nuova nota

La creazione di una nota è un'azione comune nelle app per creare note. Crea un filtro per intent per pubblicizzare la capacità della tua app di eseguire questa azione utilizzando le informazioni riportate nella sezione seguente.

Creare una nota

Per creare una nuova nota, utilizza l'azione ACTION_CREATE_NOTE e specifica i dettagli della nota, come l'oggetto e il testo, utilizzando i seguenti extra.

Nota: le app devono chiedere la conferma all'utente prima di completare questa azione.

Azione
ACTION_CREATE_NOTE
Schema dell'URI dei dati
Nessuno
Tipo MIME
PLAIN_TEXT_TYPE
"*/*"
Extra
EXTRA_NAME
Una stringa che indica il titolo o l'oggetto della nota.
EXTRA_TEXT
Una stringa che indica il testo della nota.

Esempio di intenzione:

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

Esempio di filtro per 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>

Telefono

L'avvio di una chiamata è un'azione comune per le app per smartphone. Crea un filtro per intent per pubblicizzare la capacità della tua app di eseguire questa azione utilizzando le informazioni riportate nella sezione seguente.

Avvio di una telefonata

Per aprire l'app Telefono e comporre un numero di telefono, utilizza l'azione ACTION_DIAL e specifica un numero di telefono utilizzando il seguente schema URI. All'apertura dell'app Telefono viene visualizzato il numero di telefono e l'utente deve toccare il pulsante Chiama per iniziare la telefonata.

Azioni vocali di Google

  • "chiama il 310 5555"
  • "chiama bruno"
  • "chiama segreteria"

Per effettuare direttamente una chiamata, utilizza l'azione ACTION_CALL e specifica un numero di telefono utilizzando il seguente schema URI. All'apertura dell'app Telefono, la telefonata inizia. L'utente non deve necessariamente toccare il pulsante Chiama.

L'azione ACTION_CALL richiede l'aggiunta dell'autorizzazione CALL_PHONE al file manifest:

<uses-permission android:name="android.permission.CALL_PHONE" />
Azione
  • ACTION_DIAL: consente di aprire l'app Telefono o Telefono.
  • ACTION_CALL: effettua una telefonata (richiede l'autorizzazione CALL_PHONE)
Schema dell'URI dei dati
  • tel:<phone-number>
  • voicemail:<phone-number>
Tipo MIME
Nessuno

I numeri di telefono validi sono quelli definiti nel documento RFC 3966 di IETF. Ecco alcuni esempi validi:

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

La tastiera dell'app Telefono è in grado di normalizzare gli schemi, ad esempio i numeri di telefono. Pertanto, lo schema descritto non è strettamente obbligatorio nel metodo Uri.parse(). Tuttavia, se non hai provato uno schema o se non hai la certezza che possa essere gestito, utilizza invece il metodo Uri.fromParts().

Esempio di intenzione:

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

Di seguito sono riportate le azioni comuni per le app di ricerca, incluse le informazioni necessarie per creare un filtro per intent in modo da pubblicizzare la capacità della tua app di eseguire ogni azione.

Cerca usando un'app specifica

Azioni vocali di Google

  • "cerca video di gatti su myvideoapp"

Per supportare la ricerca nel contesto della tua app, dichiara un filtro per intent nella tua app con l'azione SEARCH_ACTION, come mostrato nell'esempio di filtro per intent che segue.

Nota: non è consigliabile utilizzare SEARCH_ACTION per la ricerca di app. Implementa invece l'azione GET_THING per sfruttare il supporto integrato dell'Assistente Google per la ricerca in-app. Per ulteriori informazioni, consulta la documentazione relativa alle azioni app dell'Assistente Google.

Azione
"com.google.android.gms.actions.SEARCH_ACTION"
Supporta le query di ricerca da Google Voice Actions.
Extra
QUERY
Una stringa contenente la query di ricerca.

Esempio di filtro per 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>

Eseguire una ricerca web

Per avviare una ricerca web, utilizza l'azione ACTION_WEB_SEARCH e specifica la stringa di ricerca nel SearchManager.QUERY extra.

Azione
ACTION_WEB_SEARCH
Schema dell'URI dei dati
Nessuno
Tipo MIME
Nessuno
Extra
SearchManager.QUERY
La stringa di ricerca.

Esempio di intenzione:

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

Impostazioni

Per aprire una schermata nell'app Impostazioni di sistema quando l'app richiede all'utente di apportare modifiche, utilizza una delle seguenti azioni relative agli intent:

Azione
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

Per ulteriori schermate delle impostazioni disponibili, consulta la documentazione di Settings .

Schema dell'URI dei dati
Nessuno
Tipo MIME
Nessuno

Esempio di intenzione:

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

La scrittura di un messaggio SMS/MMS con un allegato è un'azione comune per le app di messaggistica di testo. Crea un filtro per intent per pubblicizzare la capacità della tua app di eseguire questa azione utilizzando le informazioni riportate nella sezione seguente.

Scrivi un messaggio SMS/MMS con allegato

Per avviare un SMS o MMS, utilizza una delle seguenti azioni di intent e specifica i dettagli del messaggio, come numero di telefono, oggetto e corpo del messaggio, utilizzando i seguenti tasti aggiuntivi.

Azione
ACTION_SENDTO oppure
ACTION_SEND o
ACTION_SEND_MULTIPLE
Schema dell'URI dei dati
sms:<phone_number>
smsto:<phone_number>
mms:<phone_number>
mmsto:<phone_number>

Questi schemi vengono gestiti tutti allo stesso modo.

Tipo MIME
"text/plain"
"image/*"
"video/*"
Extra
"subject"
Una stringa per l'oggetto del messaggio (di solito solo per MMS).
"sms_body"
Una stringa per il messaggio.
EXTRA_STREAM
Un Uri che rimanda all'immagine o al video da allegare. Se utilizzi l'azione ACTION_SEND_MULTIPLE, questo extra è un ArrayList di Uri oggetti che punta alle immagini o ai video da allegare.

Esempio di intenzione:

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

Se vuoi assicurarti che l'intent sia gestito solo da un'app di messaggistica e non da altre app email o social, utilizza l'azione ACTION_SENDTO e includi lo schema dati "smsto:", come mostrato nell'esempio seguente:

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

Esempio di filtro per 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>

Nota:se stai sviluppando un'app di messaggistica SMS/MMS, devi implementare i filtri per intent per diverse azioni aggiuntive in modo che siano disponibili come app per SMS predefinita su Android 4.4 e versioni successive. Per saperne di più, consulta la documentazione all'indirizzo Telephony.

Browser web

Il caricamento di un URL web è un'azione comune per le app del browser web. Crea un filtro per intent per pubblicizzare la capacità della tua app di eseguire questa azione utilizzando le informazioni riportate nella sezione seguente.

Carica un URL web

Azioni vocali di Google

  • "apri example.com"

Per aprire una pagina web, usa l'azione ACTION_VIEW e specifica l'URL web nei dati sull'intent.

Azione
ACTION_VIEW
Schema dell'URI dei dati
http:<URL>
https:<URL>
Tipo MIME
"text/plain"
"text/html"
"application/xhtml+xml"
"application/vnd.wap.xhtml+xml"

Esempio di intenzione:

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

Esempio di filtro per 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>

Suggerimento: se la tua app per Android fornisce funzionalità simili al tuo sito web, includi un filtro per intent per gli URL che rimandano al tuo sito web. In seguito, se gli utenti hanno installato la tua app, i link contenuti in email o altre pagine web che rimandano al tuo sito web apriranno la tua app per Android anziché la tua pagina web. Scopri di più nella sezione Gestire i link per app Android.

A partire da Android 12 (livello API 31), un web intent generico si risolve in un'attività nella tua app solo se quest'ultima è approvata per il dominio specifico contenuto in quell'intent web. Se la tua app non viene approvata per il dominio, il web intent si risolve nell'app browser predefinita dell'utente.

Verificare gli intent con Android Debug Bridge

Per verificare che la tua app risponda agli intent che vuoi supportare, puoi utilizzare lo strumento adb per attivare intent specifici come segue:

  1. Configura un dispositivo Android per lo sviluppo o utilizza un dispositivo virtuale.
  2. Installa una versione dell'app che gestisca gli intent che vuoi supportare.
  3. Attiva un intent utilizzando adb:
    adb shell am start -a <ACTION> -t <MIME_TYPE> -d <DATA> \
      -e <EXTRA_NAME> <EXTRA_VALUE> -n <ACTIVITY>
    

    Ecco alcuni esempi:

    adb shell am start -a android.intent.action.DIAL \
      -d tel:555-5555 -n org.example.MyApp/.MyActivity
    
  4. Se definisci i filtri per intent richiesti, gestisci l'intent.

Per maggiori informazioni, consulta Problemi dei comandi della shell.