Un intent ti 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 un intent implicito, il sistema
risolve
l'intent a un'app in grado di gestirlo e avvia il
Activity
corrispondente. Se ci sono più app
in grado di gestire l'intent, il sistema presenta all'utente una finestra di dialogo
per scegliere quale app utilizzare.
In questa pagina vengono descritti diversi intent impliciti che puoi utilizzare per eseguire azioni comuni, organizzate in base al tipo di app che gestisce l'intent. Ogni sezione mostra anche come creare un filtro per intenzione per pubblicizzare la capacità della tua app di eseguire l'azione.
Attenzione:se sul dispositivo non ci sono app in grado di ricevere un intent implicito, un'app ha un arresto anomalo quando chiama startActivity()
. Per verificare innanzitutto che
un'app esista per ricevere l'intent, chiama resolveActivity()
sull'oggetto Intent
. Se il risultato non è null, esiste almeno
un'app in grado di gestire l'intent ed è possibile chiamare startActivity()
. Se il risultato è nullo, non utilizzare l'intent e, se possibile, disabilita la funzionalità che richiama l'intent.
Se non hai dimestichezza con la creazione di intent o filtri per intent, leggi innanzitutto la pagina Intent e filtri per intent.
Per scoprire come attivare gli intent elencati in questa pagina dal tuo 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 ai comandi vocali. Per maggiori informazioni, consulta la Guida introduttiva alle 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 per pubblicizzare la capacità dell'app di eseguire ogni azione.
Crea una sveglia
Per creare una nuova sveglia, utilizza l'azione ACTION_SET_ALARM
e specifica i dettagli della sveglia, come l'ora e il messaggio, usando le opzioni seguenti.
Nota: in Android 2.3 (livello API 9) e versioni precedenti sono disponibili solo i valori extra relativi a ora, minuti e messaggi. Gli altri extra sono disponibili nelle versioni superiori della piattaforma.
- Azione
ACTION_SET_ALARM
- URI dei dati
- Nessuna
- Tipo MIME
- Nessuno
- Extra
-
EXTRA_HOUR
- L'ora della sveglia.
EXTRA_MINUTES
- I minuti per la sveglia.
EXTRA_MESSAGE
- Un messaggio personalizzato per identificare la sveglia.
EXTRA_DAYS
- Un
ArrayList
che include ogni giorno della settimana in cui si ripete la sveglia. Ogni giorno deve essere dichiarato con un numero intero della classeCalendar
, ad esempioMONDAY
.Per una sveglia una tantum, non specificare questo extra.
EXTRA_RINGTONE
- Un URI
content:
che specifica una suoneria da usare con la sveglia oVALUE_RINGTONE_SILENT
per nessuna suoneria.Per utilizzare la suoneria predefinita, non specificare questo extra.
EXTRA_VIBRATE
- Un valore booleano che specifica se vibrare per questa sveglia.
EXTRA_SKIP_UI
- Un valore booleano che specifica se l'app che risponde deve saltare la relativa UI per impostare l'allarme. Se impostato su true, l'app deve bypassare l'interfaccia utente di conferma e impostare l'allarme specificato.
Intenzione di esempio:
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); } }
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>
Creazione di un timer
Per creare un timer con conto alla rovescia, utilizza l'azione ACTION_SET_TIMER
e specifica i dettagli del timer, ad esempio la durata, usando i seguenti extra.
Nota: questo intent è disponibile in Android 4.4 (livello API 19) e versioni successive.
- Azione
ACTION_SET_TIMER
- URI dei dati
- Nessuna
- 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 che risponde o meno deve saltare la relativa UI durante l'impostazione del timer. Se impostato su true, l'app deve ignorare l'interfaccia utente di conferma e avviare il timer specificato.
Intenzione di esempio:
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); } }
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 mostrare l'elenco delle 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 sveglia può implementare questo filtro per intent e rispondere mostrando l'elenco delle sveglie correnti.
Nota: questo intent è disponibile in Android 4.4 (livello API 19) e versioni successive.
- Azione
ACTION_SHOW_ALARMS
- URI dei dati
- Nessuna
- 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>
Calendario
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 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 di dati utilizzando Events.CONTENT_URI
.
Puoi quindi specificare vari dettagli dell'evento utilizzando i seguenti extra.
- Azione
ACTION_INSERT
- URI dei 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 (millisecondi dall'epoca).
EXTRA_EVENT_END_TIME
- L'ora di fine dell'evento (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 che specificano gli invitati.
Puoi specificare molti altri dettagli dell'evento utilizzando le costanti definite nella classe
CalendarContract.EventsColumns
.
Intenzione di esempio:
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 per le app fotocamera, incluse le informazioni necessarie per creare un filtro per intent per pubblicizzare la capacità dell'app di eseguire ogni azione.
Acquisisci una foto o un video e restituiscilo
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
EXTRA_OUTPUT
.
- Azione
ACTION_IMAGE_CAPTURE
oppure
ACTION_VIDEO_CAPTURE
- Schema dell'URI dei dati
- Nessuna
- Tipo MIME
- Nessuna
- 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 restituisce correttamente
la messa a fuoco sull'attività (in altre parole, l'app riceve il callback onActivityResult()
), puoi
accedere alla foto o al video nell'URI specificato
con il valore EXTRA_OUTPUT
.
Nota: quando usi ACTION_IMAGE_CAPTURE
per scattare una foto, la fotocamera potrebbe anche restituire una
copia ridotta o una miniatura della foto nel risultato Intent
, salvata come Bitmap
in un campo aggiuntivo denominato
"data"
.
Intenzione di esempio:
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, consulta l'esempio di intent che segue.
Intenzione di esempio:
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, incluso
come creare un Uri
appropriato per il luogo di output, leggi
Scatta foto o
Registra 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'eventuale presenza di EXTRA_OUTPUT
extra nella Intent
in arrivo, quindi salvi l'immagine o il video acquisito nella posizione specificata dall'elemento aggiuntivo e chiama setResult()
con un Intent
che include una miniatura compressa in un extra denominato "data"
.
Avvia un'app della fotocamera in modalità immagine statica
Per aprire un'app della fotocamera in modalità immagine, usa l'azione INTENT_ACTION_STILL_IMAGE_CAMERA
.
- Azione
INTENT_ACTION_STILL_IMAGE_CAMERA
- Schema dell'URI dei dati
- Nessuna
- Tipo MIME
- Nessuna
- Extra
- Nessuno
Intenzione di esempio:
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
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
- Nessuna
- Tipo MIME
- Nessuna
- Extra
- Nessuno
Intenzione di esempio:
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 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 per pubblicizzare la capacità dell'app di eseguire ogni azione.
Seleziona un contatto
Per fare in modo che l'utente selezioni un contatto e fornisca alla tua app l'accesso a tutti i dati di contatto,
utilizza l'azione ACTION_PICK
e specifica il tipo MIME per
Contacts.CONTENT_TYPE
.
Il risultato Intent
recapitato al callback onActivityResult()
contiene l'URI
content:
che punta al contatto selezionato. La risposta concede
all'app le autorizzazioni temporanee a leggere il contatto utilizzando l'API Provider di contatti, anche se
la tua app non include l'autorizzazione READ_CONTACTS
.
Suggerimento:se hai bisogno di accedere solo a dei dati di contatto specifici, 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
- Nessuna
- Tipo MIME
Contacts.CONTENT_TYPE
Intenzione di esempio:
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 ottenuti l'URI del contatto, consulta Recuperare i dettagli di un contatto.
Quando recuperi l'URI del contatto utilizzando questo intent, in genere non hai bisogno dell'autorizzazione READ_CONTACTS
per leggere i dettagli di base del contatto, ad esempio il nome visualizzato e se il contatto è speciale. Tuttavia, se vuoi leggere dati più specifici su un determinato contatto, ad esempio il numero di telefono o l'indirizzo email, devi disporre dell'autorizzazione READ_CONTACTS
.
Seleziona dati di contatto specifici
Per fare in modo che l'utente selezioni un'informazione specifica da 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 per 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 avere l'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 un CONTENT_TYPE
delle classi ContactsContract.CommonDataKinds
è più efficiente rispetto all'uso di Contacts.CONTENT_TYPE
, come mostrato nella sezione precedente. Il risultato ti fornisce l'accesso diretto ai dati desiderati senza dover eseguire una query più complessa al Provider di contatti.
Il risultato Intent
inviato al callback onActivityResult()
contiene l'URI
content:
che rimanda ai dati di contatto selezionati. La risposta concede alla tua app autorizzazioni temporanee a leggere i dati di contatto anche se l'app non include l'autorizzazione READ_CONTACTS
.
- Azione
ACTION_PICK
- Schema dell'URI dei dati
- Nessuna
- Tipo MIME
-
CommonDataKinds.Phone.CONTENT_TYPE
- Scegli tra i contatti con un numero di telefono.
CommonDataKinds.Email.CONTENT_TYPE
- Scegli tra i contatti con un indirizzo email.
CommonDataKinds.StructuredPostal.CONTENT_TYPE
- Scegli tra i contatti con un indirizzo postale.
Oppure uno dei molti altri valori
CONTENT_TYPE
inContactsContract
.
Intenzione di esempio:
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 dell'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 autorizzazioni 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.
Intenzione di esempio:
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 per l'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 autorizzazioni 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
- Una o più opzioni extra definite in
ContactsContract.Intents.Insert
in modo da poter completare i campi dei dettagli di contatto.
Intenzione di esempio:
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 saperne di più su come modificare un contatto, consulta 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 da
costanti in ContactsContract.Intents.Insert
.
- Azione
ACTION_INSERT
- Schema dell'URI dei dati
- Nessuna
- Tipo MIME
Contacts.CONTENT_TYPE
- Extra
- Uno o più degli extra definiti in
ContactsContract.Intents.Insert
.
Intenzione di esempio:
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 saperne di più su come inserire un contatto, consulta Modificare i contatti utilizzando gli intent.
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 nella sezione seguente.
Scrivere un'email con allegati facoltativi
Per scrivere un'email, esegui una delle seguenti azioni, a seconda se vuoi includere o meno gli allegati, e includi i dettagli dell'email, come il destinatario e l'oggetto, utilizzando 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
- Nessuna
- Tipo MIME
-
"text/plain"
"*/*"
- Extra
-
Intent.EXTRA_EMAIL
- Un array di stringhe di tutti gli indirizzi email dei destinatari "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 "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'azioneACTION_SEND_MULTIPLE
, invece è un elementoArrayList
che contiene più oggettiUri
.
Intenzione di esempio:
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 venga gestito solo da un'app email e non da un'app di messaggistica di testo o un'app social, utilizza l'azione ACTION_SENDTO
e includi lo schema dei 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 per le app di archiviazione file, incluse le informazioni necessarie per creare un filtro per intent al fine di pubblicizzare la capacità dell'app di eseguire ogni azione.
Recupera un tipo specifico di file
Per richiedere all'utente di selezionare un file, come 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 file restituito alla tua app è temporaneo nel ciclo di vita corrente
dell'attività, quindi se vuoi accedervi in un secondo momento, devi importare una copia che potrai leggere in un secondo momento.
Questo intent consente anche all'utente di creare un nuovo file nel processo. Ad esempio, invece di selezionare una foto esistente, l'utente può scattare una nuova foto con la fotocamera.
L'intent del risultato inviato al tuo metodo onActivityResult()
include dati con un URI che rimanda al file.
L'URI può essere qualsiasi, 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 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
.
Potrai quindi accedere a ognuno dei file selezionati in un oggetto ClipData
restituito da getClipData()
.
- Azione
ACTION_GET_CONTENT
- Schema dell'URI dei dati
- Nessuna
- 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 (facoltativo)
-
CATEGORY_OPENABLE
- Per restituire solo file "apribili" che possono essere rappresentati come uno stream di file
con
openFileDescriptor()
.
Esempio di intenzione di scattare 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 supportsOpenableColumns
andContentResolver.openFileDescriptor()
. --> <category android:name="android.intent.category.OPENABLE" /> </intent-filter> </activity>
Aprire un tipo specifico di file
Invece di recuperare una copia di un file da importare nell'app, utilizzando l'azione ACTION_GET_CONTENT
, se l'esecuzione avviene su Android 4.4 o versioni successive, puoi richiedere l'apertura di un file gestito da un'altra app utilizzando l'azione ACTION_OPEN_DOCUMENT
e specificando un tipo MIME.
Per consentire anche all'utente di creare un nuovo documento su cui l'app può scrivere, usa l'azione ACTION_CREATE_DOCUMENT
.
Ad esempio, invece di
selezionare da documenti PDF esistenti, l'intent ACTION_CREATE_DOCUMENT
consente agli utenti di selezionare dove vogliono 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 URI in cui può scrivere il nuovo documento.
Mentre l'intent inviato al tuo metodo onActivityResult()
dall'azione ACTION_GET_CONTENT
potrebbe restituire un URI di qualsiasi tipo, l'intent del risultato da 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, possibilmente con accesso in scrittura. L'azione ACTION_OPEN_DOCUMENT
è particolarmente utile quando vuoi leggere un file esistente senza crearne una copia nell'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ù di un elemento, getData()
restituisce un valore nullo 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 necessario, puoi specificare più di un tipo MIME aggiungendo un array di tipi MIME con l'opzione extra EXTRA_MIME_TYPES
. 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
- Nessuna
- 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 di scattare 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 mostra 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
un 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, leggi l'articolo Aprire i file utilizzando il framework di accesso allo spazio di archiviazione.
Azioni locali
La chiamata di un'auto è un'azione locale comune. Crea un filtro per intent per pubblicizzare la capacità dell'app di eseguire questa azione utilizzando le informazioni nella sezione seguente.
Chiama un taxi
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 dei dati
- Nessuna
- Tipo MIME
- Nessuna
- Extra
- Nessuno
Intenzione di esempio:
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
La visualizzazione di una posizione su una mappa è un'azione comune per le app che utilizzano mappe. Crea un filtro per intent per pubblicizzare la capacità della tua app di eseguire questa azione utilizzando le informazioni nella sezione seguente.
Mostra un luogo su una mappa
Per aprire una mappa, utilizza l'azione ACTION_VIEW
e specifica le informazioni sulla posizione nei dati dell'intent con uno dei seguenti schemi.
- Azione
ACTION_VIEW
- Schema dell'URI dei dati
-
geo:latitude,longitude
- Mostra la mappa alle coordinate di longitudine e latitudine specificate.
Esempio:
"geo:47.6,-122.3"
geo:latitude,longitude?z=zoom
- Mostra la mappa alle coordinate di longitudine e latitudine specificate e a un determinato livello di zoom. Un livello di zoom pari a 1 mostra l'intero pianeta, centrato sul lat,lng specificato. Il livello di zoom massimo (più vicino) è 23.
Esempio:
"geo:47.6,-122.3?z=11"
geo:0,0?q=lat,lng(label)
- Mostra la mappa alle coordinate di longitudine e latitudine specificate con un'etichetta di 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 una query relativa a un indirizzo o a una località specifici.
Esempio:
"geo:0,0?q=1600+Amphitheatre+Parkway%2C+CA"
Nota:tutte le stringhe passate nell'URI
geo
devono essere codificate. Ad esempio, la stringa1st & Pike, Seattle
diventa1st%20%26%20Pike%2C%20Seattle
. Gli spazi nella stringa sono codificati con%20
o sostituiti con il segno più (+
).
- Tipo MIME
- Nessuno
Intenzione di esempio:
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 musicali e video, incluse le informazioni necessarie per creare un filtro per intent al fine di 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 relativi all'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 opzione richiesta dalla tua app.
Intenzione di esempio:
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
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 per riprodurre musica. L'app ricevente per questo intent esegue una ricerca all'interno del proprio inventario per trovare una corrispondenza tra i contenuti esistenti e la query e avvia la riproduzione dei contenuti in questione.
In questo intent, includi la stringa aggiuntiva EXTRA_MEDIA_FOCUS
, che specifica la modalità di ricerca prevista. Ad esempio, con la modalità di ricerca puoi
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
- Nessuna
- Tipo MIME
- Nessuna
- Extra
-
MediaStore.EXTRA_MEDIA_FOCUS
(campo obbligatorio)-
Indica la modalità di ricerca: se l'utente sta cercando un particolare artista, album, brano o playlist. La maggior parte delle modalità di ricerca offre ulteriori extra. 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 ciascun valore di
EXTRA_MEDIA_FOCUS
:Qualsiasi -
"vnd.android.cursor.item/*"
-
Riproduci qualsiasi brano musicale. L'app ricevente riproduce alcuni brani musicali in base a una scelta intelligente, ad esempio l'ultima playlist ascoltata dall'utente.
Ulteriori extra:
QUERY
(obbligatorio): una stringa vuota. Questo extra viene 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 una 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 una qualsiasi combinazione dell'artista, dell'album, del nome del brano o del genere.
Genere -
Audio.Genres.ENTRY_CONTENT_TYPE
-
Riprodurre musica di un genere specifico.
Ulteriori extra:
- (Obbligatorio)
"android.intent.extra.genre"
: il genere. QUERY
(obbligatorio): il genere. Questo extra viene 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 una ricerca non strutturata.
- (Obbligatorio)
Artista -
Audio.Artists.ENTRY_CONTENT_TYPE
-
Riprodurre musica di un particolare artista.
Ulteriori extra:
EXTRA_MEDIA_ARTIST
(obbligatorio): l'artista."android.intent.extra.genre"
: il genere.QUERY
(obbligatorio): una stringa contenente una qualsiasi combinazione dell'artista o del genere. Questo extra viene 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 una ricerca non strutturata.
Album -
Audio.Albums.ENTRY_CONTENT_TYPE
-
Riprodurre musica di un determinato album.
Ulteriori extra:
EXTRA_MEDIA_ALBUM
(obbligatorio): l'album.EXTRA_MEDIA_ARTIST
: l'artista."android.intent.extra.genre"
: il genere.QUERY
(obbligatorio): una stringa che contiene qualsiasi combinazione dell'album o dell'artista. Questo extra viene 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 una ricerca non strutturata.
Brano -
"vnd.android.cursor.item/audio"
-
Riprodurre un brano specifico.
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 una qualsiasi combinazione dell'album, dell'artista, del genere o del titolo. Questo extra viene 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 una ricerca non strutturata.
Playlist -
Audio.Playlists.ENTRY_CONTENT_TYPE
-
Riprodurre una determinata playlist o una playlist che soddisfi alcuni criteri specificati da ulteriori 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 una qualsiasi combinazione dell'album, dell'artista, del genere, della playlist o del titolo. Questo extra viene 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 una ricerca non strutturata.
Intenzione di esempio:
Se l'utente vuole ascoltare musica di un determinato artista, un'app di ricerca potrebbe generare il seguente intent:
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'ulteriore EXTRA_MEDIA_FOCUS
nella Intent
in entrata 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 determinata modalità di ricerca.
Con queste informazioni, l'app può quindi eseguire la ricerca nel proprio inventario per riprodurre i
contenuti corrispondenti alla query di ricerca. Ciò è mostrato 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 per le app per creare note. Crea un filtro per intent per pubblicizzare la capacità della tua app di eseguire questa azione utilizzando le informazioni 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
- Nessuna
- 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.
-
- Azione
-
ACTION_DIAL
: apre l'app Telefono o Telefono.ACTION_CALL
- Consente di effettuare una telefonata (richiede l'autorizzazioneCALL_PHONE
)
- Schema dell'URI dei dati
-
tel:<phone-number>
voicemail:<phone-number>
- Tipo MIME
- Nessuno
tel:2125551212
tel:(212) 555 1212
- Azione
-
"com.google.android.gms.actions.SEARCH_ACTION"
- Supporta le query di ricerca di Azioni vocali di Google.
- Extra
-
QUERY
- Una stringa contenente la query di ricerca.
- Azione
ACTION_WEB_SEARCH
- Schema dell'URI dei dati
- Nessuna
- Tipo MIME
- Nessuna
- Extra
-
SearchManager.QUERY
- La stringa di ricerca.
- 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 di impostazioni disponibili, consulta la documentazione
Settings
. - Schema dell'URI dei dati
- Nessuna
- Tipo MIME
- Nessuno
- Azione
ACTION_SENDTO
o
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 tutti gestiti 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 di testo.
EXTRA_STREAM
- Un
Uri
che rimanda all'immagine o al video da allegare. Se utilizzi l'azioneACTION_SEND_MULTIPLE
, questo extra è unArrayList
diUri
oggetti che puntano alle immagini o ai video da allegare.
- 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"
- Configura un dispositivo Android per lo sviluppo o utilizza un dispositivo virtuale.
- Installa una versione dell'app che gestisca gli intent che vuoi supportare.
- 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
- Se definisci i filtri per intent richiesti, gestisci l'intent.
Intenzione di esempio:
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 del telefono. Crea un filtro per intent per pubblicizzare la capacità della tua app di eseguire questa azione utilizzando le informazioni 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.
L'utente deve toccare il pulsante Chiama per avviare la telefonata.
Per effettuare direttamente una telefonata, utilizza l'azione ACTION_CALL
e specifica un numero di telefono utilizzando il seguente schema URI. All'apertura dell'app Telefono, la telefonata viene avviata. Non è necessario che l'utente tocchi 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" />
I numeri di telefono validi sono quelli definiti nella RFC 3966 di IETF. Ecco alcuni esempi validi:
La tastiera dell'app Telefono è brava a normalizzare gli schemi, come
i numeri di telefono. Di conseguenza, lo schema descritto non è strettamente obbligatorio nel
metodo Uri.parse()
.
Tuttavia, se non hai provato uno schema o non hai la certezza che possa essere gestito, utilizza invece il metodo Uri.fromParts()
.
Intenzione di esempio:
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); } }
Cerca
Di seguito sono riportate le azioni comuni per le app di ricerca, incluse le informazioni necessarie per creare un filtro per intent per pubblicizzare la capacità dell'app di eseguire ogni azione.
Cerca utilizzando un'app specifica
Per supportare la ricerca nel contesto della tua app, dichiara un filtro per intent nell'app con
l'azione SEARCH_ACTION
, come mostrato nell'esempio di filtro per intent riportato di seguito.
Nota: sconsigliamo di 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 maggiori informazioni, consulta la documentazione relativa alle Azioni app dell'Assistente Google.
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>
Esegui una ricerca web
Per avviare una ricerca web, utilizza l'azione ACTION_WEB_SEARCH
e specifica la stringa di ricerca nel
extra SearchManager.QUERY
.
Intenzione di esempio:
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 intent:
Intenzione di esempio:
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 nella sezione seguente.
Scrivi un messaggio SMS/MMS con allegato
Per avviare un messaggio SMS o MMS, utilizza una delle seguenti azioni intent e specifica i dettagli del messaggio, ad esempio il numero di telefono, l'oggetto e il corpo del messaggio, utilizzando i seguenti tasti aggiuntivi.
Intenzione di esempio:
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 il tuo intent venga gestito solo da un'app di messaggistica di testo e non da altre
app email o social, utilizza l'azione ACTION_SENDTO
e includi lo schema dei 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 affinché 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 nella sezione seguente.
Carica un URL web
Per aprire una pagina web, utilizza l'azione ACTION_VIEW
e specifica l'URL web nei dati dell'intent.
Intenzione di esempio:
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 offre funzionalità simili al tuo sito web, includi un filtro per intent per gli URL che rimandano al tuo sito web. Se gli utenti hanno installato la tua app, i link provenienti da email o altre pagine web che rimandano al tuo sito web apriranno l'app per Android anziché la pagina web. Scopri di più nella pagina Gestire i link per app Android.
A partire da Android 12 (livello API 31), un intent web generico si risolve in un'attività nella tua app solo se quest'ultima è approvata per il dominio specifico contenuto nell'intent web. Se l'app non viene approvata per il dominio, l'intent web viene risolto nell'app browser predefinita dell'utente.
Verifica 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 nel seguente modo:
Per ulteriori informazioni, vedi Problemi dei comandi della shell.