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 para o próximo estágio de uma tarefa bem definida. Por exemplo, abrir um PDF no seu app e permitir que os usuários escolham o visualizador 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 podem receber os dados e os exibe para o usuário. No caso do resolvedor de intents, se apenas uma atividade puder processar a intent, ela 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 as próprias variações do Sharesheet.

O Android Sharesheet permite que os usuários compartilhem informações com a pessoa certa, oferecendo 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 um ChooserTarget e destinos de app personalizados
• Oferecer 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 o 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 da página exibida no momento como texto com outro app. Isso é útil para compartilhar um artigo ou site com amigos por e-mail ou rede social. Veja como fazer isso a seguir:

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)

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 outros elementos para incluir mais informações, como destinatários de e-mail (EXTRA_EMAIL, EXTRA_CC, EXTRA_BCC), assunto do e-mail (EXTRA_SUBJECT) etc.

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

Enviar conteúdo binário

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

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))

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 próprio ContentProvider, garantindo que outros apps tenham 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. Confira alguns tipos MIME comuns para o envio de dados simples no Android:

Para saber mais sobre tipos MIME, consulte o registro oficial IANA (link em inglês) 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 pré-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 o mix de conteúdo que você compartilha. 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 combinação de tipos, não recomendamos fazer isso, porque não está claro para o destinatário 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:

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))

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 para dados que um app receptor pode acessar.

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

A partir do Android 10 (API de nível 29), o Android Sharesheet mostra uma visualização do texto 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 visualização mais avançada 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 para 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 de 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:

 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)

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 fica assim:

Adicionar ações personalizadas à Sharesheet

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

No Android 14 (nível 34 da API) e versões mais recentes, os apps podem adicionar ações personalizadas ao Sharesheet do Android. 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.

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)

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 apontem 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():

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

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 e ChooserTarget personalizados que você adiciona reduz o número sugerido pelo sistema. Geralmente, não recomendamos adicionar segmentações personalizadas. Um exemplo comum da adição de Intent.EXTRA_INITIAL_INTENTS é disponibilizar outras ações que os usuários podem realizar em conteúdos compartilhados. Por exemplo, um 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 oferecidos pelo app.

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 os destinos de compartilhamento do app quando os usuários compartilham de dentro dele, uma vez que a intent tende a compartilhar fora dele.

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

  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)
  }

  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 Android Sharesheet permite que você receba essas informações fornecendo o ComponentName de segmentações que os usuários selecionam usando um IntentSender.

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

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)

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:

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

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

Adicionar ações personalizadas à planilha

No Android 14 (nível 34 da API) e versões mais recentes, os apps podem adicionar ações personalizadas ao Android Sharesheet. 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 da Intent de compartilhamento.

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)

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 elementos extras como você faria para chamar o 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:

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

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 saber mais sobre o envio de dados, consulte Intents e filtros de intent.