Intenzioni comuni

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

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 il percorso di output, leggi Scatta foto oppure 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, poi salva l'immagine o il video acquisito nel località specificata dal contenuto 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

Azioni vocali di Google

• "scatta una foto"

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

Nessuna

Intenzione di esempio:

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

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

Nessuna

Tipo MIME

Nessuna

Extra

Nessuna

Intenzione di esempio:

fun capturePhoto() {
    val intent = Intent(MediaStore.INTENT_ACTION_VIDEO_CAMERA)
    if (intent.resolveActivity(packageManager) != null) {
        startActivityForResult(intent, REQUEST_IMAGE_CAPTURE)
    }
}

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 che ti servono per creare un filtro per intent al fine di pubblicizzare la capacità della tua 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, usa l'azione ACTION_PICK e specifica il tipo MIME per Contacts.CONTENT_TYPE.

Il risultato Intent pubblicato per il callback onActivityResult() contiene il URI content: che punta al contatto selezionato. La risposta concede le autorizzazioni temporanee dell'app per 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 un contatto specifico come un numero di telefono o un indirizzo email, consulta invece la sezione successiva su come seleziona dati di contatto specifici.

Azione

ACTION_PICK

Schema dell'URI dei dati

Nessuna

Tipo MIME

Contacts.CONTENT_TYPE

Intenzione di esempio:

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

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 dati di contatto una volta che hai l'URI di contatto, leggi Recupero dei dettagli per un contatto.

Quando recuperi l'URI di contatto utilizzando questo intent, in genere non hanno bisogno del READ_CONTACTS l'autorizzazione a 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, come come numero di telefono o indirizzo email: è necessario il READ_CONTACTS autorizzazione.

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 ACTION_PICK e specificare il tipo MIME su uno dei seguenti tipi di contenuti, ad esempio CommonDataKinds.Phone.CONTENT_TYPE per trovare il numero di telefono del contatto.

Nota: in molti casi, l'app deve disporre della READ_CONTACTS l'autorizzazione a visualizzare informazioni specifiche su un particolare contatto.

Se è necessario recuperare solo un tipo di dati da un contatto, questa tecnica con un CONTENT_TYPE da ContactsContract.CommonDataKinds corso è più efficiente di utilizzando Contacts.CONTENT_TYPE, come mostrato nella sezione precedente. Il risultato ti fornisce ai dati desiderati senza dover eseguire una query più complessa con il Fornitore di Contatti.

Il risultato Intent pubblicato per il callback onActivityResult() contiene il URI content: che punta ai dati di contatto selezionati. La risposta concede autorizzazioni temporanee della tua app 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 tanti altri valori CONTENT_TYPE sotto ContactsContract.

Intenzione di esempio:

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

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 ACTION_VIEW e specifica il contatto con un URI content: come dati per l'intent.

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

• Utilizza l'URI di contatto restituito dall'azione ACTION_PICK mostrato 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 lo READ_CONTACTS autorizzazione.

Azione

ACTION_VIEW

Schema dell'URI dei dati

content:<URI>

Tipo MIME

Nessuno. Il tipo viene dedotto dall'URI del contatto.

Intenzione di esempio:

fun viewContact(contactUri: Uri) {
    val intent = Intent(Intent.ACTION_VIEW, contactUri)
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

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 ACTION_EDIT specifica il contatto con un URI content: come dati sull'intent e includere eventuali informazioni di contatto note negli extra specificati da 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 mostrato 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 lo READ_CONTACTS autorizzazione.

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 poter completare i campi dei dettagli di contatto.

Intenzione di esempio:

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

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, consulta Modificare contatti usando gli intent.

Inserisci un contatto

Per inserire un nuovo contatto, usa l'azione ACTION_INSERT, specifica Contacts.CONTENT_TYPE come il tipo MIME e includere 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:

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

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, consulta Modificare contatti usando 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 informazioni nella sezione seguente.

Scrivere un'email con allegati facoltativi

Per scrivere un'email, utilizza una delle seguenti azioni, a seconda che includi 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 i campi "A" gli indirizzi email dei destinatari.

Intent.EXTRA_CC

Un array di stringhe di tutti i caratteri "CC" gli indirizzi email dei destinatari.

Intent.EXTRA_BCC

Un array di stringhe di tutti i valori "Ccn" gli indirizzi email dei destinatari.

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 il ACTION_SEND_MULTIPLE si tratta di un'azione ArrayList contenente più oggetti Uri.

Intenzione di esempio:

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

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 SMS o app social, poi usa l'azione ACTION_SENDTO e includi lo schema di dati "mailto:", come mostrato nell'esempio seguente:

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

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 per l'archiviazione di file, incluse le informazioni di cui hai bisogno. per creare un filtro per intent al fine di 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 di restituire un riferimento a la tua app, utilizza l'azione ACTION_GET_CONTENT e specifica tipo MIME. Il riferimento file restituito alla tua app è temporaneo per lo stato attuale 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. Per 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:, file: URI o content: URI. Se invece vuoi limitare i file selezionabili solo a quelli accessibili di un fornitore di contenuti (un URI content:) e disponibili come stream di file openFileDescriptor(), aggiungi la categoria CATEGORY_OPENABLE in base al tuo intento.

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 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 dalle sul dispositivo, invece di dover richiedere il download da un servizio remoto.

Categoria (facoltativo)

CATEGORY_OPENABLE

Per restituire solo "apribili" che possono essere rappresentati come uno stream di file con openFileDescriptor().

Esempio di intenzione di scattare una foto:

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

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 specifico di file

Invece di recuperare una copia di un file da importare nell'app, puoi usare l'azione ACTION_GET_CONTENT quando è in esecuzione su Android 4.4 o versioni successive, puoi richiedere l'apertura di un file gestito da un'altra app tramite usando 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 selezionando da documenti PDF esistenti, ACTION_CREATE_DOCUMENT intent consente agli utenti di selezionare dove creare un nuovo documento, ad esempio all'interno di un'altra app che gestisce l'archiviazione del documento. L'app riceve quindi la posizione URI della posizione possono scrivere il nuovo documento.

mentre l'intent ha interessato onActivityResult() dell'azione ACTION_GET_CONTENT potrebbe restituisce 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() e esegue 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ù di un elemento, getData() restituisce un valore nullo e devi invece scegliere recupera ogni elemento da un ClipData restituito da getClipData().

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

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 utilizzati dall'app richiesta. Quando utilizzi questo componente aggiuntivo, devi impostare il tipo MIME principale Da setType() a "*/*".

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 dalle sul dispositivo, invece di dover richiedere il download da un servizio remoto.

Categoria

CATEGORY_OPENABLE

Per restituire solo "apribili" che possono essere rappresentati come uno stream di file con openFileDescriptor().

Esempio di intenzione di scattare una foto:

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

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 intento con il Azione ACTION_OPEN_DOCUMENT. Il sistema riceve invece e mostra tutti i file disponibili da varie app in un'interfaccia utente unificata.

Per fornire i file dell'app in questa UI e consentire ad altre app di aprirli, devi implementare un DocumentsProvider e includi 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 in altre app, vedi Aprire i file utilizzando il framework di accesso allo spazio di archiviazione.

Azioni locali

La chiamata di un'auto è un'azione locale comune. Creare un filtro per intent per pubblicizzare la tua app 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 la ACTION_RESERVE_TAXI_RESERVATION un'azione.

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

Azione

ACTION_RESERVE_TAXI_RESERVATION

URI dei dati

Nessuna

Tipo MIME

Nessuna

Extra

Nessuna

Intenzione di esempio:

fun callCar() {
    val intent = Intent(ReserveIntents.ACTION_RESERVE_TAXI_RESERVATION)
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

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 informazioni nella sezione seguente.

Mostra un luogo su una mappa

Per aprire una mappa, usa 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 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 di 1 mostra l'intera Terra, centrata nel punto lat,lng specificato. Il più alto Il livello di zoom (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 codificati. Ad esempio, la stringa 1st & Pike, Seattle diventa 1st%20%26%20Pike%2C%20Seattle. Gli spazi nella stringa sono codificati con %20 o sostituito con il segno più (+).

Tipo MIME

Nessuna

Intenzione di esempio:

fun showMap(geoLocation: Uri) {
    val intent = Intent(Intent.ACTION_VIEW).apply {
        data = geoLocation
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

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 alcune azioni comuni eseguite dalle app di musica e video, incluse le informazioni di cui hai bisogno. per creare un filtro per intent al fine di pubblicizzare la capacità della tua app di eseguire ogni azione.

Riprodurre un file multimediale

Per riprodurre un file musicale, usa l'azione ACTION_VIEW e specificare la posizione URI del file nei dati di 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:

fun playMedia(file: Uri) {
    val intent = Intent(Intent.ACTION_VIEW).apply {
        data = file
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

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 billie jean di michael jackson"

Per riprodurre musica in base a una query di ricerca, utilizza il Intenzione INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH. Un'app potrebbe attivarsi questo intent in risposta al comando vocale dell'utente di riprodurre musica. L'app ricevente esegue una ricerca all'interno del proprio inventario per abbinare i contenuti esistenti alla query e inizia a riprodurre i contenuti.

In questo intent, includi la stringa EXTRA_MEDIA_FOCUS , che specifica la modalità di ricerca desiderata. 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

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 una playlist. La maggior parte delle modalità di ricerca offre ulteriori extra. Ad esempio, se l'utente è interessato ad ascoltare un determinato brano, l'intento potrebbe prevedere 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 musicali in base a una scelta intelligente, come come ultima playlist ascoltata dall'utente.

Ulteriori extra:

• QUERY (obbligatorio): una stringa vuota. 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 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 riesce a 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 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 è sempre disponibile 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.

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 qualsiasi combinazione di l'artista o 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 un intento non strutturato eseguire una ricerca.

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 contenente qualsiasi combinazione di l'album o l'artista. Questo extra viene sempre fornito per la compatibilità. Le app esistenti che non conoscono le modalità di ricerca possono elaborare questo intento come 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 qualsiasi combinazione di l'album, l'artista, il genere o il titolo. Questo extra è sempre disponibile la compatibilità con le versioni precedenti. Le app esistenti che non conoscono le modalità di ricerca possono elaborare questo l'intenzione di effettuare una ricerca non strutturata.

Playlist - Audio.Playlists.ENTRY_CONTENT_TYPE

Riprodurre una determinata playlist o una playlist che soddisfa alcuni criteri specificati da altri 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 che costituisce la playlist in base a cui
• QUERY (obbligatorio): una stringa contenente qualsiasi combinazione dell'album, dell'artista, del genere, della playlist o del titolo. 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 una ricerca non strutturata.

Intenzione di esempio:

Se l'utente desidera ascoltare musica di un particolare artista, un'app di ricerca potrebbe generare il seguente intento:

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

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 del parametro EXTRA_MEDIA_FOCUS extra in arrivo Intent per determinare la modalità di ricerca. Una volta che la tua attività è stata identificata 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 all'interno del proprio inventario per riprodurre i che corrispondono alla query di ricerca. Ciò è mostrato nell'esempio seguente.

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

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 informazioni nella sezione seguente.

Creare una nota

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

Nota: le app devono chiedere 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.

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 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 di 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 numero 555-5555"
• "chiama bob"
• "chiama la segreteria"

Per fare direttamente una telefonata, usa l'azione ACTION_CALL e specifica un numero di telefono utilizzando il seguente schema URI. All'apertura dell'app Telefono, avvia la telefonata. Non è necessario che l'utente tocchi il pulsante Chiama.

L'azione ACTION_CALL richiede l'aggiunta dell'elemento Autorizzazione CALL_PHONE per il tuo file manifest:

<uses-permission android:name="android.permission.CALL_PHONE" />

Azione

• ACTION_DIAL: apre l'app Telefono o Telefono.
• ACTION_CALL - Consente di effettuare una telefonata (richiede la autorizzazione CALL_PHONE)

Schema dell'URI dei dati

• tel:<phone-number>
• voicemail:<phone-number>

Tipo MIME

Nessuna

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

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

La tastiera dell'app Telefono è brava a normalizzare gli schemi, come numeri di telefono. Quindi lo schema descritto non è strettamente obbligatorio nel Uri.parse(). Tuttavia, se non hai provato uno schema o non sei sicuro che lo possono essere gestiti, utilizza l'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 di cui hai bisogno per creare un filtro per intent al fine di pubblicizzare la capacità della tua app di eseguire ogni azione.

Cerca utilizzando 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 nel seguente esempio di filtro per intent.

Nota: sconsigliamo di utilizzare SEARCH_ACTION per la ricerca di app. Implementa invece GET_THING per sfruttare il supporto integrato dell'Assistente Google per la ricerca in-app. Per ulteriori informazioni, vedi l'Assistente Google documentazione di Azioni app.

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.

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 specificare la stringa di ricerca SearchManager.QUERY extra.

Azione

ACTION_WEB_SEARCH

Schema dell'URI dei dati

Nessuna

Tipo MIME

Nessuna

Extra

SearchManager.QUERY

La stringa di ricerca.

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:

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

Nessuna

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 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 il messaggio dettagli come il numero di telefono, l'oggetto e il corpo del messaggio usando i tasti aggiuntivi che seguono.

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 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 punta a immagine o video da allegare. Se utilizzi l'azione ACTION_SEND_MULTIPLE, questo extra è di ArrayList Uri oggetti che puntano alle immagini o ai video da allegare.

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 e non da altri email o app social, quindi usa l'azione ACTION_SENDTO e includi lo schema di 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 sviluppi un'app di messaggistica SMS/MMS, devi: implementare filtri per intent per diverse azioni aggiuntive in modo che siano disponibili app SMS predefinita su Android 4.4 e versioni successive. Per ulteriori informazioni, consulta la documentazione alle ore 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 informazioni 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 specificare l'URL web nei dati relativi all'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"

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 a includi un filtro per intent per gli URL che rimandano al tuo sito web. Poi, Se gli utenti hanno installato la tua app, link da email o altre pagine web che rimandano al tuo sito web apri l'app per Android anziché la pagina web. Scopri di più in Gestione di Link per app Android.

A partire da Android 12 (livello API 31), un intent web generico viene risolto in un attività nella tua app solo se è approvata per il dominio specifico contenuti nell'intent web. Se la tua app non viene approvata per il dominio, si risolve invece 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 la adb per attivare intent specifici tramite le seguenti:

1. Configurare un dispositivo Android per lo sviluppo o usa 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>
   

   Ad esempio:

   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 ulteriori informazioni, vedi Problemi dei comandi shell.