Uma intent permite iniciar uma atividade em outro app descrevendo uma ação que você gostaria de realizar, como "ver um mapa" ou "tirar uma foto", em um objeto Intent
. Esse tipo de intent é chamado de intent implícita porque não especifica o componente do app a ser iniciado, mas especifica uma ação e fornece alguns dados para realizar a ação.
Quando você chama startActivity()
ou startActivityForResult()
e transmite uma intent implícita, o sistema
resolve
a intent para um app que pode processar a intent e inicia a
Activity
correspondente. Se houver mais de um app que pode processar o intent, o sistema apresentará 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 seção também mostra como criar um filtro de intent para anunciar a capacidade do app de realizar a ação.
Cuidado:se não houver apps no dispositivo que possam
receber uma intent implícita, um app falhará ao chamar startActivity()
. Para verificar primeiro se existe um app para receber a intent, chame resolveActivity()
no seu 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, primeiro leia Intents e filtros de intents.
Para saber como disparar os intents listados nesta página do host de desenvolvimento, consulte a seção Verificar intents com o Android Debug Bridge.
Google Voice Actions
O Google Voice Actions dispara alguns dos intents listados nesta página em resposta a comandos de voz. Para mais informações, consulte Primeiros passos com as Comandos de voz do sistema.
Despertador
Confira abaixo ações comuns para apps de despertador, incluindo as informações necessárias para criar um filtro de intent e anunciar a capacidade do app de realizar cada ação.
Criar um despertador
Para criar um novo alarme, use a ação ACTION_SET_ALARM
e especifique os detalhes do alarme, como o horário 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 (nível 9 da API) e versões anteriores. Os outros extras estão disponíveis em versões mais recentes da 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 classeCalendar
, comoMONDAY
.Para um alarme único, não especifique esse extra.
EXTRA_RINGTONE
- Um URI
content:
especificando um toque para usar com o alarme ouVALUE_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); } }
Para invocar a intent ACTION_SET_ALARM
, 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_ALARM" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </activity>
Criar um timer
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 extras a seguir.
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); } }
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 a ação
ACTION_SHOW_ALARMS
.
Embora poucos apps invoquem essa intent, já que ela é usada principalmente por apps do sistema, qualquer app 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 as informações da 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 de dados usando
Events.CONTENT_URI
.
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 na classe
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 abaixo 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 do URI em que você
quer que a câmera salve 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 o arquivo de foto ou
vídeo (como um objeto
Uri
).
Quando o app da câmera retorna
o foco para a atividade, ou seja, o app recebe o callback onActivityResult()
, você
pode acessar a foto ou o vídeo no URI especificado
com o valor EXTRA_OUTPUT
.
Observação:quando você usa ACTION_IMAGE_CAPTURE
para capturar uma foto, a câmera também pode retornar uma
cópia reduzida, ou miniatura, da foto na Intent
resultante, salva como um 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, consulte
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
no Intent
recebido, 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
Para abrir um app de câmera em modo de imagem estática, use a ação INTENT_ACTION_STILL_IMAGE_CAMERA
.
- Ação
INTENT_ACTION_STILL_IMAGE_CAMERA
- Esquema do URI dos dados
- Nenhum
- Tipo MIME
- Nenhum
- Extras
- Nenhum
Exemplo de intent:
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
Para abrir um app de câmera no modo de vídeo, use a ação INTENT_ACTION_VIDEO_CAMERA
.
- Ação
INTENT_ACTION_VIDEO_CAMERA
- Esquema do URI dos dados
- Nenhum
- Tipo MIME
- Nenhum
- Extras
- Nenhum
Exemplo de intent:
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
Confira abaixo 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 executar cada ação.
Selecionar um contato
Para que o usuário selecione um contato e forneça ao app acesso a todos os dados de contato,
use a ação ACTION_PICK
e especifique o tipo MIME como
Contacts.CONTENT_TYPE
.
O resultado Intent
entregue 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 Contacts Provider, mesmo que
o app não inclua a permissão READ_CONTACTS
.
Dica:se você precisar acessar apenas uma informação de contato específica, por exemplo, 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 do URI dos 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, consulte Recuperar detalhes de um contato.
Quando você recupera 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 número de telefone ou 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 dados, 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 saber o número de telefone do contato.
Observação : em muitos casos, seu app precisa ter a permissão
READ_CONTACTS
para visualizar informações específicas sobre um contato específico.
Se você precisar extrair apenas um tipo de dados 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 fornece acesso direto aos dados desejados sem a necessidade de realizar 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 de contato selecionados. A resposta concede ao app
permissões temporárias para ler os dados do contato, mesmo que ele não inclua a permissão READ_CONTACTS
.
- Ação
ACTION_PICK
- Esquema do URI dos dados
- Nenhum
- Tipo MIME
-
CommonDataKinds.Phone.CONTENT_TYPE
- Escolha entre os contatos com um número de telefone.
CommonDataKinds.Email.CONTENT_TYPE
- Escolha entre os contatos com um endereço de e-mail.
CommonDataKinds.StructuredPostal.CONTENT_TYPE
- Escolha entre os contatos com um endereço postal.
Ou um dos muitos outros valores de
CONTENT_TYPE
emContactsContract
.
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 da intent.
Há duas maneiras principais de recuperar inicialmente a URI do contato:
- Use o URI do 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 do URI dos 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 da intent e inclua os dados de contato conhecidos 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
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 do URI dos dados
content:<URI>
- Tipo MIME
- O tipo é inferido a partir do URI do contato.
- Extras
- Um ou mais dos extras definidos em
ContactsContract.Intents.Insert
para que você possa preencher os 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, 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 todos os dados de contato conhecidos em extras especificados por
constantes em ContactsContract.Intents.Insert
.
- Ação
ACTION_INSERT
- Esquema do URI dos dados
- Nenhum
- Tipo MIME
Contacts.CONTENT_TYPE
- Extras
- Um ou mais dos extras definidos em
ContactsContract.Intents.Insert
.
Exemplo de intent:
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.
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 as informações da seção a seguir.
Compor um e-mail com anexos opcionais
Para escrever um e-mail, use uma das ações a seguir, dependendo da inclusão de anexos, e inclua detalhes do e-mail, como destinatário e 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 endereços de e-mail de destinatários em "Para".
Intent.EXTRA_CC
- Uma matriz de strings de todos os endereços de e-mail de destinatários em "CC".
Intent.EXTRA_BCC
- Uma matriz de strings de todos os endereços de e-mail de destinatários em "BCC".
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ê estiver usando a açãoACTION_SEND_MULTIPLE
, será umArrayList
contendo vários objetosUri
.
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 você quiser garantir que sua intent seja processada apenas por um app de e-mails, e não por uma
mensagem de texto ou um app social, 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
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 executar 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 aplicativo, use a ação ACTION_GET_CONTENT
e especifique o tipo MIME desejado. A referência do 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 para ler mais tarde.
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 capturar uma nova foto com a câmera.
A intent resultante entregue ao método onActivityResult()
inclui dados com um URI que aponta para o arquivo.
O URI pode ser qualquer coisa, como um URI http:
, file:
ou content:
. No entanto, se você quiser restringir os arquivos selecionáveis apenas àqueles que possam ser acessados
por um provedor de conteúdo (um URI content:
) e que estejam disponíveis como um fluxo de arquivos com
openFileDescriptor()
,
adicione
a categoria CATEGORY_OPENABLE
à sua 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, definido 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 do URI dos dados
- Nenhum
- Tipo MIME
- O tipo MIME correspondente ao tipo de arquivo que o usuário precisa selecionar.
- Extras
-
EXTRA_ALLOW_MULTIPLE
- É um booleano que declara se o usuário pode selecionar mais de um arquivo ao mesmo tempo.
EXTRA_LOCAL_ONLY
- Um booleano que declara se o arquivo retornado precisa estar disponível diretamente no dispositivo, em vez de exigir o download de um serviço remoto.
- Categoria (opcional)
-
CATEGORY_OPENABLE
- Para retornar apenas arquivos que podem ser abertos e que podem ser representados como um stream de arquivos
com
openFileDescriptor()
.
Exemplo de intent para receber 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 supportsOpenableColumns
andContentResolver.openFileDescriptor()
. --> <category android:name="android.intent.category.OPENABLE" /> </intent-filter> </activity>
Abrir um tipo de arquivo específico
Em vez de recuperar uma cópia de um arquivo que você precisa importar para o app, usando a ação ACTION_GET_CONTENT
, ao executar no Android
4.4 ou versões mais recentes, é possível solicitar que abra 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
selecionar um documento PDF existente, a intent ACTION_CREATE_DOCUMENT
permite que os usuários selecionem onde querem criar um novo documento, como em outro app
que gerencie o armazenamento do documento. Em seguida, o app recebe o local do URI em que
pode gravar o novo documento.
Enquanto a intent entregue ao método onActivityResult()
pela 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:
apoiado por 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
é
útil principalmente quando você quer ler um arquivo já existente sem fazer uma cópia no app
ou quando quer 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á
extrair cada item de um objeto ClipData
retornado por getClipData()
.
Observação:sua intent precisa especificar um tipo MIME e
precisa declarar a categoria CATEGORY_OPENABLE
. Se
adequado, é possível especificar mais de um tipo MIME adicionando uma matriz de tipos MIME com o
extra EXTRA_MIME_TYPES
. Se fizer isso, defina o
tipo MIME principal em setType()
como "*/*"
.
- 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 que seu 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 ao mesmo tempo.
EXTRA_TITLE
- Para uso com
ACTION_CREATE_DOCUMENT
a fim de 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 o download de um serviço remoto.
- Categorias
-
CATEGORY_OPENABLE
- Para retornar apenas arquivos que podem ser abertos e que podem ser representados como um stream de arquivos
com
openFileDescriptor()
.
Exemplo de intent para receber 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. ... } }
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 interface e permitir que outros apps os abram, implemente
um DocumentsProvider
e inclua 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 saber mais 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 intent para anunciar a capacidade do app de realizar essa ação usando as informações da seção a seguir.
Chamar um carro
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:
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 as informações da 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 local nos dados da intent com um dos esquemas abaixo.
- Ação
ACTION_VIEW
- Esquema do URI dos dados
-
geo:latitude,longitude
- Mostrar o mapa na longitude e na latitude informadas.
Exemplo:
"geo:47.6,-122.3"
geo:latitude,longitude?z=zoom
- Mostra o mapa na longitude e na latitude dadas em um determinado nível de zoom. Um nível de zoom igual a 1 mostra toda a Terra, centralizada nas lat,lng informadas. 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)
- Mostrar o mapa na longitude e na latitude informadas com um rótulo de string.
Exemplo:
"geo:0,0?q=34.99,-106.61(Treasure)"
geo:0,0?q=my+street+address
- Mostrar a localização de "meu endereço", que pode ser um endereço específico ou uma consulta de local.
Exemplo:
"geo:0,0?q=1600+Amphitheatre+Parkway%2C+CA"
Observação:todas as strings transmitidas no URI
geo
precisam ser codificadas. Por exemplo, a string1st & Pike, Seattle
se torna1st%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:
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 abaixo ações comuns para apps de música e vídeo, incluindo as informações necessárias para criar um filtro de intent e anunciar a capacidade do app de realizar cada ação.
Reproduzir um arquivo de mídia
Para 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 do URI dos dados
-
file:<URI>
content:<URI>
http:<URL>
- Tipo MIME
-
"audio/*"
"application/ogg"
"application/x-ogg"
"application/itunes"
- Ou qualquer outra opção que o app exija.
Exemplo de intent:
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
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 corresponder o conteúdo existente à consulta especificada e
começa a reproduzir esse conteúdo.
Nessa intent, inclua o extra de string EXTRA_MEDIA_FOCUS
, que especifica o modo de pesquisa pretendido. Por exemplo, esse modo pode especificar se
a pesquisa é pelo nome de um artista ou da música.
- Ação
INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH
- Esquema do URI dos dados
- Nenhum
- Tipo MIME
- Nenhum
- Extras
-
MediaStore.EXTRA_MEDIA_FOCUS
(Campo obrigatório)-
Indica o modo de pesquisa: se o usuário está procurando um artista, álbum, música ou playlist em particular. A maioria dos modos de pesquisa precisa de extras adicionais. Por exemplo, se o usuário estiver interessado em ouvir uma música específica, a intent poderá ter mais três extras: 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 a última playlist que o usuário escutou.
Extras adicionais:
QUERY
(obrigatório): uma string vazia. Esse extra é sempre fornecido para compatibilidade com versões anteriores. Apps que não conhecem os modos de pesquisa podem processar essa intent como uma pesquisa não estruturada.
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 de artista, álbum, nome da música ou gênero.
Gênero:
Audio.Genres.ENTRY_CONTENT_TYPE
-
Reproduz música de um gênero particular.
Extras adicionais:
"android.intent.extra.genre"
(obrigatório): o gênero.QUERY
(obrigatório): o gênero. Esse extra é sempre fornecido para compatibilidade com versões anteriores. Apps existentes que não sabem sobre os modos de pesquisa podem processar essa intent como uma pesquisa não estruturada.
Artista:
Audio.Artists.ENTRY_CONTENT_TYPE
-
Reproduz música de um artista específico.
Extras adicionais:
EXTRA_MEDIA_ARTIST
(obrigatório): o artista."android.intent.extra.genre"
: o gênero.QUERY
(obrigatório): uma string que contém qualquer combinação de artista ou gênero. Esse extra é sempre fornecido para compatibilidade com versões anteriores. Apps existentes que não sabem sobre os modos de pesquisa podem processar essa intent como uma pesquisa não estruturada.
-
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 do álbum ou do artista. Esse extra é sempre fornecido para compatibilidade com versões anteriores. Apps existentes que não sabem sobre os 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 compatibilidade com versões anteriores. Apps existentes que não sabem sobre os modos de pesquisa podem processar essa intent como uma pesquisa não estruturada.
Playlist:
Audio.Playlists.ENTRY_CONTENT_TYPE
-
Reproduz uma playlist específica ou que corresponde a alguns critérios especificados pelos 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 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. 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ú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 na sua atividade, confira o valor do extra
EXTRA_MEDIA_FOCUS
na Intent
de entrada para determinar o modo de pesquisa. Depois que a atividade identificar
o modo de pesquisa, leia os valores dos extras extras 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.
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 em apps de anotações. 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.
Criar uma nota
Para criar uma observação, use a ação
ACTION_CREATE_NOTE
e especifique os detalhes, 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 dos dados
- Nenhum
- Tipo MIME
-
PLAIN_TEXT_TYPE
- "*/*"
- Extras
-
-
EXTRA_NAME
- Uma string que indica o título ou o assunto da nota.
-
EXTRA_TEXT
- Uma string que indica o texto da nota.
-
- Ação
-
ACTION_DIAL
: abre o discador ou o app Telefone.ACTION_CALL
: faz uma chamada telefônica (requer a permissãoCALL_PHONE
)
- Esquema do URI dos dados
-
tel:<phone-number>
voicemail:<phone-number>
- Tipo MIME
- Nenhum
tel:2125551212
tel:(212) 555 1212
- 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.
- Ação
ACTION_WEB_SEARCH
- Esquema do URI dos dados
- Nenhum
- Tipo MIME
- Nenhum
- Extras
-
SearchManager.QUERY
- A string de pesquisa.
- 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
- 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
- Um
Uri
que aponta para a imagem ou o vídeo a ser anexado. Se você estiver usando a açãoACTION_SEND_MULTIPLE
, esse extra será umaArrayList
de objetosUri
que apontam para as imagens ou vídeos a serem anexados.
- Ação
ACTION_VIEW
- Esquema do URI dos dados
http:<URL>
https:<URL>
- Tipo MIME
-
"text/plain"
"text/html"
"application/xhtml+xml"
"application/vnd.wap.xhtml+xml"
- Configure um dispositivo Android para desenvolvimento ou use um dispositivo virtual.
- Instale uma versão do aplicativo que processe os intents a que quer oferecer compatibilidade.
- Dispare uma intent usando
adb
:adb shell am start -a <ACTION> -t <MIME_TYPE> -d <DATA> \ -e <EXTRA_NAME> <EXTRA_VALUE> -n <ACTIVITY>
Por exemplo:
adb shell am start -a android.intent.action.DIAL \ -d tel:555-5555 -n org.example.MyApp/.MyActivity
- Se você definir os filtros de intent necessários, processe a intent.
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 da seção a seguir.
Iniciar uma chamada telefônica
Para abrir o app de telefone e discar um número de telefone, use a ação ACTION_DIAL
e especifique um número de telefone usando
o esquema de URI a seguir. Quando o app para telefone é aberto, ele mostra o número de telefone
e o usuário precisa tocar no botão Ligar para iniciar a ligação.
Para fazer uma chamada telefônica diretamente, use a ação ACTION_CALL
e especifique um número de telefone usando o esquema de URI a seguir. Quando o app de telefone é aberto, ele inicia a chamada. 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" />
Os números de telefone válidos são aqueles definidos na IETF RFC 3966. Veja alguns exemplos válidos:
O discador do app Telefone faz um bom trabalho na normalização de esquemas, como
números de telefone. Portanto, o esquema descrito não é estritamente obrigatório no
método Uri.parse()
.
No entanto, se você não tentou um esquema ou não tem 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
Confira abaixo ações comuns de 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
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 a ação
GET_THING
para aproveitar o suporte integrado do Google Assistente à pesquisa no app. Para saber mais, consulte
a documentação das
Ações no app do Google Assistente.
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 especifique a string de pesquisa no
extra SearchManager.QUERY
.
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:
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 as informações da seção a seguir.
Compor uma mensagem SMS/MMS com anexo
Para iniciar uma mensagem de texto SMS ou MMS, use uma das ações de intent abaixo e especifique os detalhes da mensagem, como número de telefone, assunto e corpo da mensagem, usando as chaves extras a seguir.
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 sua intent seja processada apenas por um app de mensagens de texto, e não por outros
apps de e-mail ou 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, precisará
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 a capacidade do app de realizar essa ação usando as informações da seção a seguir.
Carregar um URL da Web
Para abrir uma página da Web, use a ação ACTION_VIEW
e especifique o URL da Web nos dados da intent.
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 oferece uma funcionalidade semelhante à do site, inclua um filtro de intent para URLs que direcionem ao seu site. Assim, se os usuários tiverem seu app instalado, links de e-mails ou outras páginas da Web que direcionam para seu site abrirão o app Android em vez da página da Web. Saiba mais em 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 no app de navegador padrão do usuário.
Verificar intents com o Android Debug Bridge
Para verificar se o app responde às intents às quais você quer oferecer compatibilidade, use a ferramenta
adb
para disparar intents específicas
fazendo o seguinte:
Para mais informações, consulte Emitir comandos do shell.