Comment accéder à un flux Web (HTML)

Article
12/11/2015

[ 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 ]

Cette rubrique montre comment récupérer et afficher un flux Web à l’aide des classes de l’espace de noms Windows.Web.Syndication dans votre application Windows Runtime.

Prérequis

Les exemples suivants utilisent JavaScript et reposent sur l’exemple de syndication. Pour obtenir une aide générale sur la création d’une application Windows Runtime en JavaScript, voir Créer votre première application Windows Runtime en JavaScript. De plus, les promesses JavaScript sont utilisées dans cette rubrique pour mener des opérations asynchrones. Pour plus d’informations sur ce modèle de programmation, voir Programmation asynchrone en JavaScript à l’aide de promesses.

Pour vous assurer que votre application Windows Runtime est prête à être utilisée en réseau, vous devez définir les fonctionnalités réseau nécessaires dans le fichier Package.appxmanifest du projet. Si votre application doit se connecter en qualité de client à des services distants sur Internet, la fonctionnalité Internet (client) est nécessaire. Si l’application doit se connecter en qualité de client à des services distants sur un réseau domestique ou professionnel, la fonctionnalité Réseau domestique/professionnel est nécessaire. Pour plus d’informations, voir Comment définir les fonctionnalités réseau.

Instructions

Récupération d’un contenu syndiqué dans un flux Web

Nous allons maintenant examiner du code qui illustre comment extraire un flux puis afficher chaque élément qu’il contient. Avant de pouvoir configurer et envoyer la requête, nous allons définir quelques variables que nous utiliserons durant l’opération et initialiser une instance de SyndicationClient, qui définit les méthodes et propriétés que nous utiliserons pour extraire et afficher le flux.

Le constructeur Uri lève une exception si le uriString passé au constructeur n’est pas un URI valide. Ainsi, nous validons uriString à l’aide d’un bloc try/catch.

var currentFeed = null;
var currentItemIndex = 0;
        
var client = new Windows.Web.Syndication.SyndicationClient();

// The URI is validated by catching exceptions thrown by the Uri constructor.
var uri = null;
try {
    uri = new Windows.Foundation.Uri(uriString);
} catch (error) {
    WinJS.log && WinJS.log("Error: Invalid URI");
    return;
}

Ensuite, nous configurerons la requête en définissant les informations d’identification de serveur (propriété serverCredential), les informations d’identification de proxy (propriété proxyCredential) et les en-têtes HTTP (méthode setRequestHeader) nécessaires. Une fois les paramètres de requête de base configurés, un objet Uri valide est créé à l’aide d’une chaîne d’URI de flux fournie par l’application. L’objet Uri est ensuite passé à la fonction retrieveFeedAsync pour demander le flux.

En supposant que le contenu de flux souhaité a été renvoyé, le code itère chaque élément de flux et appelle displayCurrentItem (que nous allons définir ensuite), pour afficher les éléments et leur contenu sous forme de liste dans l’interface utilisateur.

Vous devez écrire du code capable de gérer les exceptions au moment où vous appelez la plupart des méthodes réseau asynchrones. Votre gestionnaire d’exceptions peut récupérer des informations plus détaillées sur la cause de l’exception dans le but d’analyser l’échec et de prendre des décisions appropriées. Pour plus d’informations, voir Comment gérer les exceptions dans les applications réseau.

La méthode retrieveFeedAsync lève une exception si aucune connexion n’a pu être établie avec le serveur HTTP ou si l’Uri ne pointe pas vers un flux AtomPub ou RSS valide. L’exemple de code utilise une fonction onError pour intercepter les exceptions, et affiche des informations plus détaillées sur l’exception si une erreur se produit.

function onError(err) {
    WinJS.log && WinJS.log(err, "sample", "error");

    // Match error number with a ErrorStatus value.
    // Use Windows.Web.WebErrorStatus.getStatus() to retrieve HTTP error status codes.
    var errorStatus = Windows.Web.Syndication.SyndicationError.getStatus(err.number);
    if (errorStatus === Windows.Web.Syndication.SyndicationErrorStatus.invalidXml) {
        displayLog("An invalid XML exception was thrown. Please make sure to use a URI that points to a RSS or Atom feed.");
    }
}

// Retrieve and display feed at given feed address.
function retreiveFeed(uri) {

    // Although most HTTP servers do not require User-Agent header, 
    // others will reject the request or return a different response if this header is missing.
    // Use the setRequestHeader() method to add custom headers.
    client.setRequestHeader("User-Agent", "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)");

    client.retrieveFeedAsync(uri).done(function (feed) {
        currentFeed = feed;

        WinJS.log && WinJS.log("Feed download complete.", "sample", "status");

        var title = "(no title)";
        if (currentFeed.title) {
            title = currentFeed.title.text;
        }
        document.getElementById("CurrentFeedTitle").innerText = title;

        currentItemIndex = 0;
        if (currentFeed.items.size > 0) {
            displayCurrentItem();
        }

        // List the items.
        displayLog("Items: " + currentFeed.items.size);
     }, onError);
}

Durant l’étape précédente, retrieveFeedAsync a renvoyé le contenu de flux demandé et l’exemple de code a commencé à itérer les éléments de flux disponibles. Chacun de ces éléments est représenté à l’aide d’un objet SyndicationItem qui contient tout le contenu et les propriétés d’éléments offerts par la norme de syndication pertinente (RSS ou Atom). Dans l’exemple suivant, la fonction displayCurrentItem itère chaque élément et affiche son contenu dans différents éléments d’interface utilisateur.

function displayCurrentItem() {
    var item = currentFeed.items[currentItemIndex];

    // Display item number.
    document.getElementById("Index").innerText = (currentItemIndex + 1) + " of " + currentFeed.items.size;

    // Display title.
    var title = "(no title)";
    if (item.title) {
        title = item.title.text;
    }
    document.getElementById("ItemTitle").innerText = title;

    // Display the main link.
    var link = "";
    if (item.links.size > 0) {
        link = item.links[0].uri.absoluteUri;
    }

    var link = document.getElementById("Link");
    link.innerText = link;
    link.href = link;

    // Display the body as HTML.
    var content = "(no content)";
    if (item.content) {
        content = item.content.text;
    }
    else if (item.summary) {
        content = item.summary.text;
    }
    document.getElementById("WebView").innerHTML = window.toStaticHTML(content);

Comme mentionné plus haut, le type de contenu représenté par un objet SyndicationItem sera différent en fonction de la norme de flux (RSS ou Atom) utilisée pour publier le flux. Par exemple, un flux Atom est capable de fournir une liste de contributors, ce qui n’est pas le cas d’un flux RSS. Toutefois, les éléments d’extension inclus dans un élément de flux qui ne sont pas pris en charge par l’une ou l’autre norme (par exemple les éléments d’extension Dublin Core) sont accessibles à l’aide de la propriété SyndicationItem.elementExtensions puis affiché comme illustré dans l’exemple de code suivant :


    // displayCurrentItem function continued
    var bindableNodes = [];
    for (var i = 0; i < item.elementExtensions.size; i++) {
        var bindableNode = {
            nodeName: item.elementExtensions[i].nodeName,
             nodeNamespace: item.elementExtensions[i].nodeNamespace,
             nodeValue: item.elementExtensions[i].nodeValue,
        };
        bindableNodes.push(bindableNode);
    }

    var dataList = new WinJS.Binding.List(bindableNodes);
    var listView = document.getElementById("extensionsListView").winControl;
    WinJS.UI.setOptions(listView, {
        itemDataSource: dataList.dataSource

    });
}

Récapitulatif et étapes suivantes

Dans cette rubrique, nous avons récupéré un flux associé à un URI fourni et affiché le contenu du flux élément par élément.

Si vous souhaitez des fonctionnalités avancées comme la possibilité d’ajouter, de modifier et de supprimer des entrées dans un flux Web, voir Comment gérer des entrées de flux Web.