mozilla
Vos résultats de recherche

    API d'accès au contenu de flux

    Firefox 2 et Thunderbird 2 introduisent de nouvelles interfaces permettant aux développeurs d'extensions d'accéder plus facilement aux flux RSS et Atom.

    Les interfaces de flux

    nsIFeed
    Représente un flux RSS ou Atom.
    nsIFeedContainer
    Une classe de base dont dérivent plusieurs des interfaces liées aux flux.
    nsIFeedElementBase
    Une classe de base dont dérivent plusieurs des autres interfaces liées aux flux.
    nsIFeedEntry
    Représente une entrée unique dans un flux RSS ou Atom.
    nsIFeedGenerator
    Décrit le logiciel générateur du flux RSS ou Atom.
    nsIFeedPerson
    Représente une personne. Contient le nom de la personne, son adresse de courrier électronique et celle de sa page Web.
    nsIFeedProcessor
    Analyse les flux RSS et Atom.
    nsIFeedProgressListener
    Implémentée par le logiciel désirant analyser le flux RSS ou Atom pour recevoir des messages pendant le processus d'analyse.
    nsIFeedResult
    Décrit le résultat de l'analyse d'un flux.
    nsIFeedResultListener
    Implémentée par le logiciel désirant analyser le flux RSS ou Atom pour recevoir un message lorsque l'analyse est terminée.
    nsIFeedTextConstruct
    Représente les valeurs texte dans un flux ; comprend les fonctions permettant de charger le texte au format texte ou HTML.
    nsIScriptableUnescapeHTML
    Une classe utilitaire qui décode les chaînes HTML.

    Exemple : lecture d'un flux depuis le Web

    Il est assez facile de lire et d'analyser un flux. Utilisez XMLHttpRequest pour charger le flux, puis analysez la chaîne reçue à l'aide de nsIFeedProcessor.

    Le chargement et l'envoi du flux vers l'analyseur peuvent se faire à l'aide d'un code semblable à celui-ci :

      fetch: function(feedUrl)
      {
        var httpRequest = null;
        
        function infoReceived() {
          var data = httpRequest.responseText;
          
          var ioService = Components.classes['@mozilla.org/network/io-service;1']
                                             .getService(Components.interfaces.nsIIOService);
          var uri = ioService.newURI(feedUrl, null, null);
          
          if (data.length) {
            var parser = Components.classes["@mozilla.org/feed-processor;1"]
                                            .createInstance(Components.interfaces.nsIFeedProcessor);
            var listener = new FeedTestResultListener();
            try {
              parser.listener = listener;
              parser.parseFromString(data, uri);
            }
            catch(e) {
              alert("Erreur de traitement du flux.");
            }
          }
        }
        
        httpRequest = new XMLHttpRequest();
        
        httpRequest.open("GET", feedUrl, true);
        try {
          httpRequest.onload = infoReceived;
          httpRequest.send(null);
        }
        catch(e) {
          alert(e);
        }
      }
    

    L'interface nsIFeedProcessor permet d'analyser les données du flux depuis plusieurs sources possibles ; dans ce cas, nous chargeons le document dans une chaîne, puis nous analysons celle-ci avec sa méthode parseFromString(). Vous pouvez également l'analyser depuis un fichier en utilisant parseFromStream(), ou directement depuis une URL avec parseAsync().

    La traitement à proprement parler du flux analysé est fait par la méthode handleResult() de l'objet FeedTestResultListener. Le code ressemble à cela :

        FeedTestResultListener.prototype = {
          handleResult: function(result) {
            var feed = result.doc;
            
            feed.QueryInterface(Components.interfaces.nsIFeed);
        
            // Ouvre une nouvelle fenêtre
        
            var win = window.open("", "FeedTest_Window");
            var doc = win.document;
        
            doc.open();
            
            // Écrit l'en-tête HTML et le titre de la page
            
            doc.write("<html><head><title>Flux : " + feed.title.text + "</title></head><body>");
            doc.write("<h1>" + feed.title.text + "</h1><p>");
              
            var itemArray = feed.items;
            var numItems = itemArray.length;
            
            // Écrit les informations sur l'article
            
            if (!numItems) {
              doc.write("<i>Pas de nouvelles, bonnes nouvelles !</i>");
            }
            else {
              var i;
              var theEntry;
              var theUrl;
              var info;
              
              for (i=0; i<numItems; i++) {
                theEntry = itemArray.queryElementAt(i, Components.interfaces.nsIFeedEntry);
                
                if (theEntry) {
                  theUrl = 
                  doc.write('<b><a href="' + theEntry.link.resolve("") + '">' + theEntry.title.text + '</a></b><br>');
                  if (theEntry.summary) {
                    info = theEntry.summary.text + "<p><hr><p>";
                  }
                  else {
                    info = theEntry.content.text + "<p><hr><p>";
                  }
                  doc.write("<blockquote>" + info);
                  doc.write("</blockquote><p>");
                }
              }
            }
            
            // Ferme le document ; c'est terminé !
            
            doc.write("</body></html>");
            doc.close();
          }
        }
    

    La fonction handleResult() reçoit comme argument un nsIFeedResult, qui décrit un flux ; sa propriété doc est un nsIFeed qui contient toutes les données du flux.

    Pour obtenir le titre du flux, cherchez la propriété feed.title. Le titre est de type nsIFeedTextConstruct qui peut présenter du texte dans différents formats ; on utilise sa propriété text pour extraire le titre du flux encodé en HTML. Nous pourrions également utiliser la méthode plainText() pour obtenir une copie du titre formatée en texte simple.

    On peut parcourir la liste des éléments du flux en utilisant feed.items de type nsIArray. Cette liste contient les objects nsIFeedEntry qui décrivent chaque élément du flux.

    On construit le document en récupérant les propriétés titre, lien, résumé et contenu de chaque élément. L'URL complète du lien est obtenue en utilisant la méthode resolve().

    Pour initialiser l'extraction du flux, on appelle la fonction fetch(url). Ceci ouvre une nouvelle fenêtre affichant le contenu du flux, où les titres de chaque élément sont des liens redirigeant vers les articles correspondants.

    Pour plus d'informations sur chaque interface d'accès au flux, consultez leurs pages de références respectives.

     

    Étiquettes et contributeurs liés au document

    Étiquettes : 
    Contributors to this page: Fredchat, VincentN, Mgjbot, Chbok, BenoitL, Jeremie
    Dernière mise à jour par : Jeremie,