Os intents permitem iniciar uma atividade em outro aplicativo descrevendo uma ação simples que você gostaria de executar (como “exibir um mapa” ou “tirar uma fotografia”) em um objeto Intent
. Esse tipo de intent chama-se intent implícito, porque não especifica o componente do aplicativo a iniciar. Em vez disso, ele especifica uma ação que fornece alguns dados com os quais realizar a ação.
Ao chamar startActivity()
ou startActivityForResult()
e passar um intent implícito, o sistema resolve o intent para um aplicativo que pode processar o intent e inicia a Activity
correspondente. Se houver mais de um aplicativo que pode processar o intent, o sistema apresentará ao usuário uma caixa de diálogo para escolher o aplicativo a usar.
Esta página descreve vários intents implícitos que você pode usar para executar ações comuns, organizadas pelo tipo de aplicativo que processa o intent. Cada seção mostra também como criar um filtro de intents para anunciar a capacidade do aplicativo de executar a mesma ação.
Atenção: se não houver aplicativos no dispositivo que possam receber o intent implícito, o aplicativo falhará ao chamar startActivity()
. Para verificar primeiro se existe um aplicativo para receber o intent, chame resolveActivity()
no objeto Intent
. Se o resultado for diferente de nulo, há pelo menos um aplicativo que pode processar o intent e é seguro chamar startActivity()
. Se o resultado for nulo, não use o intent e, se possível, desative o recurso que o invoca.
Se não estiver familiarizado com a forma de criar intents ou filtros de intents, leia primeiro Intents e filtros de intents.
Para saber como acionar os intents listados nesta página do host de desenvolvimento, consulte Verificação de intents com o Android Debug Bridge.
Google Voice Actions
O Google Voice Actions aciona alguns dos intents listados nesta página em resposta a comandos de voz. Para saber mais, consulte Intents acionados pelo Google Voice Actions.
Despertador
Criar um despertador
Para criar um novo alarme, use a ação ACTION_SET_ALARM
e especifique os detalhes do despertador, como o horário e a mensagem, usando extras definidos abaixo.
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 foram adicionados em versões posteriores da plataforma.
- Ação
ACTION_SET_ALARM
- URI dos dados
- Nenhum
- Tipo MIME
- Nenhum
- Extras
-
EXTRA_HOUR
- É a hora do despertador.
EXTRA_MINUTES
- São os minutos do despertador.
EXTRA_MESSAGE
- É uma mensagem personalizada para identificar o despertador.
EXTRA_DAYS
- É uma
ArrayList
incluindo cada dia da semana em que esse despertador precisará ser repetido. Cada dia deve ser declarado com um inteiro na classeCalendar
, como, por exemplo,MONDAY
.Para um despertador único, não especifique esse extra.
EXTRA_RINGTONE
- É o URI de
content:
que especifica um toque a usar com o despertador ouVALUE_RINGTONE_SILENT
para nenhum toque.Para usar o toque padrão, não especifique esse extra.
EXTRA_VIBRATE
- É um booleano especificando se deve vibrar para esse despertador.
EXTRA_SKIP_UI
- É um booleano especificando se o aplicativo que responde deve ignorar a IU ao definir o despertador. Se for verdadeiro, o aplicativo deve ignorar qualquer IU de confirmação e simplesmente 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 o intent ACTION_SET_ALARM
, o aplicativo 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 extras definidos abaixo.
Observação: esse intent foi adicionado no Android 4.4 (API de nível 19).
- Ação
ACTION_SET_TIMER
- URI dos 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 aplicativo que responde deve ignorar a IU ao definir o timer. Se for verdadeiro, o aplicativo deve ignorar qualquer IU de confirmação e simplesmente iniciar o temporizador 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 o intent ACTION_SET_TIMER
, o aplicativo 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 exibir a lista de alarmes, use a ação ACTION_SHOW_ALARMS
.
Apesar de poucos aplicativos invocarem esse intent (ele é usado principalmente por aplicativos do sistema), qualquer aplicativo que se comporte como um despertador deve implementar esse filtro de intents e responder exibindo a lista de alarmes atuais.
Observação: esse intent foi adicionado no Android 4.4 (API de nível 19).
- Ação
ACTION_SHOW_ALARMS
- URI dos 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 de calendário
Para adicionar um novo evento ao calendário do usuário, use a ação ACTION_INSERT
e especifique o URI dos dados com Events.CONTENT_URI
. Depois você pode especificar vários detalhes do evento usando extras definidos abaixo.
- Ação
ACTION_INSERT
- URI dos 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
Capturar uma imagem ou um vídeo e retorná-lo
Para abrir um aplicativo 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 a foto ou o vídeo deverá ser salvo pela câmera 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 aplicativo da câmera deve salvar o arquivo da foto ou do vídeo (como um objeto
Uri
).
Quando o aplicativo da câmera retorna corretamente o foco para a atividade (seu aplicativo recebe o callback onActivityResult()
), você 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 a foto, a câmera poderá retornar também uma cópia em escala reduzida (uma miniatura) da foto no 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 mais informações sobre como usar esse intent para capturar uma foto, inclusive criar uma Uri
apropriada para o local de saída, leia Como tirar fotos de forma simples ou Como fazer vídeos de forma simples.
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 esse intent, a atividade precisará verificar a existência do extra EXTRA_OUTPUT
no Intent
recebido, salvar a imagem ou o vídeo capturado no local especificado por aquele extra e chamar setResult()
com um Intent
que contenha uma miniatura compactada em um extra chamado "data"
.
Iniciar um aplicativo de câmera em modo de imagem estática
Para abrir um aplicativo 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
fun capturePhoto() { val intent = Intent(MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA) if (intent.resolveActivity(packageManager) != null) { startActivityForResult(intent, REQUEST_IMAGE_CAPTURE) } }
Java
public void capturePhoto() { Intent intent = new Intent(MediaStore.INTENT_ACTION_STILL_IMAGE_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.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 aplicativo de câmera em 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>
Aplicativo de contatos/pessoas
Selecionar um contato
Para fazer com que o usuário selecione um contato e forneça ao aplicativo acesso a todos os dados de contato, use a ação ACTION_PICK
e especifique o tipo MIME como Contacts.CONTENT_TYPE
.
O Intent
resultante entregue ao callback onActivityResult()
contém o URI de content:
que aponta para o contato selecionado. A resposta concede ao aplicativo permissões temporárias para ler aquele contato usando a API Contacts Provider, mesmo que o aplicativo não inclua a permissão READ_CONTACTS
.
Dica: se for necessário acessar somente uma informação do contato, como número de telefone ou endereço de e-mail, consulte a seção a seguir sobre como selecionar dados específicos de contatos.
- 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 os detalhes do contato quando já tiver o URI, consulte Recuperação dos detalhes de um contato. Lembre-se: ao recuperar o URI do contato com o intent acima, não é necessária a permissão READ_CONTACTS
para ler os detalhes do contato.
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 listados abaixo, como CommonDataKinds.Phone.CONTENT_TYPE
, para ter acesso ao número de telefone do contato.
Se você precisar recuperar só um tipo de dados de um contato, essa técnica com um CONTENT_TYPE
das classes ContactsContract.CommonDataKinds
é mais eficiente do que usar Contacts.CONTENT_TYPE
(conforme mostrado na seção anterior), porque o resultado fornece acesso direto ao resultado desejado sem que você precise realizar uma consulta mais complexa no Provedor de Contatos.
O Intent
resultante entregue ao callback onActivityResult()
contém o URI de content:
que aponta para os dados do contato selecionado. A resposta concede ao aplicativo permissões temporárias para ler os dados do contato, mesmo que o aplicativo não inclua a permissão READ_CONTACTS
.
- Ação
ACTION_PICK
- Esquema do URI dos dados
- Nenhum
- Tipo MIME
-
CommonDataKinds.Phone.CONTENT_TYPE
- Seleciona dentre contatos com um número de telefone.
CommonDataKinds.Email.CONTENT_TYPE
- Seleciona dentre contatos com um endereço de e-mail.
CommonDataKinds.StructuredPostal.CONTENT_TYPE
- Seleciona dentre contatos com um endereço de correspondência.
Ou um de 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 exibir os detalhes de um contato conhecido, use a ação ACTION_VIEW
e especifique o contato com um URI de content:
como os dados do intent.
Há duas formas principais de recuperar inicialmente o URI do contato:
- Usar o URI do contato retornado por
ACTION_PICK
, mostrado na seção anterior (essa abordagem não exige nenhuma permissão do aplicativo). - Acessar diretamente a lista de todos os contatos, como descrito em Recuperação de uma lista de contatos (essa abordagem exige a permissão
READ_CONTACTS
).
- Ação
ACTION_VIEW
- Esquema do URI dos dados
content:<URI>
- Tipo MIME
- Nenhum. O tipo é inferido da 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 de content:
como os dados do intent e inclua quaisquer informações do contato conhecido em extras especificados por constantes em ContactsContract.Intents.Insert
.
Há duas formas principais de recuperar inicialmente o URI do contato:
- Usar o URI do contato retornado por
ACTION_PICK
, mostrado na seção anterior (essa abordagem não exige nenhuma permissão do aplicativo). - Acessar diretamente a lista de todos os contatos, como descrito em Recuperação de uma lista de contatos (essa abordagem exige a permissão
READ_CONTACTS
).
- Ação
ACTION_EDIT
- Esquema do URI dos dados
content:<URI>
- Tipo MIME
- O tipo é inferido da URI do contato.
- Extras
- Um ou mais dos extras são definidos em
ContactsContract.Intents.Insert
para que você possa preencher os campos de 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 Modificação de contatos usando intents.
Inserir um contato
Para inserir um novo contato, use a ação ACTION_INSERT
, especifique Contacts.CONTENT_TYPE
como tipo MIME e inclua quaisquer informações conhecidas do contato 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 são 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, consulte Modificar contatos usando intents.
Compor um e-mail com anexos opcionais
Para compor um e-mail, use uma das ações abaixo, dependendo se incluirá anexos, e inclua detalhes do e-mail, como destinatário e assunto, usando as chaves extras listadas abaixo.
- 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 estiver usando a açãoACTION_SEND_MULTIPLE
, ela precisará ser umaArrayList
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 quiser garantir que o intent seja processado somente por um app de e-mails (e não por outros aplicativos de mensagens de texto ou sociais), use a ação ACTION_SENDTO
e inclua o esquema de dados "mailto:"
. Por exemplo:
Kotlin
fun composeEmail(addresses: Array<String>, subject: String) { val intent = Intent(Intent.ACTION_SENDTO).apply { data = Uri.parse("mailto:") // only email apps should 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 should 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
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 para seu aplicativo, use a ação ACTION_GET_CONTENT
e especifique o tipo MIME desejado. A referência de arquivo retornada para o aplicativo é temporária no ciclo de vida atual da atividade, portanto, se quiser acessá-la posteriormente, você precisará importar uma cópia que possa ler mais tarde Esse intent também permite que o usuário crie um novo arquivo no processo (por 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 de http:
, URI de file:
ou URI de content:
. No entanto, se quiser restringir os arquivos selecionáveis somente àqueles que sejam acessíveis de um provedor de conteúdo (um URI de content:
) e que estejam disponíveis como uma transmissão de arquivo com openFileDescriptor()
, você deverá adicionar a categoria CATEGORY_OPENABLE
ao intent.
No Android 4.3 (API de nível 18) e posteriores, também é possível permitir que o usuário selecione vários arquivos adicionando EXTRA_ALLOW_MULTIPLE
ao intent e definindo-o como true
. Você então poderá 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 deve selecionar.
- Extras
-
EXTRA_ALLOW_MULTIPLE
- É um booleano declarando se o usuário pode selecionar mais de um arquivo ao mesmo tempo.
EXTRA_LOCAL_ONLY
- É um booleano que declara se o arquivo retornado deve estar diretamente disponível no dispositivo, em vez de exigir o download de um serviço remoto.
- Categoria (opcional)
-
CATEGORY_OPENABLE
- Serve para retornar somente arquivos que podem ser abertos e que podem ser representados como um stream de arquivo 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 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 precisará ser importado no aplicativo (usando a ação ACTION_GET_CONTENT
), ao executar no Android 4.4 ou posterior, é possível solicitar abrir um arquivo gerenciado por outro aplicativo usando a ação ACTION_OPEN_DOCUMENT
e especificando um tipo MIME. Para permitir também que o usuário crie um novo documento em que seu aplicativo pode gravar, use a ação ACTION_CREATE_DOCUMENT
. Por exemplo, em vez de selecionar dentre documentos PDF atuais, o intent ACTION_CREATE_DOCUMENT
permite que os usuários selecionem se querem criar um novo documento (dentro de outro aplicativo que gerencia o armazenamento do documento) — nesse caso, o aplicativo recebe o local do URI em que pode gravar o novo documento.
Apesar de o intent entregue ao método onActivityResult()
pela ação ACTION_GET_CONTENT
poder retornar um URI de qualquer tipo, o intent resultante de ACTION_OPEN_DOCUMENT
e ACTION_CREATE_DOCUMENT
sempre especifica o arquivo escolhido como um URI de content:
com o apoio de um DocumentsProvider
. Você pode abrir o arquivo com openFileDescriptor()
e consultar os detalhes usando colunas de DocumentsContract.Document
.
O URI retornado concede ao aplicativo acesso de leitura de longo prazo (possivelmente também acesso de gravação). Portanto, a ação ACTION_OPEN_DOCUMENT
é particularmente útil (em vez de usar ACTION_GET_CONTENT
) quando você quer ler um arquivo existente sem fazer uma cópia dele em seu aplicativo ou quando quer abrir e editar um arquivo no local.
Para permitir que o usuário selecione vários arquivos, adicione EXTRA_ALLOW_MULTIPLE
ao intent, definido como true
. Se o usuário selecionar só um item, é possível recuperar esse item a partir de getData()
. Se o usuário selecionar mais de um item, getData()
retornará nulo e você deverá, nesse caso, recuperar cada item de um objeto ClipData
retornado por getClipData()
.
Observação: seu intent precisará especificar um tipo MIME e, além disso, 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, você precisará definir 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 deve selecionar.
- Extras
-
EXTRA_MIME_TYPES
- É uma matriz de tipos MIME que correspondente aos tipos de arquivos que seu aplicativo está solicitando. Ao usar esse extra, você deve 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
- Serve para ser usado com
ACTION_CREATE_DOCUMENT
para especificar um nome de arquivo inicial. EXTRA_LOCAL_ONLY
- É um booleano que declara se o arquivo retornado deve estar diretamente disponível no dispositivo, em vez de exigir o download de um serviço remoto.
- Categoria
-
CATEGORY_OPENABLE
- Serve para retornar somente arquivos que podem ser abertos e que podem ser representados como um stream de arquivo 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 ... } }
Aplicativos de terceiros não podem responder a um intent com a ação ACTION_OPEN_DOCUMENT
. Em vez disso, o sistema recebe esse intent e exibe todos os arquivos disponíveis de vários aplicativos em uma interface do usuário unificada.
Para fornecer os arquivos de seu aplicativo nessa IU e permitir que outros aplicativos os abram, é preciso implementar um DocumentsProvider
e incluir um filtro de intents para PROVIDER_INTERFACE
("android.content.action.DOCUMENTS_PROVIDER"
). Por exemplo:
<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 aplicativo possam ser abertos por outros aplicativos, leia o guia sobre a Biblioteca de acesso ao armazenamento.
Ações locais
Chamar um carro
Para chamar um táxi, use a ação ACTION_RESERVE_TAXI_RESERVATION
.
Observação: os aplicativos precisarão pedir confirmação do usuário antes de concluir a ação.
- Ação
ACTION_RESERVE_TAXI_RESERVATION
- URI dos 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
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 do intent com um dos esquemas definidos abaixo.
- Ação
ACTION_VIEW
- Esquema do URI dos dados
-
geo:latitude,longitude
- Exibe o mapa na longitude e na latitude dadas.
Exemplo:
"geo:47.6,-122.3"
geo:latitude,longitude?z=zoom
- Exibe o mapa na longitude e na latitude dadas em um certo nível de zoom. Um nível de zoom de 1 mostra a Terra inteira, com centro em lat,lng dadas. O nível de zoom mais alto (mais perto) é 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
- Mostra a localização para "meu endereço" (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 passadas no URI de
geo
precisarão ser codificadas. Por exemplo, a string1st & Pike, Seattle
precisará tornar-se1st%20%26%20Pike%2C%20Seattle
. Espaços na string podem ser codificados com%20
ou substituídos pelo sinal de mais (+
).
- 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
Reproduzir um arquivo de mídia
Para reproduzir um arquivo de música, use a ação ACTION_VIEW
e especifique a localização do URI do arquivo nos dados do 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 outro aplicativo que seja necessário.
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 reproduzir música com base em uma consulta de pesquisa, use o intent INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH
. Um aplicativo pode disparar esse intent em resposta ao comando de voz do usuário para reproduzir música. O aplicativo que recebe esse intent executa uma pesquisa em seu inventário para corresponder o conteúdo existente à consulta dada e começa a reproduzir o conteúdo.
Esse intent deve incluir o extra de string EXTRA_MEDIA_FOCUS
, que especifica o modo de pesquisa desejado. Por exemplo, o modo de pesquisa pode especificar se a pesquisa é por um nome de artista ou título 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
(obrigatório)-
Indica o modo de pesquisa (se o usuário procura um artista, álbum, música ou playlist específico). A maioria dos modos de pesquisa precisa de extras adicionais. Por exemplo, se o usuário está interessado em ouvir uma música específica, o intent pode ter três extras adicionais: o título da música, o artista e o álbum. Esse intent suporta os seguintes modos de pesquisa para cada valor de
EXTRA_MEDIA_FOCUS
:Qualquer -
"vnd.android.cursor.item/*"
-
Reproduz qualquer música. O aplicativo recebedor precisa reproduzir alguma música com base em uma escolha inteligente, como a última lista de reprodução que o usuário escutou.
Extras adicionais:
QUERY
(obrigatório): é uma string vazia. Esse extra é sempre fornecido para compatibilidade com versões anteriores: aplicativos existentes que não sabem da existência de modos de pesquisa podem processar esse intent como uma pesquisa não estruturada.
Não estruturado:
"vnd.android.cursor.item/*"
-
Reproduz uma música, um álbum ou um gênero particular de uma consulta de pesquisa não estruturada. Os aplicativos podem gerar um intent com esse modo de pesquisa quando não conseguem identificar o tipo de conteúdo que o usuário quer escutar. Os aplicativos precisam usar 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: aplicativos existentes que não sabem da existência de modos de pesquisa podem processar esse 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: aplicativos existentes que não sabem da existência de modos de pesquisa podem processar esse 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 de álbum ou artista. Esse extra é sempre fornecido para compatibilidade com versões anteriores: aplicativos existentes que não sabem da existência de modos de pesquisa podem processar esse 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: aplicativos existentes que não sabem da existência de modos de pesquisa podem processar esse intent como uma pesquisa não estruturada.
Playlist:
Audio.Playlists.ENTRY_CONTENT_TYPE
-
Reproduz uma playlist específica ou uma lista de reprodução que corresponde a alguns critérios definidos 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 se baseia.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: aplicativos existentes que não sabem da existência de modos de pesquisa podem processar esse intent como uma pesquisa não estruturada.
Exemplo de intent:
Se o usuário quiser escutar música de um artista específico, um aplicativo de pesquisa poderá gerar o 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 esse intent, sua atividade precisará verificar o valor do extra EXTRA_MEDIA_FOCUS
no Intent
recebido para determinar o modo de pesquisa. Depois que a atividade tiver identificado o modo de pesquisa, ela precisará ler os valores dos extras adicionais para aquele modo de pesquisa específico. Com essas informações, o aplicativo poderá realizar a pesquisa em seu inventário para reproduzir o conteúdo que corresponde à consulta de pesquisa. Por exemplo:
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 may 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 may 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 anotação
Criar uma anotação
Para criar uma anotação, use a ação ACTION_CREATE_NOTE
e especifique os detalhes da anotação, como o assunto e o texto, usando os extras definidos abaixo.
Observação: os aplicativos precisarão pedir confirmação do usuário antes de concluir a 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 anotação.
-
EXTRA_TEXT
- É uma string que indica o texto da anotação.
-
- “telefonar para 555-5555”
- "telefonar para bob"
- “telefonar para o correio de voz”
- Ação
-
ACTION_DIAL
: abre o discador ou o aplicativo de telefone.ACTION_CALL
: faz uma chamada telefônica (exige 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"
- Oferece compatibilidade com 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
Consulte a documentação de
Settings
para ver telas de configurações adicionais que estão disponíveis. - 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>
Cada um desses esquemas é processado da mesma forma.
- Tipo MIME
-
"text/plain"
"image/*"
"video/*"
- Extras
-
"subject"
- Uma string para o assunto da mensagem (normalmente apenas para MMS).
"sms_body"
- É uma string para a mensagem de texto.
EXTRA_STREAM
- É uma
Uri
que aponta para a imagem ou o vídeo a anexar. Se estiver usando a açãoACTION_SEND_MULTIPLE
, esse extra precisará ser umaArrayList
deUri
apontando para as imagens/os vídeos a anexar.
- 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"
- Configurar um dispositivo Android para desenvolvimento ou usar um dispositivo virtual.
- Instale uma versão do aplicativo que processe os intents a que quer oferecer compatibilidade.
- Dispare um 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ê definiu os filtros de intents necessários, o aplicativo será capaz de processar o 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>
Telefone
Iniciar uma chamada telefônica
Para abrir o aplicativo de telefone e discar um número, use a ação ACTION_DIAL
e especifique um número de telefone usando o esquema de URI definido abaixo. Quando o aplicativo de telefone é aberto, ele exibe o número do telefone, mas o usuário precisa pressionar o botão Chamar para iniciar a chamada telefônica.
Google Voice Actions
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 definido abaixo. Quando o aplicativo de telefone é aberto, ele inicia a chamada telefônica. O usuário não precisa pressionar o botão Chamar.
A ação ACTION_CALL
exige que você adicione a permissão CALL_PHONE
no arquivo de manifesto:
<uses-permission android:name="android.permission.CALL_PHONE" />
Números de telefone válidos são os definidos na IETF RFC 3966. Exemplos válidos incluem os seguintes:
O discador de telefone faz um bom trabalho ao normalizar esquemas, como números de telefone. Portanto, esquema descrito não é rigorosamente obrigatório no método Uri.parse()
. No entanto, se você ainda não tentou um esquema ou não sabe ao certo 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); } }
Pesquisa
Pesquisar usando um aplicativo específico
Para dar suporte à pesquisa dentro do contexto de seu aplicativo, declare um filtro de intent no aplicativo com a ação SEARCH_ACTION
, como mostrado no exemplo de filtro de intents abaixo.
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
Abrir uma seção específica das Configurações
Para abrir uma tela nas configurações do sistema quando o aplicativo exige que o usuário altere alguma coisa, use uma das seguintes ações de intent para abrir a tela de configurações relacionada ao nome da ação.
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
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 listadas abaixo.
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 o intent seja processado somente por um aplicativo de mensagens de texto (e não por outros aplicativos de e-mail ou sociais), use a ação ACTION_SENDTO
e inclua o esquema de dados "smsto:"
. Por exemplo:
Kotlin
fun composeMmsMessage(message: String, attachment: Uri) { val intent = Intent(Intent.ACTION_SEND).apply { data = Uri.parse("smsto:") // This ensures only SMS apps respond 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:")); // This ensures only SMS apps respond 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 estiver desenvolvendo um aplicativo de mensagens SMS/MMS, será preciso implementar filtros de intents para várias ações adicionais para que esteja disponível como o aplicativo de SMS padrão no Android 4.4 e posteriores. Para saber mais, consulte a documentação em Telephony
.
Navegador da Web
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 do 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 fornecer funcionalidade similar à de seu site, inclua um filtro de intents para URLs que apontem para seu site. Assim, se usuários tiverem seu aplicativo instalado, links de e-mails ou outras páginas que apontem para seu site abrirão o app Android, em vez da página.
Verificação de intents com o Android Debug Bridge
Para verificar se seu aplicativo responde aos intents a que quer dar compatibilidade, você pode usar a ferramenta adb
para disparar intents específicos:
Para saber mais, consulte Comandos de shell do ADB.