Elección de formatos de datos para uso compartido (HTML)

[ Este artículo está destinado a desarrolladores de Windows 8.x y Windows Phone 8.x que escriben aplicaciones de Windows en tiempo de ejecución. Si estás desarrollando para Windows 10, consulta la documentación más reciente

Independientemente de si vas a escribir una aplicación de origen, que ayuda a los usuarios a compartir contenido, o una aplicación de destino, que recibe ese contenido, debes dedicar algo de tiempo a considerar qué formatos de datos y tipos de archivo quieres admitir. Aquí describiremos los formatos estándar que admite el espacio de nombres de Windows.ApplicationModel.DataTransfer y cómo crear y usar formatos personalizados cuando no se aplican los formatos estándar.

Elección de formatos de datos para una aplicación de origen

Si vas a escribir una aplicación de origen, no debes limitarte a un solo formato de datos o tipo de archivo. Si bien es probable que un formato tenga más sentido que otros, al suministrar los mismos datos en otros formatos ayudas a garantizar que los usuarios puedan compartir usando la aplicación de destino de su elección. Por ejemplo, si un usuario desea compartir texto con formato, por ejemplo, el texto de una página web, es posible que también desees proporcionar una versión de texto sin formato del contenido, ya que no todas las aplicaciones de destino admiten texto con formato.

Nota  La cantidad de formatos adicionales que admitas depende del tipo de contenido que el usuario podría compartir. Es importante tener en cuenta cuál es el contenido y qué espera el usuario al compartirlo. Por ejemplo, a menudo conviene crear una versión de texto sin formato de texto con formato. Sin embargo, es posible que el usuario no espere que se cree un vínculo a una página web que contenga ese texto.

Escenario de ejemplo: el usuario quiere compartir un artículo que está leyendo en tu aplicación. Si el contenido está disponible en la Web, incluye primero un vínculo al artículo. Además, debes incluir un resumen del artículo con un vínculo al origen en formato HTML, así como texto.

Escenario de ejemplo: el usuario quiere compartir una selección del artículo en tu aplicación. En este caso, el formato HTML refleja de forma más precisa la intención del usuario. También debes incluir una versión de texto de la selección del usuario. La mejor manera de lograr esto es usar MSApp.createDataPackageFromSelection.

Esta tabla puede ayudarte a decidir qué formatos debes admitir en una aplicación de origen.

Los formatos personalizados también se admiten para situaciones en las que quieras ser más específico de lo que te permiten los formatos estándar. Estos formatos personalizados pueden estar basados en esquemas de datos estándar, como los que se encuentran en http://www.schema.org, o en un formato que puedes definir y que es exclusivo para tu aplicación.

Elección de formatos de datos para una aplicación de destino

Para una aplicación de destino, te recomendamos que intentes admitir tantos tipos de formato como sea posible. Esto ayuda a garantizar que tu aplicación esté disponible como opción en cualquier momento que el usuario quiera compartir contenido. Sin embargo, al igual que las aplicaciones de origen, no debes admitir un determinado formato si no tienes previsto recibir ese tipo de datos. Por ejemplo, una aplicación que solo acepta texto no debe registrar que admite mapas de bits.

Aquí te damos algunas recomendaciones acerca de los formatos que debes admitir.

Si tu aplicación puede admitir varios formatos de datos y todos esos formatos están presentes en el contenido que se va a compartir, te recomendamos que proceses solamente el formato que sea más relevante para tu aplicación. Por ejemplo, si tu aplicación comparte vínculos y recibe contenido compartido que incluye un vínculo y también texto, debe procesar solamente el vínculo.

A veces, es posible que sea conveniente que tu aplicación reciba datos que incluyan más información que la que proporcionan los formatos estándar. Por ejemplo, es posible que una aplicación de biblioteca quiera recibir texto, pero solamente si dicho texto incluye información acerca de un libro en particular. Los formatos personalizados se admiten para situaciones como estas. Estos formatos personalizados pueden estar basados en esquemas de datos estándar, como los que se encuentran en http://www.schema.org, o en un formato que puedes definir y que es exclusivo para tu aplicación.

Uso de formatos basados en esquemas

Hay muchas ocasiones en las que los datos que quieres compartir (con una aplicación de origen o de destino) son más específicos que los que ofrecen los formatos estándar. Por ejemplo, es posible que una aplicación específica para películas quiera compartir información sobre películas e incluir detalles como título, clasificación, director, etc. También es posible que una aplicación específica para libros quiera compartir información sobre libros e datos como autor, título y fecha de publicación. Si tu aplicación entra una categoría como esta, te recomendamos que admitas uno de los diversos esquemas que aparecen en http://www.schema.org.

Si quieres compartir datos usando uno de estos esquemas, aquí te mostramos cómo hacerlo:

1. Identifica el elemento (libro, película, etc.) que el usuario quiere compartir.
2. Recopila la información relacionada con el elemento y empaquétala con el formato de notación de objetos JavaScript (JSON).
3. Usa setData para agregar contenido a un DataPackage. Cuando lo hagas, debes incluir un ID de formato. Por ahora, usa http://schema.org/<schema> como ID. Por ejemplo, http://schema.org/Book.

Este ejemplo muestra cómo compartir datos que están en un formato personalizado.

var book = {
    "type" : "http://schema.org/Book",
    "properties" : 
    {
         "image" : "http://sourceurl.com/catcher-in-the-rye-book-cover.jpg",
         "name" : "The Catcher in the Rye",
         "bookFormat" : "http://schema.org/Paperback",
         "author" : "http://sourceurl.com/author/jd_salinger.html",
         "numberOfPages" : 224,
         "publisher" : "Little, Brown, and Company",
         "datePublished" : "1991-05-01",
         "inLanguage" : "English",
         "isbn" : "0316769487"
    }
};
book = JSON.stringify(book);

function shareCustomData() {
    var dataTransferManager = Windows.ApplicationModel.DataTransfer.DataTransferManager.getForCurrentView();
    dataTransferManager.addEventListener("datarequested", function (e) {
        var request = e.request;
        request.data.setData("http://schema.org/Book", book);
    });
}

Ten en cuenta que incluimos un solo formato de datos en DataPackage. De este modo, todas las aplicaciones de destino que seleccione el usuario sabrán qué esperar.

Si quieres recibir datos que usen uno de estos esquemas, aquí te mostramos los pasos que debes seguir:

1. Edita el archivo de manifiesto de tu paquete para declarar que tu aplicación es un destino de recursos compartidos. Consulta el Inicio rápido para obtener información sobre cómo hacerlo.
2. En el archivo de manifiesto de tu paquete, agrega un formato de datos que identifique el esquema que admite tu aplicación. Usa http://schema.org/<schema> como formato de datos. Por ejemplo, http://schema.org/Book.
3. Usa getDataAsync para obtener el contenido del objeto DataPackageView que recibes durante una operación de uso compartido de contenido.

Este ejemplo muestra cómo recibir datos compartidos que están en un formato personalizado.

if (shareOperation.data.contains("http://schema.org/Book")) {
    shareOperation.data.getTextAsync(("http://schema.org/Book").done(function (customFormatString) {
        var customFormatObject = JSON.parse(customFormatString);
        if (customFormatObject) {
            // This sample expects the custom format to be of type http://schema.org/Book
            if (customFormatObject.type === "http://schema.org/Book") {
                customFormatString = "Type: " + customFormatObject.type;
                if (customFormatObject.properties) {
                    customFormatString += "\nImage: " 
                            + customFormatObject.properties.image
                            + "\nName: " + customFormatObject.properties.name
                            + "\nBook Format: " + customFormatObject.properties.bookFormat
                            + "\nAuthor: " + customFormatObject.properties.author
                            + "\nNumber of Pages: " + customFormatObject.properties.numberOfPages
                            + "\nPublisher: " + customFormatObject.properties.publisher
                            + "\nDate Published: " + customFormatObject.properties.datePublished
                            + "\nIn Language: " + customFormatObject.properties.inLanguage
                            + "\nISBN: " + customFormatObject.properties.isbn;
                }
            }
        }
    });
}

Uso de formatos personalizados

Si no encuentras un esquema en http://schema.org/docs/full.htm que satisfaga las necesidades de tu aplicación, también tienes la opción de crear tu propio formato personalizado. Si decides hacerlo, debes recordar algunos conceptos clave:

• El nombre del formato personalizado es importante. La aplicación de origen y la aplicación de destino deben usar el mismo nombre.
• Debes publicar el formato. De esa manera, los desarrolladores que deseen usar el formato sabrán cómo deben empaquetar el contenido.

Tratamos estas y otras consideraciones de manera más detallada en las Directrices para crear formatos de datos personalizados.

Temas relacionados

Muestra de una aplicación de origen de contenido compartido

Muestra de una aplicación de destino de contenido compartido

Inicio rápido: compartir contenido

Inicio rápido: recepción de contenido compartido