Android usa intents y sus servicios adicionales asociados para que los usuarios puedan compartir información de forma rápida y fácilmente con sus aplicaciones favoritas.
Los usuarios pueden compartir contenido en Android de dos formas:
- Android Sharesheet está diseñada principalmente para enviar contenido fuera de tu app o directamente. a otro usuario. (por ejemplo, para compartir una URL con un amigo)
- El agente de resolución de intent de Android es más adecuado para pasar datos al la siguiente etapa de una tarea bien definida. Por ejemplo, abrir un PDF desde tu app y permitir que los usuarios y elige su público preferido.
Cuando construyes un intent, especificas la acción que quieres que realice.
Android usa la acción ACTION_SEND
.
para enviar datos de una actividad a otra
incluso más allá de los límites del proceso. Debes especificar
los datos y su tipo. El sistema identifica automáticamente las actividades compatibles
que puede recibir los datos y mostrárselos al usuario. En el caso del agente de resolución de intents,
si solo una actividad puede controlar el intent, esa actividad se inicia inmediatamente.
Por qué usar Android Sharesheet
![](https://developer.android.com/static/images/training/sharing/sharesheet.png?authuser=9&hl=es)
Recomendamos usar Android Sharesheet para mantener la coherencia entre tus usuarios de Google Chat. No muestres la lista de objetivos de uso compartido de tu app ni crees una propia. Variaciones de Sharesheet.
Android Sharesheet permite que los usuarios compartan información con el la persona adecuada, con sugerencias de aplicaciones relevantes, todo 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 app y la actividad del usuario que solo está disponible para el sistema.
Android Sharesheet también tiene diversas funciones útiles para desarrolladores. Por ejemplo, puedes haz lo siguiente:
- Conocer cuándo los usuarios implementan el uso compartido y dónde
- Agrega un
ChooserTarget
personalizado y destinos de apps - 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 establece su acción en
Intent.ACTION_SEND
Para mostrar Android Sharesheet, llama
Intent.createChooser()
,
y pasarle tu objeto Intent
.
Se mostrará una versión de tu intent que siempre incluye Android Sharesheet.
Enviar contenido de texto
El uso más sencillo y común de Android Sharesheet es enviar contenido de texto desde una actividad a otra. Por ejemplo, la mayoría de los navegadores pueden compartir la URL del sitio que se muestra actualmente. página como texto con otra aplicación. Esto es útil para compartir un artículo o sitio web con amigos a través de 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);
También puedes agregar datos adicionales 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 servicios adicionales 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
.
Establece el tipo de MIME adecuado y coloca un URI en los datos en la
EXTRA_STREAM
, 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 del Uri
.
señala. Estas son las dos formas recomendadas de hacerlo:
- Almacena los datos en tu
ContentProvider
y asegúrate de que los demás las apps tengan el permiso correcto para acceder a tu proveedor. El mecanismo preferido para proporcionar es usar permisos por URI, que son temporal y solo otorga acceso a la aplicación receptora. Una forma fácil de crearContentProvider
de esta manera es para usar Clase auxiliarFileProvider
. - Usa la clase
MediaStore
del sistema. ElMediaStore
es principalmente para tipos MIME de video, imagen y audio. Sin embargo, a partir de Android 3.0 (API nivel 11), también puede almacenar tipos que no son de medios. Para obtener más información, consultaMediaStore.Files
Se pueden insertar archivos enMediaStore
conscanFile()
, después de lo cualUri
al estilocontent://
apto para uso compartido se pasa alonScanCompleted()
devolución de llamada. Ten en cuenta que, una vez que se agregueMediaStore
al sistema, los usuarios podrán acceder al contenido cualquier app en el dispositivo.
Usa el tipo de MIME correcto
Proporciona el tipo de MIME más específico disponible para los datos que
el envío. Por ejemplo, usa text/plain
cuando compartas texto sin formato. Estos son algunos ejemplos
Tipos de MIME comunes cuando se envían 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 de MIME, consulta la IANA oficial de los tipos de medios MIME.
Android Sharesheet podría mostrar una vista previa de contenido según el tipo de MIME proporcionado. Algunos las funciones de versión preliminar solo están disponibles para tipos específicos.
Compartir varios contenidos
Para compartir varios tipos de contenido, usa el ACTION_SEND_MULTIPLE
.
junto con una lista de URIs que apuntan al contenido. El tipo de MIME varía según el
del contenido que compartes. Por ejemplo, si compartes tres imágenes JPEG, usas el tipo
"image/jpg"
Si usas una combinación de tipos de imágenes, usa "image/*"
para que coincida con un
que maneja cualquier tipo de imagen. Si bien es posible compartir una combinación de tipos,
desalentar esto, porque es
para que el receptor no sepa qué se debe enviar. Si es necesario enviar varios tipos, usa
"*/*"
Depende de la aplicación receptora analizarla.
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 los datos a los que puede 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
en los recursos compartidos de manera pública. En algunos casos, el texto que se comparte puede ser difícil de comprender. Considera compartir un
URL complicada, como https://www.google.com/search?ei=2rRVXcLkJajM0PEPoLy7oA4
. Una versión más completa
la vista previa puede asegurarles a los usuarios 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 utilizando ClipData
Nota: El URI de contenido de la imagen se proporciona desde un
FileProvider
, por lo general, de un <cache-path>
configurado
Para obtener más información, consulta Cómo compartir archivos. Asegúrate de dar
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 debería ser similar a la siguiente:
![](https://developer.android.com/static/images/training/sharing/sharing_content_preview.png?authuser=9&hl=es)
Agrega acciones personalizadas a Sharesheet
![](https://developer.android.com/static/images/training/sharing/sharesheet_custom_actions.png?authuser=9&hl=es)
Captura de pantalla de acciones personalizadas en Android 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
puede especificar cualquier Intent
como la acción invocada 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 con todas tus acciones personalizadas y especificarlo
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 del selector que se cargan desde ChooserTargetServices
. También puedes
especificar hasta dos intents que apunten a actividades enumeradas
antes de las sugerencias de la aplicación:
![](https://developer.android.com/static/images/training/sharing/customshare.png?authuser=9&hl=es)
Agrega Intent.EXTRA_CHOOSER_TARGETS
y Intent.EXTRA_INITIAL_INTENTS
a
tu intent para compartir después de la llamada
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
personalizado
y ChooserTarget
que agregues reduce la cantidad que sugiere el sistema. Por lo general,
no se recomienda agregar orientaciones personalizadas. Una forma apropiada de agregar
Intent.EXTRA_INITIAL_INTENTS
es proporcionar acciones adicionales que los usuarios puedan realizar en
contenido. Por ejemplo, un usuario comparte imágenes y se usa Intent.EXTRA_INITIAL_INTENTS
para
y permitirles que te envíen un vínculo. Una forma apropiada de agregar Intent.EXTRA_CHOOSER_TARGETS
es mostrar personas o dispositivos relevantes que proporciona la aplicación.
Excluye destinos específicos por componente
Puedes excluir segmentaciones específicas si proporcionas Intent.EXTRA_EXCLUDE_COMPONENTS
.
Solo debes seguir estos pasos para quitar las orientaciones sobre las que tienes el control. Un caso de uso común es ocultar tus
Los objetivos de uso compartido de la app cuando los usuarios comparten contenido desde la app, ya que es probable que su intención comparta
fuera de tu app.
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);
Obtener información sobre el uso compartido
Puede ser útil saber cuándo los usuarios comparten y qué destino seleccionan. El
Android Sharesheet te permite obtener esta información proporcionando el ComponentName
de
objetivo que los 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 Sharesheet
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 con todas tus acciones personalizadas y especificarlo
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);
Cómo usar el agente de resolución de intent de Android
![](https://developer.android.com/static/images/training/sharing/send_intent.png?authuser=9&hl=es)
Captura de pantalla del agente de resolución de intent de ACTION_SEND
.
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 intent de Android, crea un intent y agrega extras como lo harías con una llamada.
Android Sharesheet. Sin embargo, no llames
Intent.createChooser()
Si hay varias aplicaciones instaladas con filtros que coinciden
ACTION_SEND
y el tipo de MIME, el sistema muestra un diálogo de desambiguación llamado agente de resolución de intents
que permite al usuario elegir
un objetivo para compartir. Si una sola aplicación
coincide, se ejecuta.
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: