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 sua atividade verifique o extra EXTRA_OUTPUT na Intent recebida e salve a imagem ou o vídeo capturado no local especificado por esse extra. Em seguida, chame setResult() com uma Intent que inclua uma miniatura compactada em um extra chamado "data".

Iniciar um app de câmera no modo de imagem estática

Comandos de voz do Google

• "tirar uma foto"

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

Ação

INTENT_ACTION_STILL_IMAGE_CAMERA

Esquema de URI de 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 app de câmera no modo de vídeo

Comandos de voz do Google

• "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 de URI de 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 de contatos/pessoas

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

Selecione um contato

Para que o usuário selecione um contato e forneça ao app acesso a todas as informações de contato, use a ação ACTION_PICK e especifique o tipo MIME como Contacts.CONTENT_TYPE.

O resultado Intent enviado ao callback onActivityResult() contém o URI content: que aponta para o contato selecionado. A resposta concede ao app permissões temporárias para ler esse contato usando a API Provedor de contatos, mesmo que o app não inclua a permissão READ_CONTACTS.

Dica:se você precisar de acesso apenas a uma informação de contato específica, como um número de telefone ou endereço de e-mail, consulte a próxima seção sobre como selecionar dados de contato específicos.

Ação

ACTION_PICK

Esquema de URI de 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 saber como recuperar detalhes de contato depois de ter o URI do contato, leia Recuperar detalhes de um contato.

Ao recuperar o URI do contato usando essa intent, geralmente não é necessária a permissão READ_CONTACTS para ler detalhes básicos desse contato, como o 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 o número de telefone ou o endereço de e-mail, será necessária a permissão READ_CONTACTS.

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 dado, use a ação ACTION_PICK e especifique o tipo MIME para um dos seguintes tipos de conteúdo, como CommonDataKinds.Phone.CONTENT_TYPE para receber o número de telefone do contato.

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

Se você precisar recuperar apenas um tipo de dado de um contato, essa técnica com um CONTENT_TYPE das classes ContactsContract.CommonDataKinds é mais eficiente do que usar o Contacts.CONTENT_TYPE, conforme mostrado na seção anterior. O resultado oferece acesso direto aos dados desejados sem que você precise realizar uma consulta mais complexa ao Provedor de contatos.

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

Ação

ACTION_PICK

Esquema de URI de 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 CONTENT_TYPE em 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.
            //...
        }
    }
}

Ver um contato

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

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

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

Ação

ACTION_VIEW

Esquema de URI de dados

content:<URI>

Tipo MIME

Nenhuma. O tipo é inferido do 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

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

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

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

Ação

ACTION_EDIT

Esquema de URI de dados

content:<URI>

Tipo MIME

O tipo é inferido do URI do contato.

Extras

Um ou mais dos extras definidos em ContactsContract.Intents.Insert, para que você possa preencher os 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, leia Modificar contatos usando intents.

Inserir um contato

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

Ação

ACTION_INSERT

Esquema de URI de 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 mais informações sobre como inserir um contato, leia Modificar contatos usando intents.

E-mail

Escrever um e-mail com anexos opcionais é uma ação comum em apps de e-mail. Crie um filtro de intent para anunciar que seu app pode realizar essa ação usando as informações na seção a seguir.

Escrever um e-mail com anexos opcionais

Para escrever um e-mail, use uma das seguintes ações, dependendo se você vai 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 de URI de dados

Nenhum

Tipo MIME

"text/plain"

"*/*"

Extras

Intent.EXTRA_EMAIL

Uma matriz de strings de todos os endereços de e-mail dos destinatários no campo "Para".

Intent.EXTRA_CC

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

Intent.EXTRA_BCC

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

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 a ação ACTION_SEND_MULTIPLE, será um ArrayList que contém 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 você quiser garantir que a intent seja processada apenas por um app de e-mails, e não por um app de mensagens de texto ou de aplicativos sociais, use a ação ACTION_SENDTO e inclua o esquema de dados "mailto:", como 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 as ações comuns para apps de armazenamento de arquivos, incluindo as informações necessárias para criar um filtro de intent que divulgue 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 uma foto, e retorne uma referência ao seu app, use a ação ACTION_GET_CONTENT e especifique o tipo MIME desejado. A referência de arquivo retornada ao app é temporária para o ciclo de vida atual da atividade. Portanto, se você quiser acessá-la mais tarde, importe uma cópia que possa ser lida depois.

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

A intent de resultado enviada 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:. No entanto, se você quiser restringir os arquivos selecionáveis apenas àqueles que podem ser acessados por um provedor de conteúdo (um URI content:) e que estão disponíveis como um stream de arquivos com openFileDescriptor(), adicione a categoria CATEGORY_OPENABLE à intent.

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

Ação

ACTION_GET_CONTENT

Esquema de URI de 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 por vez.

EXTRA_LOCAL_ONLY

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

Categoria (opcional)

CATEGORY_OPENABLE

Para retornar apenas arquivos "abertos" 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 específico de arquivo

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 mais recente, você pode solicitar a abertura de um arquivo gerenciado por outro app 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 possa gravar, use a ação ACTION_CREATE_DOCUMENT.

Por exemplo, em vez de selecionar documentos PDF, a intent ACTION_CREATE_DOCUMENT permite que os usuários selecionem onde querem criar um novo documento, como em outro app que gerencia o armazenamento do documento. Em seguida, o app recebe o local do URI em que pode gravar o novo documento.

Enquanto a intent enviada ao método 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 especifica o arquivo escolhido como um URI content: que tem o suporte de um DocumentsProvider. É possível abrir o arquivo com openFileDescriptor() e consultar os detalhes usando colunas de DocumentsContract.Document.

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

Também é possível permitir que o usuário selecione vários arquivos adicionando EXTRA_ALLOW_MULTIPLE à intent, definida como true. Se o usuário selecionar apenas um item, você poderá recuperá-lo de getData(). Se o usuário selecionar mais de um item, getData() vai retornar nulo, e você vai precisar recuperar cada item de um objeto ClipData retornado por getClipData().

Observação:a intent precisa especificar um tipo MIME e precisa declarar a categoria CATEGORY_OPENABLE. Se apropriado, é possível especificar mais de um tipo MIME adicionando uma matriz de tipos MIME com o extra EXTRA_MIME_TYPES. Se você fizer isso, defina o tipo MIME principal em setType() como "*/*".

Ação

ACTION_OPEN_DOCUMENT ou
ACTION_CREATE_DOCUMENT

Esquema de URI de 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 correspondentes aos tipos de arquivos que o app está solicitando. Ao usar esse extra, você precisa definir o tipo MIME principal em setType() como "*/*".

EXTRA_ALLOW_MULTIPLE

Um booleano que declara se o usuário pode selecionar mais de um arquivo por vez.

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 no dispositivo, em vez de exigir um download de um serviço remoto.

Categoria

CATEGORY_OPENABLE

Para retornar apenas arquivos "abertos" que podem ser representados como um fluxo 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.
        ...
    }
}

Os apps de terceiros não podem responder a uma intent com a ação ACTION_OPEN_DOCUMENT. Em vez disso, o sistema recebe essa intent e mostra todos os arquivos disponíveis de vários apps em uma interface do usuário unificada.

Para fornecer os arquivos do seu app nessa IU e permitir que outros apps os abram, implemente um DocumentsProvider e inclua um filtro de intent para PROVIDER_INTERFACE ("android.content.action.DOCUMENTS_PROVIDER"), como 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 saber mais sobre como permitir que os arquivos gerenciados pelo seu app sejam abertos por 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 intent para anunciar a capacidade do app de realizar essa ação usando as informações da seção a seguir.

Chamar um taxi

Comandos de voz do Google

• "chame um táxi para mim"
• "chame um carro para mim"

(somente Wear OS)

Para chamar um táxi, use a ação ACTION_RESERVE_TAXI_RESERVATION.

Observação:os apps precisam pedir a confirmação do usuário antes de concluir essa 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>

Maps

Mostrar um local em um mapa é uma ação comum para apps de mapas. Crie um filtro de intent para anunciar que seu app pode realizar essa ação usando as informações na seção a seguir.

Mostrar 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 de URI de dados

geo:latitude,longitude

Mostra o mapa na longitude e latitude informadas.

Exemplo: "geo:47.6,-122.3"

geo:latitude,longitude?z=zoom

Mostra o mapa na longitude e latitude fornecidas em um determinado nível de zoom. Um nível de zoom de 1 mostra toda a Terra, centralizada na lat,lng fornecida. O nível de zoom mais alto (mais próximo) é 23.

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

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

Mostra o mapa na longitude e latitude especificadas com um marcador de string.

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

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

Mostra o local 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 codificadas. 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ídos 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 as ações comuns para apps de música e vídeo, incluindo as informações necessárias para criar um filtro de intent que divulgue a capacidade do app de realizar cada ação.

Abrir um arquivo de mídia

Para tocar 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 de URI de dados

file:<URI>

content:<URI>

http:<URL>

Tipo MIME

"audio/*"

"application/ogg"

"application/x-ogg"

"application/itunes"

Ou qualquer outra que seu 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>

Tocar músicas com base em uma consulta de pesquisa

Comandos de voz do Google

• "tocar billie jean do michael jackson"

Para tocar músicas com base em uma consulta de pesquisa, use a intent INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH. Um app pode disparar essa intent em resposta ao comando de voz do usuário para tocar música. O app que recebe essa intent realiza uma pesquisa no inventário para encontrar conteúdo que corresponda à consulta fornecida e inicia a reprodução desse conteúdo.

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

Ação

INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH

Esquema de URI de dados

Nenhum

Tipo MIME

Nenhum

Extras

MediaStore.EXTRA_MEDIA_FOCUS (obrigatório)

Indica o modo de pesquisa: se o usuário está procurando um artista, álbum, música ou playlist específico. A maioria dos modos de pesquisa aceita extras adicionais. Por exemplo, se o usuário quiser ouvir uma música específica, a intent poderá 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: "vnd.android.cursor.item/*"

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

Extras:

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

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

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

Extras:

• 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

Tocar músicas de um gênero específico.

Extras:

• "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. Os 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

Tocar músicas de um artista específico.

Extras:

• 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 do artista ou do gênero. Esse extra é sempre fornecido para compatibilidade com versões anteriores. Os apps que não conhecem os modos de pesquisa podem processar essa intent como uma pesquisa não estruturada.

Álbum: Audio.Albums.ENTRY_CONTENT_TYPE

Tocar músicas de um álbum específico.

Extras:

• 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 do álbum ou do artista. Esse extra é sempre fornecido para compatibilidade com versões anteriores. Os apps que não conhecem os modos de pesquisa podem processar essa intent como uma pesquisa não estruturada.

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

Tocar uma música específica.

Extras:

• 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 compatibilidade com versões anteriores. Os apps que não conhecem os modos de pesquisa podem processar essa intent como uma pesquisa não estruturada.

Playlist: Audio.Playlists.ENTRY_CONTENT_TYPE

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

Extras:

• 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 em que a playlist é baseada.
• QUERY (obrigatório): uma string que contém qualquer combinação de álbum, artista, gênero, playlist ou título. Esse extra é sempre fornecido para compatibilidade com versões anteriores. Os apps que não conhecem os modos de pesquisa podem processar essa intent como uma pesquisa não estruturada.

Exemplo de intent:

Se o usuário quiser ouvir músicas 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 na sua atividade, verifique o valor do extra EXTRA_MEDIA_FOCUS na Intent recebida para determinar o modo de pesquisa. Depois que a atividade identificar o modo de pesquisa, leia os valores dos extras adicionais para esse modo específico. Com essas informações, o app pode realizar a pesquisa no inventário para reproduzir o conteúdo que corresponde à 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 para apps de anotações. Crie um filtro de intent para anunciar que seu app pode realizar essa ação usando as informações na seção a seguir.

Criar uma nota

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

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

Ação

ACTION_CREATE_NOTE

Esquema de URI de 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>

Telefone

Iniciar uma chamada é uma ação comum para o app Telefone. Crie um filtro de intent para anunciar que seu app pode realizar essa ação usando as informações na seção a seguir.

Iniciar uma chamada telefônica

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

Comandos de voz do Google

• "ligar para 555-5555"
• "ligar para o Beto"
• "ligar para o correio de voz"

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

A ação ACTION_CALL exige que você adicione a permissão CALL_PHONE ao 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 ligação (requer a permissão CALL_PHONE).

Esquema de URI de dados

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

Tipo MIME

Nenhum

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

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

O discador do app Telefone é bom para normalizar esquemas, como números de telefone. Portanto, o esquema descrito não é estritamente necessário no método Uri.parse(). No entanto, se você não tiver testado um esquema ou não tiver certeza se ele pode ser processado, 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

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

Pesquisar usando um app específico

Comandos de voz do Google

• "pesquisar vídeos de gatos no meuappdevídeo"

Para oferecer suporte à pesquisa no contexto do seu app, declare um filtro de intent 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 pesquisa de apps. Em vez disso, implemente a ação GET_THING para aproveitar o suporte integrado do Google Assistente para pesquisa no app. Para mais informações, consulte a documentação das Ações no app do Google Assistente.

Ação

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

Oferecer suporte a consultas de pesquisa dos Comandos de Voz do Google.

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>

Fazer uma pesquisa na Web

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

Ação

ACTION_WEB_SEARCH

Esquema de URI de 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 exigir que o usuário mude algo, 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 ver outras telas de configurações disponíveis, consulte a documentação de Settings .

Esquema de URI de 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 que seu app pode realizar essa ação usando as informações na seção a seguir.

Escrever uma mensagem SMS/MMS com anexo

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

Ação

ACTION_SENDTO ou
ACTION_SEND ou
ACTION_SEND_MULTIPLE

Esquema de URI de dados

sms:<phone_number>

smsto:<phone_number>

mms:<phone_number>

mmsto:<phone_number>

Todos esses esquemas são processados da mesma forma.

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 a imagem ou o vídeo a ser anexado. Se você usar a ação ACTION_SEND_MULTIPLE, esse extra será um ArrayList de objetos Uri que apontam para as imagens ou os 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 você quiser garantir que a intent seja processada apenas por um app de mensagens de texto, e não por outros apps de e-mail ou aplicativos sociais, 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 outras ações para que ele esteja disponível como o app de SMS padrão no Android 4.4 e versões mais recentes. Para mais informações, consulte a documentação em 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 que seu app pode realizar essa ação usando as informações na seção a seguir.

Carregar um URL da Web

Comandos de voz do Google

• "abrir example.com"

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

Ação

ACTION_VIEW

Esquema de URI de 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:se o app Android oferecer uma funcionalidade semelhante à do seu site, inclua um filtro de intent para URLs que apontem para o site. Em seguida, se os usuários tiverem seu app instalado, os links de e-mails ou outras páginas da Web que apontam para seu site vão abrir 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 intent da Web será resolvida para o app de navegador padrão do usuário.

Verificar intents com o Android Debug Bridge

Para verificar se o app responde às intents que você quer usar, use a ferramenta adb para disparar intents específicas. Para isso, faça o seguinte:

1. Configure um dispositivo Android para desenvolvimento ou use um dispositivo virtual.
2. Instale uma versão do app que processe as intents que você quer usar.
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 Emitir comandos do shell.