Intents comuns

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>

Para mais informações sobre como usar essa intent para capturar uma foto, incluindo como criar um Uri apropriado para o local de saída, leia Tirar fotos ou Gravar vídeos.

Exemplo de filtro de intent:

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

Ao processar essa intent, faça com que a atividade verifique o extra EXTRA_OUTPUT na Intent recebida e salve a imagem ou o vídeo capturado no local especificado por esse extra e chame setResult() com uma Intent que inclua uma miniatura compactada em um extra chamado "data".

Iniciar um aplicativo de câmera em modo de imagem estática

Google Voice Actions

• "tirar uma foto"

Para abrir um app de câmera em modo de imagem estática, use a ação INTENT_ACTION_STILL_IMAGE_CAMERA.

Ação

INTENT_ACTION_STILL_IMAGE_CAMERA

Esquema do URI dos dados

Nenhum

Tipo MIME

Nenhum

Extras

Nenhum

Exemplo de intent:

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

Exemplo de filtro de intent:

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

Iniciar um aplicativo de câmera em modo de vídeo

Google Voice Actions

• "gravar um vídeo"

Para abrir um app de câmera no modo de vídeo, use a ação INTENT_ACTION_VIDEO_CAMERA.

Ação

INTENT_ACTION_VIDEO_CAMERA

Esquema do URI dos dados

Nenhum

Tipo MIME

Nenhum

Extras

Nenhum

Exemplo de intent:

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

Exemplo de filtro de intent:

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

App Contatos/pessoas

Estas são ações comuns para apps de gerenciamento de contatos, incluindo as informações necessárias para criar um filtro de intent e anunciar a capacidade do app de realizar cada ação.

Selecione um contato

Para que o usuário selecione um contato e dê ao app acesso a todos os dados de contato, use a ação ACTION_PICK e especifique o tipo MIME para Contacts.CONTENT_TYPE.

O resultado Intent entregue ao callback onActivityResult() contém o URI content: que aponta para o contato selecionado. A resposta concede permissões temporárias do app para ler esse contato usando a API Contacts Provider, mesmo se o app não inclui a permissão READ_CONTACTS.

Dica:se você precisar de acesso apenas a um contato específico informações, como número de telefone ou endereço de e-mail, consulte a próxima seção, que mostra como selecione dados de contato específicos.

Ação

ACTION_PICK

Esquema do URI dos dados

Nenhum

Tipo MIME

Contacts.CONTENT_TYPE

Exemplo de intent:

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

Para informações sobre como recuperar detalhes do contato depois de ter o URI dele, leia Recuperar detalhes de um contato.

Quando você recupera o URI do contato usando essa intent, geralmente não é necessário preciso do READ_CONTACTS permissão para ler detalhes básicos desse contato, como nome de exibição e se o contato está marcado com estrela. No entanto, se você estiver tentando ler dados mais específicos sobre um determinado contato, como como número de telefone ou endereço de e-mail, é necessário ter o READ_CONTACTS permissão.

Selecionar dados de contato específicos

Para que o usuário selecione uma informação específica de um contato, como um número de telefone, endereço de e-mail ou outro tipo de dados, use o ACTION_PICK e especificar o tipo MIME como um dos seguintes tipos de conteúdo, como CommonDataKinds.Phone.CONTENT_TYPE para acessar o número de telefone do contato.

Observação : em muitos casos, o app precisa ter a READ_CONTACTS permissão para visualizar informações específicas sobre um contato específico.

Se você precisar recuperar apenas um tipo de dados de um contato, essa técnica com uma CONTENT_TYPE do As classes ContactsContract.CommonDataKinds são mais eficientes do que usando o Contacts.CONTENT_TYPE, conforme mostrado na seção anterior. O resultado fornece acesso aos dados desejados sem que você precise fazer uma consulta mais complexa no Provedor de contatos.

O resultado Intent entregue ao callback onActivityResult() contém o URI content: que aponta para os dados do contato selecionado. A resposta concede o app permissões temporárias para ler os dados do contato, mesmo que o app não inclua a permissão READ_CONTACTS;

Ação

ACTION_PICK

Esquema do URI dos dados

Nenhum

Tipo MIME

CommonDataKinds.Phone.CONTENT_TYPE

Escolha entre os contatos com um número de telefone.

CommonDataKinds.Email.CONTENT_TYPE

Escolha entre os contatos com um endereço de e-mail.

CommonDataKinds.StructuredPostal.CONTENT_TYPE

Escolha entre os contatos com um endereço postal.

Ou um dos muitos outros valores de CONTENT_TYPE abaixo de ContactsContract.

Exemplo de intent:

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

Visualizar um contato

Para mostrar os detalhes de um contato conhecido, use o ACTION_VIEW e especificar o contato com um URI content: como os dados da intent.

Há duas maneiras principais de recuperar inicialmente a URI do contato:

• Use o URI do contato retornado pela ação ACTION_PICK. como mostrado na seção anterior. Essa abordagem não requer permissões do app.
• Acessar a lista de todos os contatos diretamente, como descrito em Recuperar uma lista de contatos. Essa abordagem exige a propriedade READ_CONTACTS permissão.

Ação

ACTION_VIEW

Esquema do URI dos dados

content:<URI>

Tipo MIME

Nenhum. O tipo é inferido com base no URI do contato.

Exemplo de intent:

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

Editar um contato atual

Para editar um contato conhecido, use o ACTION_EDIT especifique o contato com um URI de content: como os dados de intent e incluem quaisquer informações de contato conhecidas em extras especificados por constantes em ContactsContract.Intents.Insert.

Há duas maneiras principais de recuperar inicialmente o URI do contato:

• Use o URI do contato retornado pela ação ACTION_PICK. como mostrado na seção anterior. Essa abordagem não requer permissões do app.
• Acessar a lista de todos os contatos diretamente, como descrito em Recuperar uma lista de contatos. Essa abordagem exige a propriedade READ_CONTACTS permissão.

Ação

ACTION_EDIT

Esquema do URI dos dados

content:<URI>

Tipo MIME

O tipo é inferido a partir do URI do contato.

Extras

Um ou mais dos extras definidos em ContactsContract.Intents.Insert para que você possa preencher campos dos detalhes do contato.

Exemplo de intent:

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

Para mais informações sobre como editar um contato, consulte Modificar contatos usando intents.

Inserir um contato

Para inserir um novo contato, use a ação ACTION_INSERT, especificar Contacts.CONTENT_TYPE como o tipo MIME e incluem quaisquer informações de contato conhecidas em extras especificados por constantes em ContactsContract.Intents.Insert.

Ação

ACTION_INSERT

Esquema do URI dos dados

Nenhum

Tipo MIME

Contacts.CONTENT_TYPE

Extras

Um ou mais dos extras definidos em ContactsContract.Intents.Insert.

Exemplo de intent:

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

Para obter mais informações sobre como inserir um contato, consulte Modificar contatos usando intents.

E-mail

Escrever um e-mail com anexos opcionais é uma ação comum para apps de e-mail. Crie um filtro de intent para anunciar a capacidade do app de realizar essa ação usando o na seção a seguir.

Compor um e-mail com anexos opcionais

Para escrever um e-mail, use uma das seguintes ações, dependendo se incluirá anexos ou não: e inclua detalhes do e-mail, como o destinatário e o assunto, usando as chaves extras listadas.

Ação

ACTION_SENDTO (para nenhum anexo) ou
ACTION_SEND (para um anexo) ou
ACTION_SEND_MULTIPLE (para vários anexos)

Esquema do URI dos dados

Nenhum

Tipo MIME

"text/plain"

"*/*"

Extras

Intent.EXTRA_EMAIL

Uma matriz de strings de todos os valores "To" endereços de e-mail dos destinatários.

Intent.EXTRA_CC

Uma matriz de strings de todos os valores "CC" endereços de e-mail dos destinatários.

Intent.EXTRA_BCC

Uma matriz de strings de todos os valores "BCC" endereços de e-mail dos destinatários.

Intent.EXTRA_SUBJECT

Uma string com o assunto do e-mail.

Intent.EXTRA_TEXT

Uma string com o corpo do e-mail.

Intent.EXTRA_STREAM

Uma Uri que aponta para o anexo. Se você usar o ACTION_SEND_MULTIPLE ação, esta é uma ArrayList contendo vários objetos Uri.

Exemplo de intent:

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 quiser garantir que sua intent seja processada somente por um app de e-mails, e não por um mensagem de texto ou aplicativo social e use a ação ACTION_SENDTO e inclua o esquema de dados "mailto:", conforme mostrado no exemplo a seguir:

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

Exemplo de filtro de 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>

Armazenamento de arquivos

Confira abaixo ações comuns para apps de armazenamento de arquivos, incluindo as informações necessárias para criar um filtro de intent e anunciar a capacidade do app de realizar cada ação.

Recuperar um tipo específico de arquivo

Para solicitar que o usuário selecione um arquivo, como um documento ou foto, e retorne uma referência ao seu app, use a ação ACTION_GET_CONTENT e especifique o que Tipo MIME. A referência de arquivo retornada para o app é temporária em relação à atividade atual Por isso, se você quiser acessá-lo depois, vai precisar importar uma cópia para ler depois.

Essa intent também permite que o usuário crie um novo arquivo no processo. Para exemplo, em vez de selecionar uma foto existente, o usuário pode capturar uma nova foto com a câmera.

A intent resultante entregue ao método onActivityResult() inclui dados com um URI que aponta para o arquivo. O URI pode ser qualquer coisa, como um URI http:, file: ou content:. URI. No entanto, se você quiser restringir os arquivos selecionáveis apenas àqueles que possam ser acessados de um provedor de conteúdo (um URI content:) e que estão disponíveis como um fluxo de arquivos com openFileDescriptor(), adicionar a categoria CATEGORY_OPENABLE à intent.

No Android 4.3 (nível 18 da API) e versões mais recentes, você também pode permitir que o usuário selecione vários arquivos adicionando EXTRA_ALLOW_MULTIPLE à intent, definido como true. É possível acessar cada um dos arquivos selecionados em uma ClipData objeto retornado por getClipData().

Ação

ACTION_GET_CONTENT

Esquema do URI dos dados

Nenhum

Tipo MIME

O tipo MIME correspondente ao tipo de arquivo que o usuário precisa selecionar.

Extras

EXTRA_ALLOW_MULTIPLE

É um booleano que declara se o usuário pode selecionar mais de um arquivo ao mesmo tempo.

EXTRA_LOCAL_ONLY

Um booleano que declara se o arquivo retornado precisa estar disponível diretamente de dispositivo, em vez de exigir o download de um serviço remoto.

Categoria (opcional)

CATEGORY_OPENABLE

Retornar somente o status "pode ser aberto" que podem ser representados como um stream de arquivos com openFileDescriptor().

Exemplo de intent para receber uma 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.
        ...
    }
}

Exemplo de filtro de intent para retornar uma 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>

Abrir um tipo de arquivo específico

Em vez de recuperar uma cópia de um arquivo que você precisa importar para o app, usando a ação ACTION_GET_CONTENT, ao executar no Android 4.4 ou superior, você pode solicitar a abrir um arquivo gerenciado por outro aplicativo, usando a ação ACTION_OPEN_DOCUMENT e especificando um tipo MIME. Para permitir que o usuário crie um novo documento em que o app pode gravar, use a ação ACTION_CREATE_DOCUMENT.

Por exemplo, em vez de selecionando entre os documentos PDF, o ACTION_CREATE_DOCUMENT permite que os usuários selecionem onde gostariam de criar um novo documento, como em outro aplicativo que gerencia o armazenamento do documento. Em seguida, o app recebe o local do URI de onde gravar o novo documento.

Já a intent entregue ao onActivityResult() da ação ACTION_GET_CONTENT pode retornar um URI de qualquer tipo, a intent de resultado de ACTION_OPEN_DOCUMENT e ACTION_CREATE_DOCUMENT sempre especificam o arquivo escolhido como um URI content: que tem o suporte de um DocumentsProvider. É possível abrir com openFileDescriptor() e consultar os detalhes usando colunas de DocumentsContract.Document.

O URI retornado concede ao aplicativo acesso de leitura de longo prazo ao arquivo, possivelmente com acesso de gravação. A ação ACTION_OPEN_DOCUMENT é especialmente útil quando você quer ler um arquivo existente sem fazer uma cópia em seu aplicativo ou quando quiser abrir e editar um arquivo no local.

Você também pode permitir que o usuário selecione vários arquivos adicionando EXTRA_ALLOW_MULTIPLE à intent, definido como true. Se o usuário selecionar apenas um item, você poderá recuperá-lo em getData(). Se o usuário selecionar mais de um item, getData() retornará um valor nulo e você precisará recuperam cada item de uma ClipData objeto retornado por getClipData().

Observação:sua intent precisa especificar um tipo MIME e precisa declarar a categoria CATEGORY_OPENABLE. Se apropriado, você pode especificar mais de um tipo MIME adicionando uma matriz de tipos MIME com o EXTRA_MIME_TYPES extra. Se você fizer isso, precisará definir os tipo MIME principal em setType() para "*/*".

Ação

ACTION_OPEN_DOCUMENT ou
ACTION_CREATE_DOCUMENT

Esquema do URI dos dados

Nenhum

Tipo MIME

O tipo MIME correspondente ao tipo de arquivo que o usuário precisa selecionar.

Extras

EXTRA_MIME_TYPES

Uma matriz de tipos MIME correspondente aos tipos de arquivos contidos no seu app a solicitação. Ao usar esse extra, você deve definir o tipo MIME principal em setType() para "*/*".

EXTRA_ALLOW_MULTIPLE

É um booleano que declara se o usuário pode selecionar mais de um arquivo ao mesmo tempo.

EXTRA_TITLE

Para uso com ACTION_CREATE_DOCUMENT para especificar um nome de arquivo inicial.

EXTRA_LOCAL_ONLY

Um booleano que declara se o arquivo retornado precisa estar disponível diretamente de dispositivo, em vez de exigir o download de um serviço remoto.

Categorias

CATEGORY_OPENABLE

Retornar somente o status "pode ser aberto" que podem ser representados como um stream de arquivos com openFileDescriptor().

Exemplo de intent para receber uma 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.
        ...
    }
}

Apps de terceiros não podem responder a intents com as ACTION_OPEN_DOCUMENT. Em vez disso, o sistema recebe e exibe todos os arquivos disponíveis de vários aplicativos em uma interface de usuário unificada.

Para fornecer os arquivos do seu app nessa interface e permitir que outros apps os abram, é necessário implementar um DocumentsProvider e incluem um filtro de intent para PROVIDER_INTERFACE ("android.content.action.DOCUMENTS_PROVIDER"), conforme mostrado no exemplo a seguir:

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

Para mais informações sobre como permitir que os arquivos gerenciados pelo seu app possam ser abertos em outros apps, leia Abrir arquivos usando o framework de acesso ao armazenamento.

Ações locais

Chamar um carro é uma ação local comum. Crie um filtro de intenção para anunciar as executar essa ação usando as informações na seção a seguir.

Chamar um táxi

Google Voice Actions

• "mande um táxi"
• "chamar um carro para mim"

(Somente Wear OS)

Para chamar um táxi, use o método ACTION_RESERVE_TAXI_RESERVATION à ação.

Observação:os apps precisam pedir a confirmação do usuário. antes de concluir esta ação.

Ação

ACTION_RESERVE_TAXI_RESERVATION

URI de dados

Nenhum

Tipo MIME

Nenhum

Extras

Nenhum

Exemplo de intent:

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

Exemplo de filtro de 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>

Mapas

Mostrar um local em um mapa é uma ação comum para apps de mapas. Crie um filtro de intent para anunciar a capacidade do app de realizar essa ação usando o na seção a seguir.

Exibir um local em um mapa

Para abrir um mapa, use a ação ACTION_VIEW e especifique as informações de localização nos dados da intent com um dos esquemas a seguir.

Ação

ACTION_VIEW

Esquema do URI dos dados

geo:latitude,longitude

Mostrar o mapa na longitude e na latitude informadas.

Exemplo: "geo:47.6,-122.3"

geo:latitude,longitude?z=zoom

Mostra o mapa na longitude e na latitude dadas em um determinado nível de zoom. Um nível de zoom de "1" mostra toda a Terra, centralizada nas lat,lng informadas. A maior (mais próximo) é 23.

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

geo:0,0?q=lat,lng(label)

Mostrar o mapa na longitude e na latitude informadas com um rótulo de string.

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

geo:0,0?q=my+street+address

Mostrar a localização de "meu endereço", que pode ser um endereço específico ou uma consulta de local.

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

Observação:todas as strings transmitidas no URI geo precisam ser codificado. Por exemplo, a string 1st & Pike, Seattle se torna 1st%20%26%20Pike%2C%20Seattle. Os espaços na string são codificados com %20 ou substituído pelo sinal de adição (+).

Tipo MIME

Nenhum

Exemplo de intent:

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

Exemplo de filtro de 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>

Música ou vídeo

Confira abaixo ações comuns para apps de música e vídeo, incluindo as informações necessárias para criar um filtro de intent e anunciar a capacidade do app de realizar cada ação.

Reproduzir um arquivo de mídia

Para reproduzir um arquivo de música, use a ação ACTION_VIEW e especifique o local do URI do arquivo nos dados da intent.

Ação

ACTION_VIEW

Esquema do URI dos dados

file:<URI>

content:<URI>

http:<URL>

Tipo MIME

"audio/*"

"application/ogg"

"application/x-ogg"

"application/itunes"

Ou qualquer outra opção que o app exija.

Exemplo de intent:

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

Exemplo de filtro de 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>

Reproduzir música com base em uma consulta de pesquisa

Google Voice Actions

• "tocar michael jackson billie jean"

Para reproduzir música com base em uma consulta de pesquisa, use o INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH. Um app pode ser acionado essa intent em resposta ao comando de voz do usuário para tocar música. O app que vai receber o executa uma pesquisa em seu inventário para corresponder o conteúdo existente à consulta especificada e começa a reproduzir esse conteúdo.

Nessa intent, inclua a string EXTRA_MEDIA_FOCUS. que especifica o modo de pesquisa pretendido. Por exemplo, o modo de pesquisa pode especificar a pesquisa é pelo nome de um artista ou uma música.

Ação

INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH

Esquema do URI dos dados

Nenhum

Tipo MIME

Nenhum

Extras

MediaStore.EXTRA_MEDIA_FOCUS (obrigatório)

Indica o modo de pesquisa: se o usuário está procurando por um artista, álbum, música ou ou playlist. A maioria dos modos de pesquisa precisa de extras adicionais. Por exemplo, se o usuário estiver interessada em ouvir uma música específica, a intenção pode ter três extras adicionais: o título da música, o artista e o álbum. Essa intent é compatível com os seguintes modos de pesquisa para: cada valor de EXTRA_MEDIA_FOCUS:

Qualquer um: "vnd.android.cursor.item/*"

Reproduz qualquer música. O app receptor toca algumas músicas com base em uma escolha inteligente, como como a última playlist que o usuário escutou.

Extras adicionais:

• QUERY (obrigatório): uma string vazia. Esse extra é sempre fornecidos para compatibilidade com versões anteriores. Apps que não conhecem os modos de pesquisa podem processar essa intenção como uma pesquisa não estruturada.

Não estruturado - "vnd.android.cursor.item/*"

Reproduz uma música, álbum ou gênero específico de uma consulta de pesquisa não estruturada. Os apps podem gerar uma intent com esse modo de pesquisa quando não consegue identificar o tipo de conteúdo que o usuário deseja ouvir. Use modos de pesquisa mais específicos quando possível.

Extras adicionais:

• QUERY (obrigatório): uma string que contém qualquer combinação. do artista, do álbum, do nome da música ou do gênero.

Gênero: Audio.Genres.ENTRY_CONTENT_TYPE

Reproduz música de um gênero particular.

Extras adicionais:

• "android.intent.extra.genre" (obrigatório): o gênero.
• QUERY (obrigatório): o gênero. Esse extra é sempre fornecido para compatibilidade com versões anteriores. Apps que não conhecem os modos de pesquisa podem processar essa intent como uma pesquisa não estruturada.

Artista: Audio.Artists.ENTRY_CONTENT_TYPE

Reproduz música de um artista específico.

Extras adicionais:

• EXTRA_MEDIA_ARTIST (obrigatório): o artista.
• "android.intent.extra.genre": o gênero.
• QUERY (obrigatório): uma string que contém qualquer combinação de o artista ou o gênero. Esse extra é sempre fornecido para compatibilidade com versões anteriores. Os aplicativos que não conhecem os modos de pesquisa podem processar essa intent como um objeto pesquisa.

Álbum: Audio.Albums.ENTRY_CONTENT_TYPE

Reproduz música de um álbum específico.

Extras adicionais:

• EXTRA_MEDIA_ALBUM (obrigatório): o álbum.
• EXTRA_MEDIA_ARTIST: o artista.
• "android.intent.extra.genre": o gênero.
• QUERY (obrigatório): uma string que contém qualquer combinação de o álbum ou o artista. Este extra é sempre fornecido para compatibilidade. Apps existentes que desconhecem os modos de pesquisa podem processar essa intent como uma não estruturados.

Música: "vnd.android.cursor.item/audio"

Reproduz uma música particular.

Extras adicionais:

• EXTRA_MEDIA_ALBUM: o álbum.
• EXTRA_MEDIA_ARTIST: o artista.
• "android.intent.extra.genre": o gênero.
• EXTRA_MEDIA_TITLE (obrigatório): o nome da música.
• QUERY (obrigatório): uma string que contém qualquer combinação de álbum, artista, gênero ou título. Esse extra é sempre fornecido para a compatibilidade com versões anteriores. Apps que não conhecem os modos de pesquisa podem processar isso que uma pesquisa não estruturada.

Playlist: Audio.Playlists.ENTRY_CONTENT_TYPE

Reproduzir uma playlist específica ou uma playlist que corresponde a alguns critérios especificados por extras adicionais.

Extras adicionais:

• EXTRA_MEDIA_ALBUM: o álbum.
• EXTRA_MEDIA_ARTIST: o artista.
• "android.intent.extra.genre": o gênero.
• "android.intent.extra.playlist": a playlist.
• EXTRA_MEDIA_TITLE: o nome da música que a playlist é com base.
• QUERY (obrigatório): uma string que contém qualquer combinação. do álbum, do artista, do gênero, da playlist ou do título. Esse extra é sempre fornecidos para compatibilidade com versões anteriores. Apps que não conhecem os modos de pesquisa podem processar essa intenção como uma pesquisa não estruturada.

Exemplo de intent:

Se o usuário quiser ouvir música de um artista específico, um app de pesquisa poderá gerar a seguinte intent:

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

Exemplo de filtro de intent:

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

Ao processar essa intent em sua atividade, verifique o valor do atributo EXTRA_MEDIA_FOCUS extra nas mensagens recebidas Intent para determinar o modo de pesquisa. Depois que sua atividade identificar o modo de pesquisa, leia os valores dos extras adicionais para esse modo de pesquisa específico. Com essas informações, o app pode realizar a pesquisa no inventário para reproduzir o conteúdo que corresponda à consulta de pesquisa. Esta chamada é mostrada no exemplo abaixo.

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

Nova nota

Criar uma nota é uma ação comum em apps de anotações. Crie um filtro de intent para anunciar a capacidade do app de realizar essa ação usando o na seção a seguir.

Criar uma nota

Para criar uma nota, use o ACTION_CREATE_NOTE e especifique os detalhes da observação, como o assunto e o texto, usando os extras a seguir.

Observação:os apps precisam pedir a confirmação do usuário. antes de concluir esta ação.

Ação

ACTION_CREATE_NOTE

Esquema do URI dos dados

Nenhum

Tipo MIME

PLAIN_TEXT_TYPE.

"*/*"

Extras

EXTRA_NAME

Uma string que indica o título ou o assunto da nota.

EXTRA_TEXT

Uma string que indica o texto da nota.

Exemplo de intent:

Kotlin

fun createNote(subject: String, text: String) {
    val intent = Intent(NoteIntents.ACTION_CREATE_NOTE).apply {
        putExtra(NoteIntents.EXTRA_NAME, subject)
        putExtra(NoteIntents.EXTRA_TEXT, text)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void createNote(String subject, String text) {
    Intent intent = new Intent(NoteIntents.ACTION_CREATE_NOTE)
            .putExtra(NoteIntents.EXTRA_NAME, subject)
            .putExtra(NoteIntents.EXTRA_TEXT, text);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Exemplo de filtro de 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>

Smartphone

Iniciar uma chamada é uma ação comum em apps de telefone. Crie um filtro de intent para anunciar a capacidade do app de realizar essa ação usando o na seção a seguir.

Iniciar uma chamada telefônica

Para abrir o app Telefone e discar um número de telefone, use a ação ACTION_DIAL e especifique um número usando o seguinte esquema de URI. Quando o app Telefone é aberto, ele mostra o número do telefone, e o usuário precisa tocar no botão Ligar para iniciar a ligação.

Google Voice Actions

• “telefonar para 555-5555”
• "ligar para bob"
• "ligar para correio de voz"

Para fazer uma ligação diretamente, use a ação ACTION_CALL e especificar um número de telefone usando o seguinte esquema de URI. Quando o app para smartphone é aberto, inicia a chamada. O usuário não precisa tocar no botão Ligar.

A ação ACTION_CALL exige que você adicione o CALL_PHONE para o arquivo de manifesto:

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

Ação

• ACTION_DIAL: abre o discador ou o app Telefone.
• ACTION_CALL: faz uma chamada telefônica (exige o CALL_PHONE)

Esquema do URI dos dados

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

Tipo MIME

Nenhum

Números de telefone válidos são aqueles definidos no IETF RFC 3966. Veja alguns exemplos válidos:

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

O discador do app Telefone faz um bom trabalho na normalização de esquemas, como e números de telefone. Assim, o esquema descrito não é estritamente obrigatório no Uri.parse(). No entanto, se você nunca tentou um esquema ou não tem certeza se ele podem ser processadas, use o método Uri.fromParts() .

Exemplo de intent:

Kotlin

fun dialPhoneNumber(phoneNumber: String) {
    val intent = Intent(Intent.ACTION_DIAL).apply {
        data = Uri.parse("tel:$phoneNumber")
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void dialPhoneNumber(String phoneNumber) {
    Intent intent = new Intent(Intent.ACTION_DIAL);
    intent.setData(Uri.parse("tel:" + phoneNumber));
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Pesquisar

Confira a seguir ações comuns para apps de pesquisa, incluindo as informações necessárias para criar um filtro de intent e anunciar a capacidade do app de realizar cada ação.

Pesquisar usando um aplicativo específico

Google Voice Actions

• "procurar vídeos de gatos em myvideoapp"

Para oferecer suporte à pesquisa no contexto do seu app, declare um filtro de intent no app com a ação SEARCH_ACTION, conforme mostrado no exemplo de filtro de intent abaixo.

Observação:não recomendamos o uso de SEARCH_ACTION para a pesquisa de apps. Em vez disso, implemente GET_THING para aproveitar o suporte integrado do Google Assistente à pesquisa no app. Para mais informações, consulte Google Assistente Ações no app.

Ação

"com.google.android.gms.actions.SEARCH_ACTION"

Oferecer suporte a consultas de pesquisa do Google Voice Actions.

Extras

QUERY

Uma string que contém a consulta de pesquisa.

Exemplo de filtro de 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>

Realizar uma pesquisa na Web

Para iniciar uma pesquisa na Web, use a ação ACTION_WEB_SEARCH e especificar a string de pesquisa na SearchManager.QUERY extra.

Ação

ACTION_WEB_SEARCH

Esquema do URI dos dados

Nenhum

Tipo MIME

Nenhum

Extras

SearchManager.QUERY

A string de pesquisa.

Exemplo de intent:

Kotlin

fun searchWeb(query: String) {
    val intent = Intent(Intent.ACTION_WEB_SEARCH).apply {
        putExtra(SearchManager.QUERY, query)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void searchWeb(String query) {
    Intent intent = new Intent(Intent.ACTION_WEB_SEARCH);
    intent.putExtra(SearchManager.QUERY, query);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Configurações

Para abrir uma tela no app Configurações do sistema quando o app exige que o usuário faça alguma mudança, use uma das seguintes ações de intent:

Ação

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

Para conferir outras telas de configurações disponíveis, consulte a documentação de Settings .

Esquema do URI dos dados

Nenhum

Tipo MIME

Nenhum

Exemplo de intent:

Kotlin

fun openWifiSettings() {
    val intent = Intent(Settings.ACTION_WIFI_SETTINGS)
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void openWifiSettings() {
    Intent intent = new Intent(Settings.ACTION_WIFI_SETTINGS);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Mensagens de texto

Escrever uma mensagem SMS/MMS com um anexo é uma ação comum para apps de mensagens de texto. Crie um filtro de intent para anunciar a capacidade do app de realizar essa ação usando o na seção a seguir.

Compor uma mensagem SMS/MMS com anexo

Para iniciar uma mensagem de texto SMS ou MMS, use uma das seguintes ações da intent e especifique a mensagem como número de telefone, assunto e corpo da mensagem, usando as chaves extras a seguir.

Ação

ACTION_SENDTO ou
ACTION_SEND ou
ACTION_SEND_MULTIPLE

Esquema do URI dos dados

sms:<phone_number>

smsto:<phone_number>

mms:<phone_number>

mmsto:<phone_number>

Todos esses esquemas são tratados da mesma maneira.

Tipo MIME

"text/plain"

"image/*"

"video/*"

Extras

"subject"

Uma string para o assunto da mensagem (geralmente apenas para MMS).

"sms_body"

Uma string para a mensagem de texto.

EXTRA_STREAM

Uma Uri que aponta para imagem ou vídeo para anexar. Se estiver usando a ação ACTION_SEND_MULTIPLE, este extra é um ArrayList de Objetos Uri que apontam para as imagens ou vídeos a serem anexados.

Exemplo de intent:

Kotlin

fun composeMmsMessage(message: String, attachment: Uri) {
    val intent = Intent(Intent.ACTION_SENDTO).apply {
        type = HTTP.PLAIN_TEXT_TYPE
        putExtra("sms_body", message)
        putExtra(Intent.EXTRA_STREAM, attachment)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void composeMmsMessage(String message, Uri attachment) {
    Intent intent = new Intent(Intent.ACTION_SENDTO);
    intent.setType(HTTP.PLAIN_TEXT_TYPE);
    intent.putExtra("sms_body", message);
    intent.putExtra(Intent.EXTRA_STREAM, attachment);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Se quiser garantir que sua intent seja processada somente por um aplicativo de mensagens de texto, e não por outro apps de redes sociais ou e-mail e use a ação ACTION_SENDTO e inclua o esquema de dados "smsto:", conforme mostrado no exemplo a seguir:

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

Exemplo de filtro de 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>

Observação: se você estiver desenvolvendo um app de mensagens SMS/MMS, será necessário implementar filtros de intent para várias ações adicionais a fim de estar disponível como o app de SMS padrão no Android 4.4 e superior. Para mais informações, consulte a documentação às Telephony.

Navegador da Web

Carregar um URL da Web é uma ação comum para apps de navegador da Web. Crie um filtro de intent para anunciar a capacidade do app de realizar essa ação usando o na seção a seguir.

Carregar um URL da Web

Google Voice Actions

• "abrir example.com"

Para abrir uma página da Web, use a ação ACTION_VIEW e especificar o URL da Web nos dados da intent.

Ação

ACTION_VIEW

Esquema do URI dos dados

http:<URL>
https:<URL>

Tipo MIME

"text/plain"

"text/html"

"application/xhtml+xml"

"application/vnd.wap.xhtml+xml"

Exemplo de intent:

Kotlin

fun openWebPage(url: String) {
    val webpage: Uri = Uri.parse(url)
    val intent = Intent(Intent.ACTION_VIEW, webpage)
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void openWebPage(String url) {
    Uri webpage = Uri.parse(url);
    Intent intent = new Intent(Intent.ACTION_VIEW, webpage);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Exemplo de filtro de 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>

Dica:caso seu app Android ofereça uma funcionalidade semelhante à incluem um filtro de intenção para URLs que levam ao site. Depois, se os usuários têm seu app instalado, links de e-mails ou outras páginas da Web que direcionam para seu site abra o app Android em vez da página da Web. Saiba mais em Como processar Links do app Android.

Com o Android 12 (nível 31 da API), intents da Web genéricas são resolvida como uma atividade no app apenas se ele for aprovado para o domínio específico contido na intent. Se o app não for aprovado para o domínio, a Web é resolvida para o app de navegador padrão do usuário.

Verificar intents com o Android Debug Bridge

Para verificar se o app responde aos intents aos quais você quer oferecer compatibilidade, use o a ferramenta adb para disparar intents específicas ao realizar o seguinte:

1. Configurar um dispositivo Android para desenvolvimento ou use um dispositivo virtual.
2. Instale uma versão do aplicativo que processe os intents a que quer oferecer compatibilidade.
3. Dispare uma intent usando adb:

   adb shell am start -a <ACTION> -t <MIME_TYPE> -d <DATA> \
     -e <EXTRA_NAME> <EXTRA_VALUE> -n <ACTIVITY>
   

   Exemplo:

   adb shell am start -a android.intent.action.DIAL \
     -d tel:555-5555 -n org.example.MyApp/.MyActivity
   

4. Se você definir os filtros de intent necessários, processe a intent.

Para mais informações, consulte Emita comandos do shell.