Enviar dados simples para outros apps

O Android usa intents e extras associados para permitir que os usuários compartilhem informações de maneira rápida e fácil usando os apps favoritos.

O Android oferece duas maneiras para os usuários compartilharem dados entre apps:

• O Android Sharesheet foi projetado principalmente para enviar conteúdo fora do seu app e/ou diretamente para outro usuário. Por exemplo, compartilhar um URL com um amigo.
• O resolvedor de intents do Android é mais adequado para transmitir dados ao próxima etapa de uma tarefa bem definida. Por exemplo, abrir um PDF a partir do seu aplicativo e permitir que os usuários escolher seu visor preferido.

Ao criar uma intent, você especifica a ação que ela vai executar. O Android usa a ação ACTION_SEND para enviar dados de uma atividade a outra, mesmo entre limites de processos. É necessário especificar os dados e o tipo relacionado. O sistema identifica automaticamente as atividades compatíveis que pode receber os dados e os exibir ao usuário. No caso do resolvedor de intents, se apenas uma atividade puder lidar com a intent, essa atividade será iniciada imediatamente.

Por que usar o Android Sharesheet

É altamente recomendável usar o Android Sharesheet para criar consistência para seus usuários nos apps. Não mostre a lista de destinos de compartilhamento do seu app nem crie suas próprias variações do Sharesheet.

O Android Sharesheet permite que os usuários compartilhem informações com os pessoa certa, com sugestões de apps relevantes, tudo com um único toque. A Sharesheet pode sugerir destinos indisponíveis para soluções personalizadas e usa uma classificação consistente. Isso ocorre porque o Sharesheet pode levar em conta informações sobre a atividade do app e do usuário que estão disponíveis apenas para o sistema.

O Android Sharesheet também conta com muitos recursos úteis para desenvolvedores. Por exemplo, você pode fazer o seguinte:

• descobrir quando seus usuários concluem um compartilhamento e para onde;
• Adicionar uma ChooserTarget personalizada e destinos de app
• disponibilizar visualizações de conteúdo rich text a partir do Android 10 (nível 29 da API);
• Excluir destinos correspondentes a nomes de componentes específicos

Usar o Android Sharesheet

Para todos os tipos de compartilhamento, crie uma intent e defina a ação como Intent.ACTION_SEND. Para mostrar o Android Sharesheet, chame Intent.createChooser(), transmitindo a ele seu objeto Intent. Ele retorna uma versão da sua intent que sempre mostra o Android Sharesheet.

Enviar conteúdo de texto

O uso mais direto e comum do Android Sharesheet é enviar conteúdo de texto de uma atividade para outra. Por exemplo, a maioria dos navegadores pode compartilhar o URL do navegador a página como texto em outro aplicativo. Isso é útil para compartilhar um artigo ou site com amigos através do e-mail ou redes sociais. Veja como fazer isso a seguir:

Kotlin

val sendIntent: Intent = Intent().apply {
    action = Intent.ACTION_SEND
    putExtra(Intent.EXTRA_TEXT, "This is my text to send.")
    type = "text/plain"
}

val shareIntent = Intent.createChooser(sendIntent, null)
startActivity(shareIntent)

Java

Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "This is my text to send.");
sendIntent.setType("text/plain");

Intent shareIntent = Intent.createChooser(sendIntent, null);
startActivity(shareIntent);

Opcionalmente, você pode adicionar extras para incluir mais informações, como destinatários de e-mail (EXTRA_EMAIL, EXTRA_CC, EXTRA_BCC). o assunto do e-mail (EXTRA_SUBJECT) etc.

Observação: alguns apps de e-mail, como o Gmail, esperam uma String[] para elementos extras, como EXTRA_EMAIL e EXTRA_CC. Usar putExtra(String, String[]) para adicioná-las à sua intent.

Enviar conteúdo binário

Compartilhe dados binários usando a ação ACTION_SEND. Defina o tipo MIME apropriado e coloque um URI para os dados no elemento extra EXTRA_STREAM, conforme mostrado no exemplo abaixo. Normalmente, essa opção é usada para compartilhar imagens, mas pode ser usada para compartilhar qualquer tipo de conteúdo binário.

Kotlin

val shareIntent: Intent = Intent().apply {
    action = Intent.ACTION_SEND
    // Example: content://com.google.android.apps.photos.contentprovider/...
    putExtra(Intent.EXTRA_STREAM, uriToImage)
    type = "image/jpeg"
}
startActivity(Intent.createChooser(shareIntent, null))

Java

Intent shareIntent = new Intent();
shareIntent.setAction(Intent.ACTION_SEND);
// Example: content://com.google.android.apps.photos.contentprovider/...
shareIntent.putExtra(Intent.EXTRA_STREAM, uriToImage);
shareIntent.setType("image/jpeg");
startActivity(Intent.createChooser(shareIntent, null));

O aplicativo receptor precisa de permissão para acessar os dados que o Uri indica. Há duas maneiras recomendadas de fazer isso:

• Armazene os dados no seu próprio ContentProvider, garantindo que os outros têm a permissão correta para acessar seu provedor. O mecanismo preferencial para conceder acesso é usar permissões por URI, que são temporárias e só concedem acesso ao aplicativo receptor. Uma maneira fácil de criar um ContentProvider como esse é usar a classe auxiliar FileProvider.
• Use o sistema MediaStore. O MediaStore é destinado principalmente a tipos MIME de vídeo, áudio e imagem. No entanto, a partir do Android 3.0 (nível 11 da API), ele também pode armazenar tipos que não são de mídia. Para mais informações, consulte MediaStore.Files. É possível inserir arquivos no MediaStore usando scanFile(), seguido de um Uri de estilo content:// adequado para compartilhamento, que é transmitido para o callback onScanCompleted() fornecido. Depois de adicionado ao MediaStore do sistema, o conteúdo pode ser acessado por qualquer app no dispositivo.

Usar o tipo MIME correto

Informe o tipo MIME mais específico disponível para os dados que você está enviando. Por exemplo, use text/plain ao compartilhar texto simples. Estes são alguns Tipos MIME comuns ao enviar dados simples no Android:

Os receptores se registram para	Os remetentes enviam
text/*	text/plain text/rtf text/html text/json
`image/*`	image/jpg image/png image/gif
video/*	video/mp4 video/3gp
Extensões de arquivo compatíveis	application/pdf

Cuidado:embora você possa usar o tipo MIME */*, é altamente desencorajar a fazer isso porque a maioria dos aplicativos receptores não pode receber conteúdo. O ideal é que seu app corresponda a atividades que possam processar fluxos de dados genéricos.

Para obter mais informações sobre tipos MIME, consulte a IANA (em inglês) oficial de tipos MIME de mídia.

O Sharesheet do Android pode mostrar uma visualização do conteúdo, dependendo do tipo MIME informado. Alguns recursos de visualização estão disponíveis apenas para tipos específicos.

Compartilhar vários conteúdos

Para compartilhar várias partes do conteúdo, use a ação ACTION_SEND_MULTIPLE com uma lista de URIs que apontam para o conteúdo. O tipo MIME varia de acordo com a combinação de conteúdo que você está compartilhando. Por exemplo, se você compartilhar três imagens JPEG, use o tipo "image/jpg": Para uma mistura de tipos de imagem, use "image/*" para corresponder a uma atividade que lida com qualquer tipo de imagem. Embora seja possível compartilhar uma mistura de tipos, nós altamente desencorajar isso, porque é não está claro para o destinatário sobre o que deve ser enviado. Se for necessário enviar vários tipos, use "*/*". Cabe ao aplicativo receptor analisar e processar seus dados. Veja um exemplo:

Kotlin

val imageUris: ArrayList<Uri> = arrayListOf(
        // Add your image URIs here
        imageUri1,
        imageUri2
)

val shareIntent = Intent().apply {
    action = Intent.ACTION_SEND_MULTIPLE
    putParcelableArrayListExtra(Intent.EXTRA_STREAM, imageUris)
    type = "image/*"
}
startActivity(Intent.createChooser(shareIntent, null))

Java

ArrayList<Uri> imageUris = new ArrayList<Uri>();
imageUris.add(imageUri1); // Add your image URIs here
imageUris.add(imageUri2);

Intent shareIntent = new Intent();
shareIntent.setAction(Intent.ACTION_SEND_MULTIPLE);
shareIntent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, imageUris);
shareIntent.setType("image/*");
startActivity(Intent.createChooser(shareIntent, null));

Verifique se os objetos Uri fornecidos apontam aos dados que um aplicativo receptor pode acessar.

Adicionar conteúdo avançado a visualizações de texto

A partir do Android 10 (nível 29 da API), o Android Sharesheet mostra uma visualização do texto que está sendo compartilhado. Em alguns casos, o texto compartilhado pode ser difícil de entender. Imagine um caso de compartilhamento de um URL complicado, como https://www.google.com/search?ei=2rRVXcLkJajM0PEPoLy7oA4. Uma abordagem pode tranquilizar os usuários com relação ao que está sendo compartilhado.

Se você estiver visualizando o texto, poderá definir um título, uma imagem em miniatura ou ambos. Adicione uma descrição a Intent.EXTRA_TITLE antes de chamar Intent.createChooser() e adicione uma miniatura relevante usando ClipData.

Observação: o URI do conteúdo da imagem é fornecido por um FileProvider, geralmente por um <cache-path> configurado. Para mais informações, consulte Como compartilhar arquivos. O Sharesheet precisa ter as permissões corretas para ler qualquer imagem que você queira usar como miniatura. Para mais informações, consulte Intent.FLAG_GRANT_READ_URI_PERMISSION.

Veja um exemplo:

Kotlin

 val share = Intent.createChooser(Intent().apply {
      action = Intent.ACTION_SEND
      putExtra(Intent.EXTRA_TEXT, "https://developer.android.com/training/sharing/")

      // (Optional) Here you're setting the title of the content
      putExtra(Intent.EXTRA_TITLE, "Introducing content previews")

      // (Optional) Here you're passing a content URI to an image to be displayed
      data = contentUri
      flags = Intent.FLAG_GRANT_READ_URI_PERMISSION
  }, null)
  startActivity(share)

Java

Intent sendIntent = new Intent(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "https://developer.android.com/training/sharing/");

// (Optional) Here you're setting the title of the content
sendIntent.putExtra(Intent.EXTRA_TITLE, "Introducing content previews");

// (Optional) Here you're passing a content URI to an image to be displayed
sendIntent.setData(contentUri);
sendIntent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);

// Show the Sharesheet
startActivity(Intent.createChooser(sendIntent, null));

A visualização tem esta aparência:

Adicionar ações personalizadas à Sharesheet

Captura de tela de ações personalizadas no Sharesheet do Android.

No Android 14 (nível 34 da API) e versões mais recentes, os apps podem adicionar ações personalizadas ao Android Sharesheet. As ações personalizadas são mostradas como ícones de ação pequenos na parte de cima da Sharesheet do Android, e os apps podem especificar qualquer Intent como a ação invocada quando o ícone é clicado.

Para adicionar ações personalizadas no Sharesheet do Android, primeiro crie um ChooserAction com ChooserAction.Builder. É possível especificar um PendingIntent como a ação invocada quando o ícone é clicado. Crie uma matriz que contenha todas as suas ações personalizadas e especifique-a como EXTRA_CHOOSER_CUSTOM_ACTIONS do Intent de compartilhamento.

Kotlin

val sendIntent = Intent(Intent.ACTION_SEND)
    .setType("text/plain")
    .putExtra(Intent.EXTRA_TEXT, text)
val shareIntent = Intent.createChooser(sendIntent, null)
val customActions = arrayOf(
    ChooserAction.Builder(
        Icon.createWithResource(context, R.drawable.ic_custom_action),
        "Custom",
        PendingIntent.getBroadcast(
            context,
            1,
            Intent(Intent.ACTION_VIEW),
            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_CANCEL_CURRENT
        )
    ).build()
)
shareIntent.putExtra(Intent.EXTRA_CHOOSER_CUSTOM_ACTIONS, customActions)
context.startActivity(shareIntent)

Java

Intent sendIntent = new Intent(Intent.ACTION_SEND)
        .setType("text.plain")
        .putExtra(Intent.EXTRA_TEXT, text);
Intent shareIntent = Intent.createChooser(sendIntent, null);
ChooserAction[] actions = new ChooserAction[]{
        new ChooserAction.Builder(
                Icon.createWithResource(context, R.drawable.ic_custom_action),
                "Custom",
                PendingIntent.getBroadcast(
                        context,
                        1,
                        new Intent(Intent.ACTION_VIEW),
                        PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_CANCEL_CURRENT
                )
        ).build()
};
shareIntent.putExtra(Intent.EXTRA_CHOOSER_CUSTOM_ACTIONS, actions);
context.startActivity(shareIntent);

Adicionar destinos personalizados

O Android Sharesheet permite especificar até dois objetos ChooserTarget que são mostrados antes dos atalhos de compartilhamento e dos alvos de escolha carregados de ChooserTargetServices. Você também pode especificar até duas intents que apontam para atividades listadas antes das sugestões do app:

Adicione Intent.EXTRA_CHOOSER_TARGETS e Intent.EXTRA_INITIAL_INTENTS à intent de compartilhamento depois de chamar Intent.createChooser():

Kotlin

val share = Intent.createChooser(myShareIntent, null).apply {
    putExtra(Intent.EXTRA_CHOOSER_TARGETS, myChooserTargetArray)
    putExtra(Intent.EXTRA_INITIAL_INTENTS, myInitialIntentArray)
}

Java

Intent shareIntent = Intent.createChooser(sendIntent, null);
share.putExtra(Intent.EXTRA_CHOOSER_TARGETS, myChooserTargetArray);
share.putExtra(Intent.EXTRA_INITIAL_INTENTS, myInitialIntentArray);

Use esse recurso com cuidado. Cada Intent personalizado e ChooserTarget que você adiciona reduz o número sugerido pelo sistema. Em geral, não recomendamos adicionar destinos personalizados. Um exemplo comum apropriado de adicionar Intent.EXTRA_INITIAL_INTENTS é disponibilizar outras ações que os usuários podem realizar em conjuntos conteúdo. Por exemplo, o usuário compartilha imagens, e Intent.EXTRA_INITIAL_INTENTS é usado para permitir que ele envie um link. Um exemplo comum da adição de Intent.EXTRA_CHOOSER_TARGETS é mostrar pessoas ou dispositivos relevantes que seu app oferece.

Excluir destinos específicos por componente

Você pode excluir destinos específicos fornecendo Intent.EXTRA_EXCLUDE_COMPONENTS. Faça isso apenas para remover segmentações que você controla. Um caso de uso comum é ocultar metas de compartilhamento do app quando seus usuários compartilham de dentro dele, já que a intenção deles provavelmente compartilhará fora do app.

Adicione Intent.EXTRA_EXCLUDE_COMPONENTS à intent depois de chamar Intent.createChooser():

Kotlin

  val share = Intent.createChooser(Intent(), null).apply {
    // Only use for components you have control over
    val excludedComponentNames = arrayOf(ComponentName("com.example.android", "ExampleClass"))
    putExtra(Intent.EXTRA_EXCLUDE_COMPONENTS, excludedComponentNames)
  }

Java

  Intent shareIntent = Intent.createChooser(new Intent(), null);
  // Only use for components you have control over
  ComponentName[] excludedComponentNames = {
          new ComponentName("com.example.android", "ExampleClass")
  };
  shareIntent.putExtra(Intent.EXTRA_EXCLUDE_COMPONENTS, excludedComponentNames);

Receber informações sobre o compartilhamento

Pode ser útil saber quando seus usuários estão compartilhando e qual é o destino selecionado. O O Android Sharesheet permite acessar essas informações fornecendo o ComponentName do segmenta seus usuários selecionados usando um IntentSender.

Primeiro, crie um PendingIntent para uma BroadcastReceiver e forneça o IntentSender em Intent.createChooser():

Kotlin

var share = Intent(Intent.ACTION_SEND)
// ...
val pi = PendingIntent.getBroadcast(
    myContext, requestCode,
    Intent(myContext, MyBroadcastReceiver::class.java),
    PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
)
share = Intent.createChooser(share, null, pi.intentSender)

Java

Intent share = new Intent(ACTION_SEND);
...
PendingIntent pi = PendingIntent.getBroadcast(myContext, requestCode,
        new Intent(myContext, MyBroadcastReceiver.class),
        PendingIntent.FLAG_MUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
share = Intent.createChooser(share, null, pi.getIntentSender());

Receba o callback em MyBroadcastReceiver e procure em Intent.EXTRA_CHOSEN_COMPONENT:

Kotlin

override fun onReceive(context: Context, intent: Intent) {
  ...
  val clickedComponent : ComponentName = intent.getParcelableExtra(EXTRA_CHOSEN_COMPONENT);
}

Java

@Override public void onReceive(Context context, Intent intent) {
  ...
  ComponentName clickedComponent = intent.getParcelableExtra(EXTRA_CHOSEN_COMPONENT);
}

Adicionar ações personalizadas à Sharesheet

No Android 14 (nível 34 da API) e versões mais recentes, os apps podem adicionar ações personalizadas ao Sharesheet do Android. Crie um ChooserAction com ChooserAction.Builder. É possível especificar um PendingIntent como a ação invocada quando o ícone é clicado. Crie uma matriz que contenha todas as suas ações personalizadas e especifique-a como EXTRA_CHOOSER_CUSTOM_ACTIONS do Intent de compartilhamento.

Kotlin

val sendIntent = Intent(Intent.ACTION_SEND)
    .setType("text/plain")
    .putExtra(Intent.EXTRA_TEXT, text)
val shareIntent = Intent.createChooser(sendIntent, null)
val customActions = arrayOf(
    ChooserAction.Builder(
        Icon.createWithResource(context, R.drawable.ic_custom_action),
        "Custom",
        PendingIntent.getBroadcast(
            context,
            1,
            Intent(Intent.ACTION_VIEW),
            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_CANCEL_CURRENT
        )
    ).build()
)
shareIntent.putExtra(Intent.EXTRA_CHOOSER_CUSTOM_ACTIONS, customActions)
context.startActivity(shareIntent)

Java

Intent sendIntent = new Intent(Intent.ACTION_SEND)
        .setType("text.plain")
        .putExtra(Intent.EXTRA_TEXT, text);
Intent shareIntent = Intent.createChooser(sendIntent, null);
ChooserAction[] actions = new ChooserAction[]{
        new ChooserAction.Builder(
                Icon.createWithResource(context, R.drawable.ic_custom_action),
                "Custom",
                PendingIntent.getBroadcast(
                        context,
                        1,
                        new Intent(Intent.ACTION_VIEW),
                        PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_CANCEL_CURRENT
                )
        ).build()
};
shareIntent.putExtra(Intent.EXTRA_CHOOSER_CUSTOM_ACTIONS, actions);
context.startActivity(shareIntent);

Usar o resolvedor de intents do Android

Captura de tela do resolvedor de intents ACTION_SEND.

O resolvedor de intents do Android é mais adequado para enviar dados para outro app como parte de um fluxo de tarefas bem definido.

Para usar o resolvedor de intents do Android, crie uma intent e adicione extras como faria para chamar no Android Sharesheet. No entanto, não chame Intent.createChooser().

Se houver vários aplicativos instalados com filtros que correspondem a ACTION_SEND e ao tipo MIME, o sistema vai mostrar uma caixa de diálogo de desambiguação chamada resolvedor de intents, que permite que o usuário escolha um destino de compartilhamento. Se um único aplicativo for correspondente, ele será executado.

Veja um exemplo de como usar o resolvedor de intents do Android para enviar texto:

Kotlin

val sendIntent: Intent = Intent().apply {
    action = Intent.ACTION_SEND
    putExtra(Intent.EXTRA_TEXT, "This is my text to send.")
    type = "text/plain"
}
startActivity(sendIntent)

Java

Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "This is my text to send.");
sendIntent.setType("text/plain");
startActivity(sendIntent);

Saiba mais

Para mais informações sobre o envio de dados, consulte Intents e filtros de intent.