Podzieh Teil 1: Einlesen eines RSS-Feeds für Podcasts

So nun wird es ernst. Willkommen zum ersten Teil des Entwicklungstagebuches für meinen Podcatcher “Podzieh”. Die Anforderungen an das Programm habe ich im letzten Post bereits aufgeführt. Ich werde hier, in hoffentlich regelmäßigen Abständen, über aktuelle Punkte der Implementierung des Programmes schreiben. Und ich würde sagen, beginnen wir mal mit dem wichtigsten Punkt für einen Podcatcher, das Abrufen und Einlesen des RSS-Feeds.

Beispiele für RSS-Feeds habe ich im Post “Podcasts für Entwickler und für nebenbei” genügend geliefert, diese Feeds dienen mir als Referenz für mein Programm. Ich hoffe damit decke ich den Großteil der Möglichkeiten ab. In meinem Programm lege ich mich auf RSS-Feeds der Version 2.0 fest, da alle Feeds die ich bisher gefunden haben auch diese Version hatten. Einen guten Einstieg in den Aufbau eines RSS bietet w3schools.com/rss. Beim RSS Format handelt es sich im Grunde genommen nur um ein genau definiertes XML-Schema. Leider reicht manchen diese Vordefinierte Struktur nicht aus, und so kommen dann Erweiterungen, wie zum Beispiel die für iTunes, dazu. Da es sich einfach nur um XML handelt, kann ich solch einen Feed mit den XML Klassen des dotNet Frameworks einlesen. Um die Erweiterungen zu Nutzen muss ich allerdings beim Analysieren des XML auf die Xml-Namespaces achten. Achja noch kurz zu Anmerkung, das Programm wird mit dem dotNet Framework 4 Client Profile entwickelt.

Zur Verarbeitung des RSS-Feeds müssen nur zwei Klassen angelegt werden. Eine für den “Channel”, dieser Beschreibt den Podcast im allgemeinen, und eine Klasse für das “Item”. Das Item stellt eine Episode im Podcast dar und kommt somit mehrfach als Kindelement des Channel vor. Damit keine fehlerhaften Objekte zustande kommen können, kann eine Instanz der Klassen nur über eine Factory-Methode erstellt werden. So kann ich zum Beispiel beeinflussen, was passiert wenn es sich nicht um einen RSS-Feed mit Version 2.0 handelt. Eingelesen wird das XML mit LINQ und der XDocument Klasse. Eine wirklich schöne Hilfe beim einlesen des XML ist die automatische Konvertierung des Inhaltes eines XElement bzw. XAttribute. Man muss nur den entsprechenden cast davor schreiben. Wenn man das ganz dann auch noch mit Nullable-Typen verbindet kann man sich etliche if Abfragen sparen.

public class Channel
{
    #region Namespaces

    public static XNamespace NsItunes = XNamespace.Get("http://www.itunes.com/dtds/podcast-1.0.dtd");
    public static XNamespace NsMedia = XNamespace.Get("http://search.yahoo.com/mrss/");

    #endregion

    #region Properties

    public string Title { get; protected set; }
    public string Description { get; protected set; }
    public string URL { get; protected set; }
    public IEnumerable<Item> Items { get; protected set; }

    public string LocalFolder { get; set; }

    #endregion

    #region Init

    protected Channel() { }

    public static Channel LoadFromFeed(string url)
    {
        XDocument doc = XDocument.Load(url);
        if(doc == null) return null;
        XElement rss = doc.Element("rss");
        if (rss == null || (string)rss.Attribute("version") != "2.0")
            return null;

        XElement channel = rss.Element("channel");
        if (channel == null) return null;

        Channel c = new Channel()
        {
            URL = url,
            Title = (string)channel.Element("title"),
            Description = (string)channel.Element("description")
        };

        c.Items = channel.Elements("item")
                            .Select(i => Item.LoadFromXml(i))
                            .Where(i => !String.IsNullOrEmpty(i.Download) && !String.IsNullOrEmpty(i.Title));

        return c;
    }

    #endregion
}

Die Liste mit den Items erstelle ich mit Hilfe der LINQ Extension Methoden. Mit “Elements()” geh ich alle Items durch. Auf diese Enumeration wird ein “Select” angewedet, welches aus den XML-Items eine Item-Instanz meiner Klasse macht. Im Anschluss daran, Filter ich gleich die mit raus, bei denen ich keinen Download gefunden habe.

public class Item
{
    #region Properties

    public string Title { get; protected set; }
    public string Description { get; protected set; }
    public string Guid { get; protected set; }
    public string Author { get; protected set; }
    public string Download { get; protected set; }
    public long? DownloadSize { get; protected set; }

    public DateTime? PubDate { get; protected set; }

    public string LocalFile { get; set; }

    #endregion

    #region Init

    protected Item() { }

    public static Item LoadFromXml(XElement el)
    {
        Item i = new Item()
        {
            Title = (string)el.Element("title"),
            Description = (string)el.Element("description"),
            Guid = (string)el.Element("guid"),
            Author = (string)el.Element("author")
        };

        if (String.IsNullOrEmpty(i.Guid))
            i.Guid = (string)el.Element("link");

        if(el.Element("pubDate") != null)
            i.PubDate = (DateTime?)el.Element("pubDate");

        if (i.Description == String.Empty)
        {   // wenn in description nichts drin steht, ist vieleicht im itunes-tag summary was drin
            i.Description = (string)el.Element(Channel.NsItunes + "summary");
        }

        if (el.Element("enclosure") != null)
        {
            i.Download = (string)el.Element("enclosure").Attribute("url");
            i.DownloadSize = (long?)el.Element("enclosure").Attribute("length");
            if (i.DownloadSize.HasValue && i.DownloadSize.Value == 0)
                i.DownloadSize = null;
        }

        if(String.IsNullOrEmpty(i.Download) || !i.DownloadSize.HasValue)
        {   // wenn in enclosure nichts steht, steht das vieleicht in einem media:content-tag
            XElement elMedia = el.Element(Channel.NsMedia + "content");
            if (elMedia != null && elMedia.Attribute("url") != null)
            {
                i.Download = (string)elMedia.Attribute("url");
                i.DownloadSize = (long?)elMedia.Attribute("fileSize");
                if (i.DownloadSize.HasValue && i.DownloadSize.Value == 0)
                    i.DownloadSize = null;
            }
        }

        return i;
    }

    #endregion
}

Wenn ich beim Einlesen eines Items keinen Download finde, versuche ich es mit dem Element media:content. Hier steht im Grunde das gleiche drin wie im enclosure-Element. Die Guid wird verwendet um die Episode eindeutig zu Identifizieren und später mit einer Datenbank abzugleichen. Die Properties “LocalFolder” und “LocalFile” habe ich angelegt um hier nach dem einlesen des Feeds, den Pfad zur lokalen Instanz einzutragen. Mehr dazu in einem späteren Post.

Mein eigener Podcatcher: Podzieh

Wie im letzten Post schon angedeutet suche ich zur Zeit nach einem guten Tool zur Verwaltung meiner Podcast-Downloads und –Feeds. Alle Programme die ich bis jetzt getestet habe, sind mir einfach zu überfrachtet oder zu Kompliziert. Aus diesem Grund habe ich mich dazu entschlossen ein eigenes kleines Programm dafür zu entwickeln. Schließlich bin ich nicht umsonst Softwareentwickler geworden .

 

Im allgemeinen wird die Gruppe von solchen Programmen als Podcatcher bezeichnet. Solch einem Programm wird Üblicherweise der RSS Feed eines Podcasts übergeben und es zeigt dann die verfügbaren Downloads an und lädt sie bei Bedarf herunter. Genau aus diesem Verhalten habe ich den Namen für mein kleines Programm abgeleitet. Ich wollte es zwar erst “Podzblitz” nennen, dass war mir dann aber doch zu abgedroschen und nicht beschreibend genug. Darum soll es jetzt “Podzieh” heißen, sowie PODcast und aus dem Netz ZIEHen.

 

So und um auch gleich einen Einstieg zu haben, beginnen wir doch mal mit der Anforderungsanalyse. Was soll das Programm denn können? Für mich am wichtigsten sind eigentlich folgende Punkte:

• Verwaltung von Podcast-Feeds, das Umfasst folgende Kriterien
  • Eingabe von RSS URLs
  • Abrufen des RSS Feeds
  • Überprüfen auf neue Einträge
• Herunterladen von Podcast-Folgen
  • Eine oder mehrere Folgen auswählbar zum herunterladen
  • Download im Hintergrund
  • Fortschrittsanzeige
  • Speicherung in einer eigenen Ordnerstruktur, zum Beispiel jeder Feed in einem eigenen Ordner
  • ggf. fortsetzen von Downloads
• Markieren der Folgen
  • als gehört Kennzeichnen
  • Bewerten
  • ggf. automatisches löschen, wenn Platz gespart werden soll
• Abspielen
  • ggf. auch schon abspielen, wenn sie noch nicht fertig heruntergeladen wurde!
• Konvertieren ins AAC Format
  • zur Platzsparenden Archivierung oder um den Speicherplatz des Smartphone zu schonen
  • natürlich auch im Hintergrund
  • frei Konfigurierbar
  • vorgegebene (empfohlene) Profile
• Übertagen auf ein (Android-)Smartphone per WLAN

So das sind jetzt erst mal alle Punkte die mir Einfallen. Sicher gäbe es auch noch ein paar Features mehr die man in so ein Programm stecken könnte, aber man sollte es auch nicht übertreiben. Denn jetzt kommen ja noch die Nicht-Funktionalen Anforderungen, die die ganze Sache erst richtig interessant machen.

• Natürlich soll das Programm eine optisch ansprechende Oberfläche haben
• es soll möglichst Idiotensicher sein; der Nutzer soll so viel wie möglich mit dem Programm machen können und so wenig wie nötig dafür tun müssen
• Beachtung des CleanCodeDeveloper Wertesystems bei der Entwicklung
• und das Ganze soll Open-Source sein

So das ist jetzt erst mal ein ganz schöner Brocken Arbeit der da vor mir liegt. Ich hoffe ich kann alle Punkte so umsetzen wie ich mir das vorstelle. Ich werde versuchen bei der Entwicklung immer hier auf dem Blog zu schreiben und auf jeden Funktionspunkt näher einzugehen. Wenn Ihr noch weitere Ideen habt, was unbedingt in so ein Programm gehört, könnt Ihr mir gern einen Kommentar da lassen, bzw. könnt Ihr auch einfach schreiben was Ihr von der Idee haltet.

Podcasts für Entwickler und für nebenbei

Wenn man mal wieder den Abwasch machen muss, etwas im Garten arbeitet oder einfach nur mit der Bahn fährt, mit einem Podcast in den Ohren geht das Alles viel leichter. Wenn ich mal gerade nicht am Entwickeln und Programmieren bin, tu ich durch das Podcast hören etwas um mich weiterzubilden und um mich zu informieren. Wenn ich ganz ehrlich bin, ist es aber vor allem als Unterhaltung gedacht. Da ich mein Handy/Smartphone immer dabei habe, lade ich mir dort regelmäßig die neuesten Episoden von verschiedenen Podcasts drauf.

Zum Podcast hören gekommen bin ich erst vor kurzem. Irgend wie ist die ganze Podcast-Mania vor ein paar Jahren ganz an mir vorbeigezogen, ohne das ich dem etwas abgewinnen konnte. Gepackt hat mich das Podcast-Fieber erst mit den wirklich gut und professionell gemachten Podcasts von gameone.de. Da ich die meisten der Redakteure schon seit Giga-Zeiten aus dem Fernsehen kenne, ist das hören der Episoden ganz angenehm.  Vor allem treffen aber die Retro und Kopfkino Podcasts genau ins Schwarze bei mir. In den Retro-Podcasts geht es vor allem um Spiele aus der guten alten Zeit, also genau da wo ich auch gespielt habe (SNES und Co.). Und in den Kopfkino-Podcasts werden Filme bzw. Filmreihen besprochen. Absolutes Highlight war hier natürlich der Livecast zur Oscar-Verleihung 2011. Da mein Sohn natürlich genau in dieser Nacht um 2 Uhr aufgewacht ist und nicht mehr schlafen wollte, habe ich mir tatsächlich die Oscar-Verleihung Live im Fernsehen angesehen. Ohne den Livecast und die Kommentare der gameone Redakteure hätte ich diese langweilige Verleihung wohl nicht durchgestanden.

Aber das war nur der erste von zwei Podcasts die mich zu einem Fan dieses Mediums haben werde lassen. Der gameone Podcast ist natürlich nur etwas zur Unterhaltung. Richtig die Augen oder besser gesagt Ohren geöffnet hat mir dann der SoftwareArchitekTOUR-Podcast von heise.de/developer. Hier geht es um mein Lieblingsthema, die Softwareentwicklung. Naja eigentlich nicht ganz um die Softwareentwicklung, sondern wie der Name schon sagt um Softwarearchitektur. Besprochen werden Vorgehensmodelle, Designschwerpunkte, Pattern und aktuelle Entwicklungen wie NoSQL und Cloud Computing.

So genug geredet, es wird Zeit sich etwas anzuhören. Hier nun meine Liste mit Podcasts die ich regelmäßig höre, bzw. auf die ich gerade erst aufmerksam geworden bin.

• gameone.de Plauschangriff  | website | feed
• SoftwareArchitekTOUR-Podcast | website | feed
• pentacast (Podcast des c3d2) | website | feed
• Technikwürze Podcast | website | feed
• Working Draft Podcast | website | feed
• Spieleveteranen | website | feed

Und hier noch ein paar interessante  Englische Podcasts:

• Experimental Game Dev Podcast Show | website | feed
• hanselminutes | website | feed
• This Developers Life | website | feed

Natürlich gibt es noch wesentlich mehr englischsprachige Podcasts, es macht nur keinen Sinn die hier alle aufzuzählen.

Da es mit der Zeit ganz schön unübersichtlich wird mit so vielen unterschiedlichen Podcasts und dem ganzen Runtergelade und Angehöre, bin ich zur Zeit noch auf der Suche nach einer guten Software, die das Alles etwas Unterstützt. Ich hab zwar auch schon ein paar Programme ausprobiert, aber so richtig glücklich geworden, bin ich mit keinem. Über Empfehlungen würde ich mich hier freuen. Aber anscheinend muss ich da wohl selber mal ran und mir genau das Programmieren was ich brauch!