Sélection des formats de données pour le partage (HTML)

[ Cet article est destiné aux développeurs de Windows 8.x et Windows Phone 8.x qui créent des applications Windows Runtime. Si vous développez une application pour Windows 10, voir la Documentation ]

Que vous écriviez une application source, qui aide les utilisateurs à partager du contenu, ou une application cible, qui reçoit ce contenu, vous devez prendre le temps de déterminer les formats et les types de fichiers à prendre en charge. Nous allons décrire ici les formats standards pris en charge par l’espace de noms Windows.ApplicationModel.DataTransfer, et comment créer et utiliser des formats personnalisés lorsque les formats standards ne s’appliquent pas.

Sélection des formats de données pour une application source

Si vous écrivez une application source, vous n’êtes pas limité à un seul format de données ou type de fichier. Bien qu’il soit probable qu’un format soit plus logique que les autres, en mettant à disposition les mêmes données dans d’autres formats, vous veillez à ce que les utilisateurs puissent les partager en utilisant l’application cible de leur choix. Par exemple, si un utilisateur souhaite partager du texte mis en forme, notamment provenant d’une page Web, vous pouvez fournir une version du contenu en texte brut, car toutes les applications cibles ne prennent pas en charge du texte mis en forme.

Remarque  Le nombre de formats supplémentaires pris en charge dépend du type de contenu que vos utilisateurs partagent. Il est essentiel de tenir compte du contenu et des attentes des utilisateurs lorsqu’ils le partagent. Il est souvent logique de créer une version en texte brut d’un texte mis en forme. Cependant, créer un lien vers une page Web qui contient ce texte ne répond probablement pas aux attentes de l’utilisateur.

Exemple de scénario : l’utilisateur veut partager un article qu’il lit dans votre application. Si le contenu est disponible sur le Web, commencez par inclure un lien vers l’article. Incluez aussi un extrait de l’article avec un lien de retour vers la source au format HTML, ainsi que textuel.

Exemple de scénario : l’utilisateur souhaite partager une de l’article dans votre application. Dans ce cas, le format HTML reflète avec précision l’intention de l’utilisateur. Incluez également une version textuelle de la sélection de l’utilisateur. Pour cela, nous vous recommandons d’utiliser MSApp.createDataPackageFromSelection.

Ce tableau peut vous aider à décider des formats à prendre en charge en tant qu’application source.

Les formats personnalisés sont également pris en charge pour les cas où vous souhaiteriez être plus spécifique que ne le permettent les formats standard. Ces formats personnalisés peuvent être basés sur des schémas de données standard, tels que ceux disponibles sur le site http://www.schema.org, ou sur un format que vous définissez, qui est unique dans votre application.

Sélection des formats de données pour une application cible

Pour une application cible, nous vous recommandons de prendre en charge autant de types de formats que possible. Cela permet de vous assurer que votre application est disponible en tant qu’option lorsque les utilisateurs souhaitent partager des données. Toutefois, de même que pour les applications sources, n’assurez pas la prise en charge d’un format particulier si vous n’envisagez pas de recevoir ce type de données. Par exemple, une application qui accepte uniquement du texte ne doit pas prendre en charge les bitmaps.

Voici quelques recommandations relatives aux formats à prendre en charge.

Si votre application prend en charge plusieurs formats, et tous ces formats sont présents dans le contenu partagé, nous vous recommandons de traiter uniquement le format le plus approprié dans votre application. Par exemple, si votre application partage des liens, et reçoit du contenu partagé composé à la fois d’un lien et de texte, elle ne doit traiter que le lien.

Parfois, votre application peut tirer parti de la réception de données qui comportent plus d’informations que celles fournies par les formats standards. Par exemple, une application bibliothèque peut recevoir du texte, mais uniquement si ce texte contient des informations sur un ouvrage. Les formats personnalisés sont pris en charge dans de telles situations. Ces formats personnalisés peuvent être basés sur des schémas de données standard, tels que ceux disponibles sur le site http://www.schema.org, ou sur un format que vous définissez, qui est unique dans votre application.

Utilisation de formats basés sur un schéma

Il arrive souvent que les données à partager (en tant qu’application source ou cible) soient plus spécifiques que celles fournies par les formats standards. Par exemple, une application axée sur les films peut partager des informations sur des films, et souhaiter des détails tels que le titre, l’évaluation, le metteur en scène, etc. Une application axée sur les ouvrages peut partager des informations sur les ouvrages, notamment l’auteur, le titre et la date de publication. Si votre application entre dans une catégorie similaire, nous vous recommandons de prendre en charge l’un des nombreux schémas répertoriés sur le site http://www.schema.org.

Pour partager des données en utilisant l’un de ces schémas, procédez comme suit :

1. Identifiez l’élément (ouvrage, film, etc.) que l’utilisateur souhaite partager.
2. Collectez les informations associées à l’élément et empaquetez-les au format JSON (JavaScript Object Notation).
3. Utilisez setData pour ajouter le contenu à un objet DataPackage. Le cas échéant, vous devez inclure un ID de format. Pour le moment, utilisez http://schema.org/<schema> comme ID. Par exemple, http://schema.org/Book.

Cet exemple illustre comment partager des données dans un format personnalisé.

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

Notez que nous insérons un seul format de données dans DataPackage. Ainsi, les applications cibles sélectionnées par l’utilisateur savent à quoi s’attendre.

Si vous souhaitez recevoir des données qui utilisent l’un de ces schémas, voici la procédure à suivre :

1. Modifiez le manifeste de package pour déclarer que votre application est une cible de partage. Pour en savoir plus, consultez Démarrage rapide.
2. Dans le manifeste de package, ajoutez un format de données qui identifie le schéma pris en charge par votre application. Utilisez http://schema.org/<schema> comme format de données. Par exemple, http://schema.org/Book.
3. Utilisez getDataAsync pour obtenir le contenu de l’objet DataPackageView que vous recevez lors d’une opération de partage.

Cet exemple illustre comment recevoir des données partagées dans un format personnalisé.

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

Utilisation de formats personnalisés

Si vous ne trouvez aucun schéma sur le site http://schema.org/docs/full.htm qui répond aux besoins de votre application, vous avez également la possibilité de créer votre propre format personnalisé. Le cas échéant, gardez à l’esprit les points suivants :

• Le nom du format personnalisé est important. Le même nom doit être utilisé à la fois par l’application source et par l’application cible.
• Vous devez publier le format. Ainsi, les développeurs qui souhaitent l’utiliser savent comment empaqueter le contenu.

Ces considérations, et d’autres, sont traitées plus en détail dans Recommandations sur la création de formats de données personnalisés.

Rubriques associées

Exemple de partage de contenu source entre applications

Exemple de partage de contenu cible entre applications

Démarrage rapide : partage de contenu

Démarrage rapide : réception de contenu partagé