Intents comuns

Uma intent permite que você inicie uma atividade em outro aplicativo descrevendo uma ação que você gostaria de realizar, como "ver um mapa" ou "fazer uma imagem", em um objeto Intent. Esse tipo de intenção é chamada de intent implícita porque não especifica o app seja iniciado, mas especifica uma ação e fornece alguns dados com os quais realizar a ação.

Quando você ligar para startActivity() ou startActivityForResult() e transmitir uma intent implícita, o sistema resolve a intent para um app que pode processar a intent e iniciar a Activity correspondente. Se houver mais de um app que pode processar o intent, o sistema apresenta ao usuário uma caixa de diálogo para escolher qual app usar.

Esta página descreve várias intents implícitas que podem ser usadas para executar ações comuns, organizadas pelo tipo de app que processa a intent. Cada também mostra como criar uma intent filtro para anunciar a capacidade do app de realizar a ação.

Atenção:se não houver apps no dispositivo que possam receber uma intent implícita, um app falhará ao chamar startActivity(). Para verificar primeiro se um app existir para receber a intent, chame resolveActivity() no objeto Intent. Se o resultado não for nulo, há pelo menos um app que pode processar a intent, e é seguro chamar startActivity(). Se o resultado for nulo, não use a intent e, se possível, desative o recurso que a invoca.

Se você não sabe como criar intents ou filtros de intents, leia primeiro Intents e intents. Filtros.

Para saber como disparar as intents listadas nesta página do código de host, consulte a página Verificar intents com o Android Debug Ponte.

Google Voice Actions

O Google Voice Actions aciona algumas das intenções listadas nesta página em resposta a comandos de voz. Para obter mais informações, consulte Introdução às Comandos de voz do sistema.

Despertador

A seguir estão ações comuns para aplicativos de despertador, incluindo as informações de que você precisa para criar um filtro de intent e anunciar a capacidade do app de realizar cada ação.

Criar um despertador

Google Voice Actions

  • "defina um alarme para 7h"

Para criar um novo alarme, use o ACTION_SET_ALARM e especificar detalhes do alarme, como a hora e a mensagem, usando os extras a seguir.

Observação:somente os extras de hora, minutos e mensagem estão disponíveis no Android 2.3 (API de nível 9) e anteriores. Os outros extras estão disponíveis em versões mais recentes de plataforma.

Ação
ACTION_SET_ALARM
URI de dados
Nenhum
Tipo MIME
Nenhum
Extras
EXTRA_HOUR
A hora do alarme.
EXTRA_MINUTES
Os minutos do alarme.
EXTRA_MESSAGE
Uma mensagem personalizada para identificar o alarme.
EXTRA_DAYS
Uma ArrayList incluindo cada dia da semana em que esse alarme se repete. Cada dia precisa ser declarado com um número inteiro da Calendar. classe, como MONDAY.

Para um alarme único, não especifique esse extra.

EXTRA_RINGTONE
Um URI content: que especifica um toque a ser usado com o alarme ou VALUE_RINGTONE_SILENT para nenhum toque.

Para usar o toque padrão, não especifique esse extra.

EXTRA_VIBRATE
Um booleano especificando se quer vibrar para esse alarme.
EXTRA_SKIP_UI
É um booleano especificando se o app que responde precisa pular a interface ao definir o alarme. Se verdadeiro, o app precisa ignorar qualquer interface de confirmação e definir o alarme especificado.

Exemplo de intent:

Kotlin

fun createAlarm(message: String, hour: Int, minutes: Int) {
    val intent = Intent(AlarmClock.ACTION_SET_ALARM).apply {
        putExtra(AlarmClock.EXTRA_MESSAGE, message)
        putExtra(AlarmClock.EXTRA_HOUR, hour)
        putExtra(AlarmClock.EXTRA_MINUTES, minutes)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void createAlarm(String message, int hour, int minutes) {
    Intent intent = new Intent(AlarmClock.ACTION_SET_ALARM)
            .putExtra(AlarmClock.EXTRA_MESSAGE, message)
            .putExtra(AlarmClock.EXTRA_HOUR, hour)
            .putExtra(AlarmClock.EXTRA_MINUTES, minutes);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}
Observação:

Para invocar a intent ACTION_SET_ALARM, seu app precisa ter o Permissão SET_ALARM:

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

Exemplo de filtro de intent:

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

Criar um timer

Google Voice Actions

  • "definir timer de 5 minutos"

Para criar um timer de contagem regressiva, use a ação ACTION_SET_TIMER e especifique os detalhes do timer, como a duração, usando os seguintes extras.

Observação:essa intent está disponível no Android 4.4 (nível 19 da API) e versões mais recentes.

Ação
ACTION_SET_TIMER
URI de dados
Nenhum
Tipo MIME
Nenhum
Extras
EXTRA_LENGTH
A duração do timer em segundos.
EXTRA_MESSAGE
Uma mensagem personalizada para identificar o timer.
EXTRA_SKIP_UI
É um booleano especificando se o app que responde precisa pular a interface ao definir o timer. Se verdadeiro, o app precisa ignorar qualquer interface de confirmação e iniciar o timer especificado.

Exemplo de intent:

Kotlin

fun startTimer(message: String, seconds: Int) {
    val intent = Intent(AlarmClock.ACTION_SET_TIMER).apply {
        putExtra(AlarmClock.EXTRA_MESSAGE, message)
        putExtra(AlarmClock.EXTRA_LENGTH, seconds)
        putExtra(AlarmClock.EXTRA_SKIP_UI, true)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void startTimer(String message, int seconds) {
    Intent intent = new Intent(AlarmClock.ACTION_SET_TIMER)
            .putExtra(AlarmClock.EXTRA_MESSAGE, message)
            .putExtra(AlarmClock.EXTRA_LENGTH, seconds)
            .putExtra(AlarmClock.EXTRA_SKIP_UI, true);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}
Observação:

Para invocar a intent ACTION_SET_TIMER, seu app precisa ter a Permissão SET_ALARM:

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

Exemplo de filtro de intent:

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

Exibir todos os alarmes

Para mostrar a lista de alarmes, use o ACTION_SHOW_ALARMS à ação.

Embora poucos apps invoquem essa intent, já que ela é usada principalmente por apps do sistema, qualquer aplicativo que se comporte como um despertador pode implementar esse filtro de intent e responder mostrando a lista de alarmes atuais.

Observação: essa intent está disponível no Android 4.4 (nível 19 da API) e versões mais recentes.

Ação
ACTION_SHOW_ALARMS
URI de dados
Nenhum
Tipo MIME
Nenhum

Exemplo de filtro de intent:

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

Agenda

Adicionar um evento é uma ação comum para apps de agenda. Crie um filtro de intent para anunciar a capacidade do app de realizar essa ação usando o na seção a seguir.

Adicionar um evento à agenda

Para adicionar um novo evento à agenda do usuário, use a ação ACTION_INSERT e especifique o URI dos dados usando Events.CONTENT_URI. Depois, você pode especificar vários detalhes do evento usando os extras a seguir.

Ação
ACTION_INSERT
URI de dados
Events.CONTENT_URI
Tipo MIME
"vnd.android.cursor.dir/event"
Extras
EXTRA_EVENT_ALL_DAY
É um booleano especificando se é um evento de dia inteiro.
EXTRA_EVENT_BEGIN_TIME
É o horário de início do evento (milissegundos desde a época).
EXTRA_EVENT_END_TIME
É o horário de término do evento (milissegundos desde a época).
TITLE
O título do evento.
DESCRIPTION
A descrição do evento.
EVENT_LOCATION
O local do evento.
EXTRA_EMAIL
Uma lista separada por vírgulas de endereços de e-mail que especificam os convidados.

Muitos outros detalhes do evento podem ser especificados usando as constantes definidas no CalendarContract.EventsColumns.

Exemplo de intent:

Kotlin

fun addEvent(title: String, location: String, begin: Long, end: Long) {
    val intent = Intent(Intent.ACTION_INSERT).apply {
        data = Events.CONTENT_URI
        putExtra(Events.TITLE, title)
        putExtra(Events.EVENT_LOCATION, location)
        putExtra(CalendarContract.EXTRA_EVENT_BEGIN_TIME, begin)
        putExtra(CalendarContract.EXTRA_EVENT_END_TIME, end)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void addEvent(String title, String location, long begin, long end) {
    Intent intent = new Intent(Intent.ACTION_INSERT)
            .setData(Events.CONTENT_URI)
            .putExtra(Events.TITLE, title)
            .putExtra(Events.EVENT_LOCATION, location)
            .putExtra(CalendarContract.EXTRA_EVENT_BEGIN_TIME, begin)
            .putExtra(CalendarContract.EXTRA_EVENT_END_TIME, end);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Exemplo de filtro de intent:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.INSERT" />
        <data android:mimeType="vnd.android.cursor.dir/event" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Câmera

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

Capturar uma imagem ou um vídeo e retorná-lo

Para abrir um app de câmera e receber a foto ou o vídeo resultante, use a ação ACTION_IMAGE_CAPTURE ou ACTION_VIDEO_CAPTURE. Especifique também o local da URI em que a câmera deve salvar a foto ou o vídeo no extra EXTRA_OUTPUT.

Ação
ACTION_IMAGE_CAPTURE ou
ACTION_VIDEO_CAPTURE
Esquema do URI dos dados
Nenhum
Tipo MIME
Nenhum
Extras
EXTRA_OUTPUT
O local do URI em que o app de câmera salva a foto ou arquivo de vídeo (como um objeto Uri).

Quando o app de câmera retornar sua atividade. Em outras palavras, o app recebe o callback onActivityResult(). pode acessar a foto ou o vídeo no URI especificado com o valor EXTRA_OUTPUT.

Observação:ao usar ACTION_IMAGE_CAPTURE para capturar uma foto, a câmera também pode retornar cópia reduzida, ou miniatura, da foto no resultado Intent, salva como Bitmap em um campo extra chamado "data".

Exemplo de intent:

Kotlin

const val REQUEST_IMAGE_CAPTURE = 1
val locationForPhotos: Uri = ...

fun capturePhoto(targetFilename: String) {
    val intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE).apply {
        putExtra(MediaStore.EXTRA_OUTPUT, Uri.withAppendedPath(locationForPhotos, targetFilename))
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivityForResult(intent, REQUEST_IMAGE_CAPTURE)
    }
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == Activity.RESULT_OK) {
        val thumbnail: Bitmap = data.getParcelableExtra("data")
        // Do other work with full size photo saved in locationForPhotos.
        ...
    }
}

Java

static final int REQUEST_IMAGE_CAPTURE = 1;
static final Uri locationForPhotos;

public void capturePhoto(String targetFilename) {
    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    intent.putExtra(MediaStore.EXTRA_OUTPUT,
            Uri.withAppendedPath(locationForPhotos, targetFilename));
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivityForResult(intent, REQUEST_IMAGE_CAPTURE);
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == RESULT_OK) {
        Bitmap thumbnail = data.getParcelableExtra("data");
        // Do other work with full size photo saved in locationForPhotos.
        ...
    }
}

Para fazer isso ao trabalhar no Android 12 (nível 31 da API) ou versões mais recentes, consulte o exemplo de intent abaixo.

Exemplo de intent:

Kotlin

val REQUEST_IMAGE_CAPTURE = 1

private fun dispatchTakePictureIntent() {
    val takePictureIntent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
    try {
        startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE)
    } catch (e: ActivityNotFoundException) {
        // Display error state to the user.
    }
}

Java

static final int REQUEST_IMAGE_CAPTURE = 1;

private void dispatchTakePictureIntent() {
    Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    try {
        startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE);
    } catch (ActivityNotFoundException e) {
        // Display error state to the user.
    }
}
</section></div>

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 de dados
Nenhum
Tipo MIME
Nenhum
Extras
Nenhum

Exemplo de intent:

Kotlin

private fun dispatchTakePictureIntent() {
    val takePictureIntent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
    try {
        startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE)
    } catch (e: ActivityNotFoundException) {
        // Display error state to the user.
    }
}

Java

public void capturePhoto(String targetFilename) {
    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    intent.putExtra(MediaStore.EXTRA_OUTPUT,
            Uri.withAppendedPath(locationForPhotos, targetFilename));
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivityForResult(intent, REQUEST_IMAGE_CAPTURE);
    }
}

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 de dados
Nenhum
Tipo MIME
Nenhum
Extras
Nenhum

Exemplo de intent:

Kotlin

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

Java

public void capturePhoto() {
    Intent intent = new Intent(MediaStore.INTENT_ACTION_VIDEO_CAMERA);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivityForResult(intent, REQUEST_IMAGE_CAPTURE);
    }
}

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 acessar apenas uma informação de contato, como número de telefone ou endereço de e-mail, consulte a próxima seção sobre como selecionar dados específicos de contatos.

Ação
ACTION_PICK
Esquema do URI de dados
Nenhum
Tipo MIME
Contacts.CONTENT_TYPE

Exemplo de intent:

Kotlin

const val REQUEST_SELECT_CONTACT = 1

fun selectContact() {
    val intent = Intent(Intent.ACTION_PICK).apply {
        type = ContactsContract.Contacts.CONTENT_TYPE
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivityForResult(intent, REQUEST_SELECT_CONTACT)
    }
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    if (requestCode == REQUEST_SELECT_CONTACT && resultCode == RESULT_OK) {
        val contactUri: Uri = data.data
        // Do something with the selected contact at contactUri.
        //...
    }
}

Java

static final int REQUEST_SELECT_CONTACT = 1;

public void selectContact() {
    Intent intent = new Intent(Intent.ACTION_PICK);
    intent.setType(ContactsContract.Contacts.CONTENT_TYPE);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivityForResult(intent, REQUEST_SELECT_CONTACT);
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_SELECT_CONTACT && resultCode == RESULT_OK) {
        Uri contactUri = data.getData();
        // Do something with the selected contact at contactUri.
        ...
    }
}

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

Ao recuperar 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 o número de telefone ou o endereço de e-mail, será necessário ter a permissão READ_CONTACTS.

Selecionar dados de contato específicos

Para fazer com que o usuário selecione uma informação específica de um contato, como 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 como um dos tipos de conteúdo abaixo, como CommonDataKinds.Phone.CONTENT_TYPE para receber 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 permissões temporárias ao app para ler os dados do contato, mesmo que ele não inclua a permissão READ_CONTACTS.

Ação
ACTION_PICK
Esquema do 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 de CONTENT_TYPE em ContactsContract.

Exemplo de intent:

Kotlin

const val REQUEST_SELECT_PHONE_NUMBER = 1

fun selectContact() {
    // Start an activity for the user to pick a phone number from contacts.
    val intent = Intent(Intent.ACTION_PICK).apply {
        type = CommonDataKinds.Phone.CONTENT_TYPE
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivityForResult(intent, REQUEST_SELECT_PHONE_NUMBER)
    }
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    if (requestCode == REQUEST_SELECT_PHONE_NUMBER && resultCode == Activity.RESULT_OK) {
        // Get the URI and query the content provider for the phone number.
        val contactUri: Uri = data.data
        val projection: Array<String> = arrayOf(CommonDataKinds.Phone.NUMBER)
        contentResolver.query(contactUri, projection, null, null, null).use { cursor ->
            // If the cursor returned is valid, get the phone number.
            if (cursor.moveToFirst()) {
                val numberIndex = cursor.getColumnIndex(CommonDataKinds.Phone.NUMBER)
                val number = cursor.getString(numberIndex)
                // Do something with the phone number.
                ...
            }
        }
    }
}

Java

static final int REQUEST_SELECT_PHONE_NUMBER = 1;

public void selectContact() {
    // Start an activity for the user to pick a phone number from contacts.
    Intent intent = new Intent(Intent.ACTION_PICK);
    intent.setType(CommonDataKinds.Phone.CONTENT_TYPE);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivityForResult(intent, REQUEST_SELECT_PHONE_NUMBER);
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_SELECT_PHONE_NUMBER && resultCode == RESULT_OK) {
        // Get the URI and query the content provider for the phone number.
        Uri contactUri = data.getData();
        String[] projection = new String[]{CommonDataKinds.Phone.NUMBER};
        Cursor cursor = getContentResolver().query(contactUri, projection,
                null, null, null);
        // If the cursor returned is valid, get the phone number.
        if (cursor != null && cursor.moveToFirst()) {
            int numberIndex = cursor.getColumnIndex(CommonDataKinds.Phone.NUMBER);
            String number = cursor.getString(numberIndex);
            // Do something with the phone number.
            //...
        }
    }
}

Visualizar 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 do 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 o READ_CONTACTS permissão.
Ação
ACTION_VIEW
Esquema do URI de dados
content:<URI>
Tipo MIME
Nenhum. O tipo é inferido com base no URI do contato.

Exemplo de intent:

Kotlin

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

Java

public void viewContact(Uri contactUri) {
    Intent intent = new Intent(Intent.ACTION_VIEW, contactUri);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Editar um contato atual

Para editar um contato conhecido, use a ação ACTION_EDIT, especifique o contato com um URI content: como os dados do intent e inclua todas as informações do contato conhecido 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.
  • Acesse diretamente a lista de todos os contatos, conforme descrito em Recuperar uma lista de contatos. Essa abordagem requer a permissão READ_CONTACTS.
Ação
ACTION_EDIT
Esquema do URI de 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:

Kotlin

fun editContact(contactUri: Uri, email: String) {
    val intent = Intent(Intent.ACTION_EDIT).apply {
        data = contactUri
        putExtra(ContactsContract.Intents.Insert.EMAIL, email)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void editContact(Uri contactUri, String email) {
    Intent intent = new Intent(Intent.ACTION_EDIT);
    intent.setData(contactUri);
    intent.putExtra(Intents.Insert.EMAIL, email);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

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 de dados
Nenhum
Tipo MIME
Contacts.CONTENT_TYPE
Extras
Um ou mais dos extras definidos em ContactsContract.Intents.Insert.

Exemplo de intent:

Kotlin

fun insertContact(name: String, email: String) {
    val intent = Intent(Intent.ACTION_INSERT).apply {
        type = ContactsContract.Contacts.CONTENT_TYPE
        putExtra(ContactsContract.Intents.Insert.NAME, name)
        putExtra(ContactsContract.Intents.Insert.EMAIL, email)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void insertContact(String name, String email) {
    Intent intent = new Intent(Intent.ACTION_INSERT);
    intent.setType(Contacts.CONTENT_TYPE);
    intent.putExtra(Intents.Insert.NAME, name);
    intent.putExtra(Intents.Insert.EMAIL, email);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

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 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 endereços de e-mail de destinatários "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 o ACTION_SEND_MULTIPLE ação, esta é uma ArrayList contendo vários objetos Uri.

Exemplo de intent:

Kotlin

fun composeEmail(addresses: Array<String>, subject: String, attachment: Uri) {
    val intent = Intent(Intent.ACTION_SEND).apply {
        type = "*/*"
        putExtra(Intent.EXTRA_EMAIL, addresses)
        putExtra(Intent.EXTRA_SUBJECT, subject)
        putExtra(Intent.EXTRA_STREAM, attachment)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void composeEmail(String[] addresses, String subject, Uri attachment) {
    Intent intent = new Intent(Intent.ACTION_SEND);
    intent.setType("*/*");
    intent.putExtra(Intent.EXTRA_EMAIL, addresses);
    intent.putExtra(Intent.EXTRA_SUBJECT, subject);
    intent.putExtra(Intent.EXTRA_STREAM, attachment);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

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

Kotlin

fun composeEmail(addresses: Array<String>, subject: String) {
    val intent = Intent(Intent.ACTION_SENDTO).apply {
        data = Uri.parse("mailto:") // Only email apps handle this.
        putExtra(Intent.EXTRA_EMAIL, addresses)
        putExtra(Intent.EXTRA_SUBJECT, subject)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void composeEmail(String[] addresses, String subject) {
    Intent intent = new Intent(Intent.ACTION_SENDTO);
    intent.setData(Uri.parse("mailto:")); // Only email apps handle this.
    intent.putExtra(Intent.EXTRA_EMAIL, addresses);
    intent.putExtra(Intent.EXTRA_SUBJECT, subject);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

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.

O 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 sejam acessíveis de um provedor de conteúdo (um URI content:) e que estejam disponíveis como uma transmissão de arquivo com openFileDescriptor(), adicione 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 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 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 conseguir uma foto:

Kotlin

const val REQUEST_IMAGE_GET = 1

fun selectImage() {
    val intent = Intent(Intent.ACTION_GET_CONTENT).apply {
        type = "image/*"
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivityForResult(intent, REQUEST_IMAGE_GET)
    }
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    if (requestCode == REQUEST_IMAGE_GET && resultCode == Activity.RESULT_OK) {
        val thumbnail: Bitmap = data.getParcelableExtra("data")
        val fullPhotoUri: Uri = data.data
        // Do work with photo saved at fullPhotoUri.
        ...
    }
}

Java

static final int REQUEST_IMAGE_GET = 1;

public void selectImage() {
    Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
    intent.setType("image/*");
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivityForResult(intent, REQUEST_IMAGE_GET);
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_IMAGE_GET && resultCode == RESULT_OK) {
        Bitmap thumbnail = data.getParcelable("data");
        Uri fullPhotoUri = data.getData();
        // Do work with photo saved at fullPhotoUri.
        ...
    }
}

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 precisa ser importado no app, use a ação ACTION_GET_CONTENT. Ao executar no Android 4.4 ou mais recente, é possível 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 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 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 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 conseguir uma foto:

Kotlin

const val REQUEST_IMAGE_OPEN = 1

fun selectImage2() {
    val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
        type = "image/*"
        addCategory(Intent.CATEGORY_OPENABLE)
    }
    // Only the system receives the ACTION_OPEN_DOCUMENT, so no need to test.
    startActivityForResult(intent, REQUEST_IMAGE_OPEN)
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    if (requestCode == REQUEST_IMAGE_OPEN && resultCode == Activity.RESULT_OK) {
        val fullPhotoUri: Uri = data.data
        // Do work with full size photo saved at fullPhotoUri.
        ...
    }
}

Java

static final int REQUEST_IMAGE_OPEN = 1;

public void selectImage() {
    Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
    intent.setType("image/*");
    intent.addCategory(Intent.CATEGORY_OPENABLE);
    // Only the system receives the ACTION_OPEN_DOCUMENT, so no need to test.
    startActivityForResult(intent, REQUEST_IMAGE_OPEN);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_IMAGE_OPEN && resultCode == RESULT_OK) {
        Uri fullPhotoUri = data.getData();
        // Do work with full size photo saved at fullPhotoUri.
        ...
    }
}

Os apps de terceiros não podem responder a uma intent com a ação 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

  • "Peça um táxi"
  • "chamar um carro"

(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 esta ação.

Ação
ACTION_RESERVE_TAXI_RESERVATION
URI de dados
Nenhum
Tipo MIME
Nenhum
Extras
Nenhum

Exemplo de intent:

Kotlin

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

Java

public void callCar() {
    Intent intent = new Intent(ReserveIntents.ACTION_RESERVE_TAXI_RESERVATION);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

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 de 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 a Terra inteira, com centro na lat,lng informadas. A maior (mais próximo) é 23.

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

geo:0,0?q=lat,lng(label)
Exibe o mapa na longitude e na latitude dadas 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:

Kotlin

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

Java

public void showMap(Uri geoLocation) {
    Intent intent = new Intent(Intent.ACTION_VIEW);
    intent.setData(geoLocation);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

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 a seguir ações comuns para apps de música e vídeo, incluindo as informações necessárias para criar um filtro de intents para 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 de 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:

Kotlin

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

Java

public void playMedia(Uri file) {
    Intent intent = new Intent(Intent.ACTION_VIEW);
    intent.setData(file);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

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 disparar essa intent em resposta ao comando de voz do usuário para reproduzir música. O app que recebe esse intent executa uma pesquisa no inventário para corresponder o conteúdo existente à consulta dada e começa a reproduzir o 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 de 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. Os apps existentes que não sabem da existência de modos de pesquisa podem processar essa intent 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 conseguem identificar o tipo de conteúdo que o usuário quer 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. Os apps existentes que não sabem da existência de 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. Os apps existentes que não sabem da existência de modos de pesquisa podem processar essa intent como uma pesquisa não estruturada.

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 de álbum, artista, gênero, playlist ou título. Esse extra é sempre fornecido 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:

Kotlin

fun playSearchArtist(artist: String) {
    val intent = Intent(MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH).apply {
        putExtra(MediaStore.EXTRA_MEDIA_FOCUS, MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE)
        putExtra(MediaStore.EXTRA_MEDIA_ARTIST, artist)
        putExtra(SearchManager.QUERY, artist)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void playSearchArtist(String artist) {
    Intent intent = new Intent(MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH);
    intent.putExtra(MediaStore.EXTRA_MEDIA_FOCUS,
                    MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE);
    intent.putExtra(MediaStore.EXTRA_MEDIA_ARTIST, artist);
    intent.putExtra(SearchManager.QUERY, artist);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

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

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    ...
    if (intent.action.compareTo(MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH) == 0) {

        val mediaFocus: String? = intent.getStringExtra(MediaStore.EXTRA_MEDIA_FOCUS)
        val query: String? = intent.getStringExtra(SearchManager.QUERY)

        // Some of these extras might not be available depending on the search mode.
        val album: String? = intent.getStringExtra(MediaStore.EXTRA_MEDIA_ALBUM)
        val artist: String? = intent.getStringExtra(MediaStore.EXTRA_MEDIA_ARTIST)
        val genre: String? = intent.getStringExtra("android.intent.extra.genre")
        val playlist: String? = intent.getStringExtra("android.intent.extra.playlist")
        val title: String? = intent.getStringExtra(MediaStore.EXTRA_MEDIA_TITLE)

        // Determine the search mode and use the corresponding extras.
        when {
            mediaFocus == null -> {
                // 'Unstructured' search mode (backward compatible)
                playUnstructuredSearch(query)
            }
            mediaFocus.compareTo("vnd.android.cursor.item/*") == 0 -> {
                if (query?.isNotEmpty() == true) {
                    // 'Unstructured' search mode.
                    playUnstructuredSearch(query)
                } else {
                    // 'Any' search mode.
                    playResumeLastPlaylist()
                }
            }
            mediaFocus.compareTo(MediaStore.Audio.Genres.ENTRY_CONTENT_TYPE) == 0 -> {
                // 'Genre' search mode.
                playGenre(genre)
            }
            mediaFocus.compareTo(MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE) == 0 -> {
                // 'Artist' search mode.
                playArtist(artist, genre)
            }
            mediaFocus.compareTo(MediaStore.Audio.Albums.ENTRY_CONTENT_TYPE) == 0 -> {
                // 'Album' search mode.
                playAlbum(album, artist)
            }
            mediaFocus.compareTo("vnd.android.cursor.item/audio") == 0 -> {
                // 'Song' search mode.
                playSong(album, artist, genre, title)
            }
            mediaFocus.compareTo(MediaStore.Audio.Playlists.ENTRY_CONTENT_TYPE) == 0 -> {
                // 'Playlist' search mode.
                playPlaylist(album, artist, genre, playlist, title)
            }
        }
    }
}

Java

protected void onCreate(Bundle savedInstanceState) {
    //...
    Intent intent = this.getIntent();
    if (intent.getAction().compareTo(MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH) == 0) {

        String mediaFocus = intent.getStringExtra(MediaStore.EXTRA_MEDIA_FOCUS);
        String query = intent.getStringExtra(SearchManager.QUERY);

        // Some of these extras might not be available depending on the search mode.
        String album = intent.getStringExtra(MediaStore.EXTRA_MEDIA_ALBUM);
        String artist = intent.getStringExtra(MediaStore.EXTRA_MEDIA_ARTIST);
        String genre = intent.getStringExtra("android.intent.extra.genre");
        String playlist = intent.getStringExtra("android.intent.extra.playlist");
        String title = intent.getStringExtra(MediaStore.EXTRA_MEDIA_TITLE);

        // Determine the search mode and use the corresponding extras.
        if (mediaFocus == null) {
            // 'Unstructured' search mode (backward compatible).
            playUnstructuredSearch(query);

        } else if (mediaFocus.compareTo("vnd.android.cursor.item/*") == 0) {
            if (query.isEmpty()) {
                // 'Any' search mode.
                playResumeLastPlaylist();
            } else {
                // 'Unstructured' search mode.
                playUnstructuredSearch(query);
            }

        } else if (mediaFocus.compareTo(MediaStore.Audio.Genres.ENTRY_CONTENT_TYPE) == 0) {
            // 'Genre' search mode.
            playGenre(genre);

        } else if (mediaFocus.compareTo(MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE) == 0) {
            // 'Artist' search mode.
            playArtist(artist, genre);

        } else if (mediaFocus.compareTo(MediaStore.Audio.Albums.ENTRY_CONTENT_TYPE) == 0) {
            // 'Album' search mode.
            playAlbum(album, artist);

        } else if (mediaFocus.compareTo("vnd.android.cursor.item/audio") == 0) {
            // 'Song' search mode.
            playSong(album, artist, genre, title);

        } else if (mediaFocus.compareTo(MediaStore.Audio.Playlists.ENTRY_CONTENT_TYPE) == 0) {
            // 'Playlist' search mode.
            playPlaylist(album, artist, genre, playlist, title);
        }
    }
}

Nova nota

Criar uma nota é uma ação comum para 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 essa ação.

Ação
ACTION_CREATE_NOTE
Esquema do 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 anotação.

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 as informações 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 o 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 a permissão CALL_PHONE).
Esquema do URI de 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ê ainda não tentou um esquema ou não sabe 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);
    }
}

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 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 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 o imagem ou vídeo para anexar. Se estiver usando a ação ACTION_SEND_MULTIPLE, esse extra será 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 e-mail ou aplicativos sociais 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 intents para várias ações adicionais para que ele esteja disponível como o aplicativo de SMS padrão no Android 4.4 e versões mais recentes. 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 as informações 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 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 funcionalidade semelhante à do site, inclua um filtro de intents para URLs que apontem para seu 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 o intent.

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