Enviar dados simples para outros apps

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

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, especifique a ação que ela deve executar. O Android usa a ação ACTION_SEND para enviar dados de uma atividade a outra, mesmo entre limites de processos. Você precisa especificar os dados e seu tipo. O sistema identifica automaticamente as atividades compatíveis que podem receber os dados e as mostra ao 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

Recomendamos o uso do Android Sharesheet para criar consistência para seus usuários em todos os 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 a pessoa certa e com sugestões de apps relevantes com um único toque. O Sharesheet pode sugerir destinos indisponíveis para soluções personalizadas e usa uma classificação consistente. Isso ocorre porque o Sharesheet pode considerar 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, é possível fazer o seguinte:

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

Usar o Android Sharesheet

Para todos os tipos de compartilhamento, crie uma intent e defina a ação dela como Intent.ACTION_SEND. Para exibir o Android Sharesheet, chame Intent.createChooser(), transmitindo seu objeto Intent. Ele retorna uma versão da sua intent que sempre exibe 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 mostrada 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);

Também é possível adicionar outros detalhes, como destinatários do 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 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 EXTRA_STREAM, conforme mostrado no exemplo abaixo. Ele é usado com frequência para compartilhar uma imagem, mas pode ser utilizado 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 app receptor precisa de permissão para acessar os dados para os quais o Uri aponta. 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 preferido para fornecer acesso é usar permissões por URI, que são temporárias e só concedem acesso ao app 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, do Android 3.0 (nível 11 da API) em diante, ele também pode armazenar tipos que não são de mídia. Para mais informações, consulte MediaStore.Files. Os arquivos podem ser inseridos no MediaStore usando scanFile(). Depois disso, um Uri de estilo content:// adequado para compartilhamento é transmitido para o callback onScanCompleted() fornecido. Depois de adicionado ao MediaStore do sistema, o conteúdo pode ser acessado por qualquer app no dispositivo.

Use o tipo MIME correto

Forneça o tipo MIME mais específico disponível para os dados enviados. Por exemplo, use text/plain ao compartilhar texto simples. Confira alguns tipos MIME comuns ao enviar dados simples no Android:

Para saber mais sobre os tipos MIME, consulte o registro oficial da IANA (link em inglês) de tipos de mídia MIME.

O Android Sharesheet pode mostrar uma visualização de conteúdo dependendo do tipo MIME fornecido. Alguns recursos de pré-lançamento estão disponíveis somente 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 mistura 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 processa qualquer tipo de imagem. Embora seja possível compartilhar uma mistura de tipos, não recomendamos isso, porque não está claro para o destinatário o que 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 podem ser acessados por um app receptor.

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 que está sendo compartilhado. Em alguns casos, o texto compartilhado pode ser difícil de entender. Considere compartilhar um URL complicado, como https://www.google.com/search?ei=2rRVXcLkJajM0PEPoLy7oA4. Uma visualização mais completa pode mostrar aos usuários o 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 de um <cache-path> configurado. Para mais informações, consulte Como compartilhar arquivos. Certifique-se de conceder ao Sharesheet as permissões corretas para ler qualquer imagem que quiser 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 vai ficar assim:

Adicionar ações personalizadas ao Sharesheet

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

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 pequenos ícones de ação na parte de cima do Android Sharesheet, e os apps podem especificar qualquer Intent como a ação invocada quando o ícone é clicado.

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

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 destinos do seletor 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():

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. Em geral, não recomendamos adicionar destinos personalizados. 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 que o app oferece.

Excluir destinos específicos por componente

É possível excluir segmentações específicas fornecendo Intent.EXTRA_EXCLUDE_COMPONENTS. Só faça isso para remover destinos sobre os quais você tem controle. Um caso de uso comum é ocultar os destinos de compartilhamento do seu app quando os usuários compartilham de dentro dele, já que a intent provavelmente vai compartilhar fora do app.

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 compartilhamento

Pode ser útil saber quando os usuários estão compartilhando e qual destino eles selecionam. O Android Sharesheet permite acessar essas informações fornecendo o ComponentName dos destinos 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 ao Sharesheet

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 contendo todas as suas ações personalizadas e especifique-a como EXTRA_CHOOSER_CUSTOM_ACTIONS do compartilhamento Intent.

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 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 para compartilhar. Se um único aplicativo corresponder, 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 intents.