Android usa intents y sus servicios adicionales asociados para que los usuarios puedan compartir información de forma rápida y sencilla con sus apps favoritas.
Los usuarios pueden compartir contenido en Android de dos formas:
- Android Sharesheet, que se diseñó para enviar contenido fuera de la app o directamente a otro usuario (por ejemplo, para compartir una URL con un amigo)
- El agente de resolución de intents de Android es más adecuado para pasar datos a la siguiente etapa de una tarea bien definida. (por ejemplo, abrir un PDF desde la app y permitir a los usuarios seleccionar el visor preferido)
Cuando construyes un intent, debes especificar la acción que quieres que lleve a cabo.
Android usa la acción ACTION_SEND
para enviar datos de una actividad a otra, incluso entre límites de procesos. Debes especificar los datos y su tipo. El sistema identifica automáticamente las actividades compatibles que pueden recibir los datos y se las muestra al usuario. En el caso del agente de resolución de intents, si solo una actividad puede controlar el intent, esa actividad se inicia de inmediato.
Por qué usar Android Sharesheet
Te recomendamos que uses Android Sharesheet a fin de crear coherencia para tus usuarios en todas las apps. No muestres la lista de objetivos de uso compartido de tu app ni crees tus propias variaciones de Sharesheet.
Android Sharesheet permite que los usuarios compartan información con la persona adecuada, mediante sugerencias relevantes de la app, con un solo toque. Sharesheet puede sugerir objetivos no disponibles para soluciones personalizadas y usa una clasificación coherente. Esto se debe a que Sharesheet puede tener en cuenta información sobre la actividad de la app y del usuario que solo está disponible para el sistema.
Android Sharesheet también tiene diversas funciones útiles para desarrolladores. Por ejemplo, puedes hacer lo siguiente:
- Conocer cuándo los usuarios implementan el uso compartido y dónde
- Agrega un
ChooserTarget
y destinos de apps personalizados - Proporcionar vistas previas de contenido de texto enriquecido a partir de Android 10 (nivel de API 29)
- Cómo excluir destinos que coincidan con nombres de componentes específicos
Cómo usar Android Sharesheet
Para todos los tipos de uso compartido, crea un intent y configura la acción en Intent.ACTION_SEND
.
Para mostrar Android Sharesheet, llama a Intent.createChooser()
y pásale tu objeto Intent
.
Se mostrará una versión de tu intent que siempre estará disponible en Android Sharesheet.
Enviar contenido de texto
El uso más simple y común de Android Sharesheet es el envío de contenido de texto desde una actividad a otra. Por ejemplo, la mayoría de los navegadores pueden compartir la URL de la página que se muestra actualmente como texto con otra app. Esto es útil para compartir un artículo o sitio web con amigos por correo electrónico o redes sociales. Este es un ejemplo de cómo hacerlo:
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);
De manera opcional, puedes agregar extras para incluir más información, como los destinatarios del correo electrónico
(EXTRA_EMAIL
,
EXTRA_CC
,
EXTRA_BCC
),
el asunto del correo electrónico
(EXTRA_SUBJECT
), etcétera.
Nota: Algunas apps de correo electrónico, como Gmail, esperan una String[]
para extras como EXTRA_EMAIL
y EXTRA_CC
. Usa putExtra(String, String[])
para agregarlos a tu intent.
Enviar contenido binario
Comparte los datos binarios con la acción ACTION_SEND
.
Define el tipo de MIME adecuado y coloca una URI en los datos del EXTRA_STREAM
adicional, como se muestra en el siguiente ejemplo.
Por lo general, se usa para compartir una imagen, pero se puede utilizar para compartir cualquier tipo de contenido binario.
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));
La aplicación receptora necesita permiso para acceder a los datos a los que apunta la Uri
. Existen dos maneras recomendadas de hacerlo:
- Almacena los datos en tu
ContentProvider
y asegúrate de que otras apps tengan el permiso correcto para acceder a tu proveedor. El mecanismo preferido para proporcionar acceso es usar permisos por URI, que son temporales y solo otorgan acceso a la aplicación receptora. Una manera fácil de crear unContentProvider
como este es usar la clase auxiliarFileProvider
. - Usa la clase
MediaStore
del sistema.MediaStore
es principalmente para tipos de MIME de video, imagen y audio. Sin embargo, a partir de Android 3.0 (nivel de API 11), también puede almacenar tipos que no son de contenido multimedia. Para obtener más información, consultaMediaStore.Files
. Los archivos se pueden insertar enMediaStore
conscanFile()
. Después de eso, se pasa unUri
de estilocontent://
adecuado para el uso compartido a la devolución de llamadaonScanCompleted()
proporcionada. Ten en cuenta que, una vez que se agregueMediaStore
al sistema, cualquier app del dispositivo podrá acceder al contenido.
Usa el tipo de MIME correcto
Proporciona el tipo de MIME más específico disponible para los datos que envías. Por ejemplo, usa text/plain
cuando compartas texto sin formato. Estos son algunos tipos de MIME comunes que se usan al enviar datos simples en Android:
Los receptores se registran para | Los remitentes envían |
---|---|
text/* |
|
`image/*` |
|
video/* |
|
Extensiones de archivo compatibles | application/pdf |
Para obtener más información sobre los tipos MIME, consulta el registro oficial de la IANA de los tipos de medios MIME.
Android Sharesheet también puede mostrar una vista previa de contenido, según el tipo de MIME proporcionado. Algunas funciones de vista previa solo están disponibles para tipos específicos.
Compartir varios contenidos
Para compartir varios contenidos, usa la acción ACTION_SEND_MULTIPLE
, junto con una lista de URI que apunta al contenido. El tipo de MIME varía según la combinación de contenido que compartes. Por ejemplo, si compartes tres imágenes JPEG, debes usar el tipo "image/jpg"
. En el caso de una combinación de tipos de imágenes, usa "image/*"
para hacer coincidir una actividad que controle cualquier tipo de imagen. Si bien es posible compartir una combinación de tipos, no se recomienda, ya que no es claro para el receptor qué se pretende enviar. Si es necesario enviar varios tipos, usa "*/*"
. Depende de la aplicación receptora
analizar y procesar tus datos. Por ejemplo:
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));
Asegúrate de que los objetos Uri
proporcionados apunten a datos a los que pueda acceder una aplicación receptora.
Cómo agregar contenido enriquecido a las vistas previas de texto
A partir de Android 10 (nivel de API 29), Android Sharesheet muestra una vista previa del texto que se comparte. En algunos casos, el texto que se comparte puede ser difícil de comprender. Te recomendamos compartir una URL complicada, como https://www.google.com/search?ei=2rRVXcLkJajM0PEPoLy7oA4
. Una vista previa enriquecida ayudará a los usuarios a comprender lo que se comparte.
Mientras se muestra una vista previa del texto, puedes definir un título, una imagen en miniatura o ambas. Agrega una descripción a Intent.EXTRA_TITLE
antes de llamar a Intent.createChooser()
y agrega una miniatura relevante con ClipData
.
Nota: El URI de contenido de la imagen se proporciona desde un FileProvider
, por lo general, desde un <cache-path>
configurado.
Para obtener más información, consulta Cómo compartir archivos. Asegúrate de otorgarle a Sharesheet los permisos adecuados para leer cualquier imagen que quieras usar como miniatura. Para obtener más información, consulta Intent.FLAG_GRANT_READ_URI_PERMISSION
.
Por ejemplo:
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));
La vista previa se verá de la siguiente manera:
Agrega acciones personalizadas a Sharesheet
En Android 14 (nivel de API 34) y versiones posteriores, las apps pueden agregar acciones personalizadas a Android Sharesheet.
Las acciones personalizadas se muestran como pequeños íconos de acción en la parte superior de Android Sharesheet, y las apps pueden especificar cualquier Intent
como la acción que se invoca cuando se hace clic en el ícono.
Para agregar acciones personalizadas en Android Sharesheet, primero crea un ChooserAction
con ChooserAction.Builder
.
Puedes especificar un PendingIntent
como la acción que se invoca cuando se hace clic en el ícono. Crea un array que contenga todas tus acciones personalizadas y especifícalo como EXTRA_CHOOSER_CUSTOM_ACTIONS
del Intent
compartido.
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);
Agregar destinos personalizados
Android Sharesheet te permite especificar hasta dos objetos ChooserTarget
que se muestran antes de los accesos directos de uso compartido y los objetivos de selector cargados desde ChooserTargetServices
. También puedes especificar hasta dos intents que apunten a actividades que se enumeran antes de las sugerencias de la app:
Agrega Intent.EXTRA_CHOOSER_TARGETS
y Intent.EXTRA_INITIAL_INTENTS
a tu intent de uso compartido después de llamar a 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);
Usa esta función con cuidado. Cada Intent
y ChooserTarget
personalizados que agregas reduce la cantidad que sugiere el sistema. Por lo general, no se recomienda agregar destinos personalizados. Una forma apropiada de agregar Intent.EXTRA_INITIAL_INTENTS
es proporcionar acciones adicionales que los usuarios puedan realizar en el contenido compartido. Por ejemplo, un usuario comparte imágenes y se usa Intent.EXTRA_INITIAL_INTENTS
para permitirle enviar un vínculo. Una forma apropiada de agregar Intent.EXTRA_CHOOSER_TARGETS
es indicar personas o dispositivos relevantes que proporciona tu app.
Excluye destinos específicos por componente
Puedes excluir segmentaciones específicas si proporcionas Intent.EXTRA_EXCLUDE_COMPONENTS
.
Solo haz esto para quitar los destinos que controlas. Un caso de uso común consiste en ocultar los objetivos de uso compartido de tu app cuando los usuarios comparten contenido desde la app, ya que es probable que su intent comparta fuera de ella.
Agrega Intent.EXTRA_EXCLUDE_COMPONENTS
a tu intent después de llamar a 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);
Obtén información sobre el uso compartido
Puede ser útil saber cuándo los usuarios comparten y qué destino seleccionan. Android Sharesheet te permite obtener esta información proporcionando el ComponentName
de los destinos que tus usuarios seleccionan mediante un IntentSender
.
Primero, crea un PendingIntent
para un BroadcastReceiver
y proporciona su IntentSender
en 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());
Recibe la devolución de llamada en MyBroadcastReceiver
y busca en 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); }
Agrega acciones personalizadas a la hoja compartida
En Android 14 (nivel de API 34) y versiones posteriores, las apps pueden agregar acciones personalizadas a Android Sharesheet.
Crea un ChooserAction
con ChooserAction.Builder
.
Puedes especificar un PendingIntent
como la acción que se invoca cuando se hace clic en el ícono. Crea un array que contenga todas tus acciones personalizadas y especifícalo como EXTRA_CHOOSER_CUSTOM_ACTIONS
del elemento compartido Intent
.
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);
Cómo usar el agente de resolución de intents de Android
El agente de resolución de intent de Android se usa mejor cuando se envían datos a otra app como parte de un flujo de tareas bien definido.
Para usar el agente de resolución de intents de Android, crea un intent y agrega servicios adicionales como si llamaras a Android Sharesheet. Sin embargo, no llames a Intent.createChooser()
.
Si hay varias aplicaciones instaladas con filtros que coinciden con ACTION_SEND
y el tipo de MIME, el sistema mostrará un diálogo de desambiguación, denominado agente de resolución de intents, que permite al usuario elegir un destino donde compartir. Si se encuentra una aplicación, se ejecutará.
A continuación, se muestra un ejemplo de cómo usar el agente de resolución de intent de 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);
Más información
Para obtener más información sobre el envío de datos, consulta Intents y filtros de intents.