Da im Moment anscheinend wieder Änderungen am Last.FM-Webservice gemacht werden, die dazu geführt haben, dass LastSharp höchstens noch mithilfe der “Modifizierten Verbindung” (unter “Erweiterte Einstellungen” >> “Verschiedenes”) funktioniert, habe ich mir mal das Radio-API angesehen, das ja anscheinend die Zukunft des Radiostreamings bei Last.FM ist. Was mich daran allerdings stört, ist die umständliche Anmeldeprozedur: Token holen, Browser öffnen, auf Authentifizierung warten, Session holen.

Der Umweg über den Browser ist einfach unschön, weshalb ich nach einer Lösung gesucht habe, die den Login sowie die anschließende Bestätigung eines Users im Hintergrund simuliert, sodass er das eigentliche Programm nicht verlassen muss.

Funktionen, die Authentication-Token und -Session holen, werden im folgenden als gegeben betrachetet, z.B. durch LastFmLib.Net.

Wir brauchen nun also zwei Funktionen, die das Abschicken des Login-Formulars und das Klicken auf den “Zulassen”-Button vortäuschen. Beide Operationen produzieren eine HTTP-POST-Anfrage, funktionieren aber nur, wenn auch die richtigen Cookies vorhanden sind. (Das hat mich einige Zeit gekostet und dabei war die Lösung so einfach…) Es bietet sich an, die POST-Anfrage in eine Hilfsfunktion ExecutePOST zu packen, hier z.B. in C#:
(Namespace System.Net muss eingebunden sein)

// Löst das Cookie Problem: Immer denselben Container verwenden!
private static CookieContainer GlobalCookies = new CookieContainer();

// Sendet eine POST-Anfrage
public static void ExecutePOST(string uri, string data) {
    try
    {
        // Bereite die Anfrage vor
        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
        request.Method = "POST";
        request.CookieContainer = GlobalCookies; // !!
        request.ContentType = "application/x-www-form-urlencoded";
        request.ContentLength = data.Length;

        // Schreiben der Daten
        ASCIIEncoding enc = new ASCIIEncoding();
        byte[] bdata = enc.GetBytes(bodyData);
        Stream str = req.GetRequestStream();
        str.Write(bdata, 0, bdata.Length);
        str.Close();

        // Schicke Anfrage ab und verwirf die Antwort
        HttpWebResponse response = (HttpWebResponse)request.GetResponse();
        response.Close();
    }
    catch { }
}

Will man überprüfen, ob die gewünschte Operation erfolgreich war, würde es sich vermutlich anbieten, die Antwort auszuwerten, aber darauf verzichte ich jetzt aus Zeitgründen.

Nächster Schritt ist die Untersuchung der Formulare auf der Last.FM-Seite, damit man weiß, welche Daten an welche Adresse gesendet werden müssen:

• Login: https://www.last.fm/login/
  • refererKey (leer)
  • backto (“/”)
  • username (Benutzername)
  • password (Passwort)
• Zulassen: http://www.last.fm/api/grantAccess
  • api_key (Last.FM schickt den sogar zweimal, wir deshalb sicherheitshalber auch…)
  • token (Authentication-Token)
  • referer (“/”)

Also, die beiden verbleibenden Funktionen in C#:

    // Lasse ein Programm zu
    public static void GrantAccess(string token)
    {
        ExecutePOST(
            "http://www.last.fm/api/grantAccess",
            "api_key=" + apiKey + "&api_key=" + apiKey + "&token=" + token + "&referer=/"
        );
    }

    // Melde den User bei Last.FM an
    public static void Login(string username, string password)
    {
        ExecutePOST(
            "https://www.last.fm/login/",
            "refererKey=&backto=/&username=" + Uri.EscapeDataString(username) +
            "&password=" + Uri.EscapeDataString(password)
        );
    }

Um jetzt eine gesamte Anmeldung zu simulieren, müsste man nun folgendes machen:

public static void Authenticate(string username, string password)
{
    string token = GetToken(); // irgendeine externe Funktion
    Login(username, password);
    GrantAccess(token);
    string session = GetSession(); // irgendeine externe Funktion
    // Mache etwas...
}

Das war’s auch schon. Wie gesagt fehlt hier ein Test, ob die Anmeldung erfolgreich war, aber irgendwie lässt sich das bestimmt einfach überprüfen. (Vllt. liefert Last.FM ja im Hintergrund einen HTTP-Error, der im Browser nicht auffällt?)

Jedenfalls, wenn jemand die Authentifizierung für das Last.FM-API 2.0 im Hintergrund ablaufen lassen will, ist das hier der Weg. Ich hoffe, es hilft.

Die Verwendung des Radio-APIs in LastSharp werde ich übrigens so lang wie möglich hinauszögern, da hier wieder einmal diverse Standards (HTTP, XML, …) unsachgemäß ausgelegt werden…

Als Beispiel sei die UVD von LastSharp gegeben, die wir im folgenden Codebeispiel mithilfe einer XSL-Transformation (DescriptionPage.xsl) in eine HTML-Datei verwandeln. Das soll illustrieren, wie einfach die Verwendung von UVD sein kann, wenn entsprechende Bibliotheken vorhanden sind:

UVD lastsharp = UVD.Create("http://dev.xscheme.de/uvd/lastsharp.uvd.xml");
lastsharp.Save("c:/lastsharp.htm", "http://dev.xscheme.de/uvd/DescriptionPage.xsl");

Nun haben wir eine Datei “lastsharp.htm”, die hier eingesehen werden kann und Beschreibungen in verschiedenen Sprachen und Längen bietet, Downloadlinks, etc… Außerdem sind (wie man bei der Ansicht des Quelltextes feststellen kann) auch die META-Tags zu Schlüsselwörtern und Beschreibungen bereits gesetzt, sodass die Seite auch für Suchmaschinen verwendbar ist.

Das UVD-Objekt (s. Code) bietet noch weitere Möglichkeiten, aber ich möchte nun auf den Update-Mechanismus zu sprechen kommen, den man mithilfe von UVD implementieren kann. Eine UVD kann einen Verweis auf die vorhergehende Version, sowie Informationen zum inkrementellen Update (lösche Datei X, aktualisiere Datei Y, …) enthalten, sodass man durch Untersuchen der Versionsgeschichte jede Version auf den neuesten Stand bringen kann.

Wir verwenden die folgenden (sinnlosen) Dateien zur Demonstration: Version 1.2 >> Version 1.1 >> Version 1.0. Mithilfe der UVDs läuft ein Update von Version 1.0 auf 1.2 folgendermaßen ab:

1. Extrahiere aus der UVD zu Version 1.2 die URL zu Version 1.1!
2. Speichere die Update-Informationen in der UVD zu Version 1.1!
3. Führe nacheinander die Update-Schritte (1.0 >> 1.1) und (1.1 >> 1.2) aus!

Die Bibliothek, an der ich gerade arbeite, verwendet hierfür sog. Update-Profile, die festlegen, welche Sprache und welches Betriebssystem für das Update berücksichtigt werden soll. Code:

UVD version12 = UVD.Create("http://dev.xscheme.de/uvd/updatetest1.xml");
UVDVersion currentVs = new UVDVersion(1, 0); // aktuelle Version
UpdateProfile profile = new UpdateProfile(); // OS und Sprache egal
Update u = profile.CreateUpdate(currentVs, version12);
foreach(UpdateSegment s in u)
{
    Console.WriteLine(s.ToString());
}
u.Execute("c:/program/"); // Programmverzeichnis muss angegeben werden!

Das liefert folgende Ausgabe:

[Add: file3.txt] http://www.download.de
[Execute: file3.txt]
[Remove: file4.txt]
[Add: file1.txt] http://www.download.de
[Update: file2.txt] http://www.download.de
[Execute: file3.txt]

Anschließend werden genau diese Schritte ausgeführt. Bei der Erstellung des Updates wird im übrigen mehr oder weniger intelligent vorgegangen: wenn eine Datei in Version 1.2 gelöscht wird, wird sie in Version 1.1 gar nicht erst hinzugefügt. Und warum eine Datei hinzufügen, wenn sie irgendwann später überschrieben wird? Dieses Verhalten lässt sich über das Update-Profil festlegen. Wenn deaktiviert, lautet die Ausgabe:

[Add: file4.txt] http://www.download.de
[Add: file2.txt] http://www.download.de
[Add: file3.txt] http://www.download.de
[Execute: file3.txt]
[Remove: file4.txt]
[Add: file1.txt] http://www.download.de
[Update: file2.txt] http://www.download.de
[Execute: file3.txt]

Soviel dazu. Was jetzt noch wichtig ist, ist die Übertragung der Bibliothek auf andere Programmiersprachen. Deswegen suche ich Entwickler, die mit mir gemeinsam UVD auf Java, PHP, etc… portieren. Bei Interesse einfach eine E-Mail schreiben an Yannick_Scherer@gmx.net! Aber man sollte sich bewusst sein, dass das einiges an Arbeit bedeutet.

Mehr habe ich vorerst nicht vorzuweisen… Außer vielleicht das ultimative “einzeilige” Update (mit einer sinnvollen Datei funktioniert es dann auch…):

new UpdateProfile()
       .CreateUpdate(new UVDVersion(1, 0), UVD.Create("http://dev.xscheme.de/uvd/updatetest1.xml"))
       .Execute("c:/program/");

Um zu lernen, wie das geht, entwickeln wir hier (mit C#, aber eine Übertragung auf andere .NET-Sprachen dürfte jeder einigermaßen versierte Programmierer hinbekommen) ein Mini-Programm, das in einem Fenster zwei Eingabefelder für “Interpret” und “Titel” bereitstellt und das zugehörige Album findet. Ich gebe zu, keine bahnbrechende Idee, aber zur Demonstration reicht’s.

Zuallererst erstellen wir ein neues Projekt vom Typ “Windows Forms Anwendung” mit beliebigem Namen und erstellen einen Verweis auf Lapicon. Das geht folgendermaßen:

1. Rechtsklick auf “Veweise” im Projektmappen-Explorer, dann Klick auf “Verweis hinzufügen…”:
2. Unter “Durchsuchen” die Datei “Lapicon.exe” suchen und auswählen. Klick auf “OK”.

Jetzt kann die Programmentwicklung losgehen. Wir erstellen ein Fenster, das in etwa so aussieht:

Jetzt geht es an die Implementierung der Funktionen. Alle Lapicon-Funktionen werden durch das Objekt “LapiconProcessor” im Namespace “Lapicon” bereitgestellt. Da “LapiconProcessor” ein ziemlich langer Name ist und Programmierer von Haus aus faul sind, fügen wir folgendes Statement an den Anfang des Codes unseres Fensters (Rechtsklick auf das Fenster >> “Code anzeigen”) ein:

using L = Lapicon.LapiconProcessor;

Damit kürzen wir das Objekt “LapiconProcessor” als “L” ab und können ab sofort in unserem Code darauf zugreifen. Zuallererst ist unsere Anwendung ja auf das Last.FM-API ausgelegt, d.h. beim Laden der Anwendung würde es sich anbieten, Lapicon für dieses API zu konfigurieren. Hierfür verwenden wir das “Load”-Ereignis des Fensters, indem wir an irgendeine freie Stelle (im Fensterentwurf) doppelklicken. Anschließend ergänzen wir den so erstellten Code folgendermaßen:

private void AlbumFinderForm_Load(object sender, EventArgs e)
{
   // Lapicon: Initialisierung für Last.FM (entspricht L.Process("#lastfm"))
   L.LastFMInit(); 
}

Jetzt müssen wir noch festlegen, was passiert, wenn wir auf den Button klicken. Also erstellen wir mit einem Doppelklick darauf das “Click”-Event und verwenden die verschiedenen Lapicon-Funktionen, um eine Anfrage an Last.FM zu senden und das Ergebnis in einer MessageBox anzuzeigen. Die wichtigsten Lapicon-Funktionen sind:

• Process(“statement1″, “statement2″, …) führt die angegebenen Lapicon-Befehle nacheinander aus.
• Var(“var”) liefert den Wert einer Variablen.
• Var(“var”, “wert”) speichert “wert” in der Variable “var”.
• VarExists(“var”) liefert “true”, wenn eine Variable existiert.
• List(“var”) liefert eine Liste.
• ListCreate(“var”) erstellt eine Liste.
• List(“var”, “wert”) fügt “wert” zur Liste hinzu.
• ListExists(“var”) liefert “true”, wenn eine Liste existiert.

Mehr braucht man meistens nicht. Unser Click-Event wird demnach folgendermaßen aussehen:

private void btFindAlbum_Click(object sender, EventArgs e)
{
    // Interpret und Titel
    string artist = txtArtist.Text.Trim();
    string track = txtTrack.Text.Trim();

    // Wenn eins von beidem leer ist: nicht weitermachen
    if (artist == "" || track == "") return;

    // Ansonsten: Album (und richtig geschriebene Infos) holen
    L.Process(
        "[track.getInfo : track=" + track + "&artist=" + artist + "]",
        "store track/album/title in album",
        "store track/artist/name in artist",
        "store track/name in track"
    );

    // Ausgabe oder Fehler
    if (L.Var("album") == "")
    {
        MessageBox.Show(
            "Kein Album zu diesen Eingaben gefunden!",
            "Kein Album",
            MessageBoxButtons.OK,
            MessageBoxIcon.Exclamation);
    }
    else
    {
        MessageBox.Show(
            "Gefundene Informationen:\n\n" +
               "   " + L.Var("artist") + " - " + L.Var("track") + "\n" +
               "   Album: " + L.Var("album"),
            "Album gefunden!",
            MessageBoxButtons.OK,
            MessageBoxIcon.Information);
    }
}

Das war auch schon alles. Mit “Process” wird die Anfrage abgeschickt und die nötigen Daten gesichert, mit “Var” erfolgt die Verwendung der Daten. Und schon ist das Programm good to go:

Viel einfacher geht es wirklich nicht mehr. Ich hoffe, damit allen, die Interesse an Lapicon haben, ein Stück weiter geholfen zu haben.

Praktisch gesehen ist Lapicon eine einfache Möglichkeit, Webservices zu verwenden. Und geeignete gibt es (wie die Google-Suche nach “REST-API” schon bald zeigt) einige:

• Last.FM (http://www.last.fm/api)
• Flickr (http://www.flickr.com/services/api/)
• Twitter (http://apiwiki.twitter.com/Twitter-API-Documentation)
• Wuala (http://www.wuala.com/de/api)
• …

Aber wie geht man nun vor, wenn man Lapicon für irgendeines dieser APIs verwenden will? Diese Frage will ich in diesem Artikel beantworten, anhand zweier Beispiele: den Skripts DownloadAlbumAfterSearch.lpc und Lyrics.lpc aus dem Paket DarkSharpScripts, das ab Version 1.0.9 von Lapicon im Verzeichnis “packages” zu finden ist. Das erste Script sucht anhand einer Eingabe alle in Frage kommenden Alben und lässt den User eines auswählen, das anschließend komplett von Last.FM heruntergeladen wird (wenn möglich). Und das zweite findet mithilfe der LyricWiki (noch eine Seite, die REST-Anfragen unterstützt!) den Songtext zu einem vom User eingegebenen Musiktitel.

Schritt 0: Den einfachen Scriptstart ermöglichen

Damit man möglichst einfach Lapicon-Scripts starten kann, sollte man eine Datei mit der Endung “.lpc” anlegen und unter Windows darauf doppelklicken und anschließend über “Programm aus Liste auswählen” >> “Durchsuchen…” die Lapicon.exe als Standardprogramm festlegen. Dann lassen sich Scripts per Doppelklick starten.

Schritt 1: Grundeinstellungen

Zuallererst muss Lapicon mitgeteilt werden, wohin es Anfragen schicken soll, wie diese Anfragen aussehen sollen und wie es mit den Antworten umzugehen hat. Man stelle sich folgende Fragen:

1. Wie lautet die URL, an die die Anfragen gehen sollen? (Findet man meistens auf der API-Seite.)
2. Brauche ich irgendwelche Daten für die Anfrage, die immer vorhanden sein müssen? (Beispielsweise bei Last.FM: ein API-Schlüssel.)
3. Wie ist das Format der Anfrage-URL? “URL?Parameter” oder “URL/Parameter1/Parameter2″?
4. Wie sieht die Antwort aus? Welcher XML-Knoten ist die Wurzel? Sind irgendwelche Namespaces enthalten?
5. Werden mir Informationen bereitgestellt, ob Fehler aufgetreten sind, und wo finde ich sie?

Jetzt geht es ans Konfigurieren von Lapicon, hier am Beispiel Last.FM:

// s.o. Punkt 1: die Basis-URL
#base http://ws.audioscrobbler.com/2.0/

// s.o. Punkt 2: API-Key muss immer mitgesendet werden
#static api_key ce59c153ff5e3003c74df5b618aeccac

// s.o. Punkt 3: Die Anfrage hat das Format "URL?Parameter" (ansonsten: #noquery)
#query

// s.o. Punkt 4: Wurzel ist der "lfm"-Knoten; wir brauchen die Namespaces "xspf" und "lastfm"
#rootnode
#namespace xspf http://xspf.org/ns/0/
#namespace lastfm http://www.audioscrobbler.net/dtd/xspf-lastfm

// s.o. Punkt 5: wenn kein Fehler aufgetreten ist, steht im Attribut "status" des "lfm"-Knotens "ok"
#errornode lfm/@status
#noerrorvalue ok

Für “#rootnode” und “#errornode”, sowie später für Anfragen, wird Kenntnis von XPath benötigt. Es sei an dieser Stelle auf den Wikipedia-Artikel zum Thema verwiesen.

Da Last.FM als eines der Hauptanwendungsfelder für Lapicon gedacht war, lässt sich das oben geschriebene abkürzen:

#lastfm

Und schon ist Lapicon bereit dafür, zu arbeiten.

Schritt 2: Wie soll das Programm ablaufen?

Es ist immer wichtig, sich klarzumachen, was man jetzt eigentlich vorhat. Was also soll unser Script machen? Welche Daten brauchen wir dafür? Welche Anfragen müssen wir senden und welche Teile der Antworten verwenden?

Wir schreiben ein Script, das Alben sucht und anschließend komplett herunterlädt, also soll es folgende Schritte ausführen:

1. Eingabe des Suchstrings
2. Verwendung der Funktion album.search des Last.FM-APIs um eine Suche durchzuführen. Aus der Antwort lesen wir die Titel, Interpreten und IDs der einzelnen Alben aus.
3. Ausgabe einer nummerierten Liste mit Interpreten und Albumtitel
4. Eingabe der Nummer des gewünschten Albums
5. Verwendung der Funktion playlist.fetch, um an die Tracks des Albums zu kommen. (Mit zwei nicht dokumentierten Parametern.) Wir verwenden die URLs und die Titel der Tracks.
6. Erstellen des Ausgabeverzeichnisses nach dem Muster “Interpret/Album”
7. Schleife, die einen Track nach dem anderen herunterlädt.
8. Ende.

Schritt 3: Implementierung

Das Originalscript setzt zuerst die Last.FM-Einstellungen fest, dann lädt es die DarkSharpScripts-Konfigurationsdatei, die im selben Verzeichnis liegt:

// Use Last.FM
#lastfm

// Include
inc(<script directory>/Config.DarkSharpScripts.lpc)

Anschließend folgt die Eingabe des Suchstrings und eine Prüfung, ob auch wirklich etwas eingegeben wurde:

// Search
def query << Suchen
echo

[if <query> is not empty]

Die Zeile “def query << Suchen” bewirkt, dass der User eine Eingabezeile mit der Beschriftung “[in] Suchen:” vor sich hat. Drückt er die Enter-Taste wird alles eingegebene in der Variable “query” gespeichert. Um auf den Wert dieses Variable wiederum zuzugreifen, muss man sie in spitze Klammern setzen: “<query>”. Alles, was jetzt folgt, wird demnach nur ausgeführt, wenn der Wert von “query” nicht leer ist:

   [album.search : album=<query>&limit=<DS_SearchLimit>]*
   store* results/albummatches/album/name in albumTitles
   store* results/albummatches/album/artist in albumCreators
   store* results/albummatches/album/id in albumIDs

   // Choose
   f:displayAlbum n
      echo [<n>] <albumCreators[<n>]> - <albumTitles[<n>]>
   f:end
   forall* albumTitles index t: displayAlbum(<t>)
   echo

Das Konstrukt in eckigen Klammern ist die Anfrage an Last.FM. Vor dem Doppelpunkt steht die Funktion, die aufgerufen werden soll, dahinter ihre Argumente – in diesem Fall “album” und “limit” mit den Werten der Variablen “query” und “DS_SearchLimit” (letztere aus der Konfigurationsdatei; sie legt fest, wie viele Suchergebnisse maximal angezeigt werden). Die Sternchen signalisieren, dass nun nicht ein einzelner Wert gespeichert werden soll, sondern eine Reihe von Werten in einer Liste. “store* results/albummatches/album/name in albumTitles” beispielsweise speichert alle Werte, die über diesen XPath (“results/…”) zu erreichen sind, in der Liste “albumTitles”.

Was dann folgt, ist eine Funktion, die genau einen Wert (die Variable “n”) als Argument erhält. Sie gibt anhand der beiden Listen “albumTitles” und “albumCreators” das n-te Album (wobei n bei 0 beginnt) aus. Hier sieht man den Zugriff auf einzelne Listenelemente: <albumTitles[0]> wäre z.B. der Titel des ersten gefundenen Albums, falls vorhanden.

Diese Funktion wird nun für jedes Element der Liste “albumTitles” aufgerufen, immer mit dem aktuellen Index als Argument. (Neben der gezeigten Version der “forall*”-Schleife gibt es noch eine weitere, die nicht den Index, sondern den Wert als Variable liefert: “forall* list as element: …”)

Jetzt kann der User eingeben, welches Album er haben will, anschließend wird die Playlist mit den einzelnen Titel geladen:

   def nr << Nummer des Albums
   echo

   // Album Info
   def albumID = <albumIDs[<nr>]>
   def albumName = file(<albumTitles[<nr>]>)
   def albumCreator = file(<albumCreators[<nr>]>)

   // Playlist Info
   [playlist.fetch : playlistURL=lastfm://playlist/album/<albumID>&streaming=1&fod=1]*
   store* xspf:playlist/xspf:trackList/xspf:track/xspf:title in trackTitles
   store* xspf:playlist/xspf:trackList/xspf:track/xspf:location in trackLocation

Die Zeile “def albumName = file(…)” speichert in der Variable “albumName” einen bereinigten, für Dateinamen geeigneten String. Jetzt haben wir die URLs und Titel der Tracks, die wir herunterladen wollen. Und genau das macht der folgende Abschnitt – wieder nach dem Prinzip: “Lade die Datei mit dem Index “index” herunter!”

   [if <trackLocation length> != 0]

      // Directory
      def dir = <DS_AlbumsPath><albumCreator>/<albumName>
      mkdir <dir>

      // Download Function
      f:dl index
         def title = file(<trackTitles[<index>]>)
         def nindex
         nindex ::= <index>+1
         echo Downloading(<nindex>/<trackLocation length>) <albumCreator> - <title>...
         def fn = <dir>/<nindex> - <albumCreator> - <title>.mp3
         lpc(<script directory>/ResolveAndDownload.lpc) with <trackLocation[<index>]>|<fn>
         mp3Gain(<fn>)
      f:end

      // Download
      forall* trackTitles as t: dl(<trackTitles counter>)
      //
      wait

   [else]

      wait Album nicht herunterladbar

   [endif]

[else]

   wait Keine Sucheingabe

[endif]

Wir sehen einiges Neues hier: die Funktion “mkdir” erstellt ein Verzeichnis, die Zuweisung mit “::=” löst eine Berechnung aus (damit “nindex” um 1 größer ist als “index”) und dann das Konstrukt “lpc(…) with …”. Hier geschieht folgendes: Lapicon ruft das Script ResolveAndDownload.lpc auf, das im selben Verzeichnis liegt, und zwar mit den Kommandozeilenargumenten <trackLocation[<index>]> und <fn>. Dieses kleine Hilfsscript macht nichts anderes, als die übergebene URL (das erste Argument) mithilfe von HTTP aufzulösen und dann herunterzuladen. Das zweite Argument ist der Name der heruntergeladenen Datei. Es sollte sich also eigentlich von selbst erschließen:

// Data
def url = <cmd 1>
def file = <cmd 2>

// Resolve
def rurl

#error off
rurl = resolve <url>
#error on

[if <rurl> is not empty]

   down <rurl> >> <file>

[else]

   echo Resolving URL "<url>" failed...
   echo
   wait Taste drücken zum Beenden
   exit

[endif]

Die Funktion “mp3Gain”, die nach dem “lpc”-Statement kommt, ist in der Konfigurationsdatei definiert und ruft ein Hilfsprogramm auf, das wiederum mit der mp3Gain.exe,  die im selben Verzeichnis liegt, die Musikdatei normalisiert:

// MP3-Gain
f:mp3Gain file

   [if <file> is not empty]

      echo Normalisieren...
      shell: <script directory>/ExecuteMp3Gain.bat | "<file>"

   [endif]

f:end

Eine genaue Übersicht über alle von Lapicon unterstützen Funktionen findet sich in der Datei Lapicon.txt oder auf SourceForge: http://lastsharp.svn.sourceforge.net/viewvc/lastsharp/branches/Lapicon/Lapicon.txt?view=markup&pathrev=65

Beispiel 2: Lyrics.lpc

// -------------------------------------------------------------------
// DarkSharp.Lyrics
//   Downloads lyrics
//   Copyright (c) 2009 Yannick Scherer
// -------------------------------------------------------------------
// Lyricwiki
#base http://lyricwiki.org/api.php
#rootnode LyricsResult
#static func getSong
#static fmt xml

// Config
inc(<script directory>/Config.DarkSharpScripts.lpc)

// Input
def artist << Interpret
def track << Titel

// Get Lyrics from Lyricwiki
[artist=<artist>&song=<track>] store lyrics in lyrics

[if <lyrics> is not empty]
   // Clean
   artist = file(<artist>)
   track = file(<track>)
   // Save
   mkdir <DS_LyricsPath>
   echo crlf(<lyrics>) >>> <DS_LyricsPath><artist> - <track>.txt
[else]
   echo Keine Lyrics gefunden!
[endif]

echo
wait

Anmerkungen hierzu: man kann Anfragen auch in einer Zeile und/oder ohne Angabe der Funktion schreiben. Letzteres ist immer dann notwendig, wenn der Parameter, der die Funktion enthält, nicht “method” heißt.

Des weiteren sieht man eine Dateiausgabe: zuerst wird mit “artist = file(<artist>)” der Interpret und anschließend der Titel bereinigt, dann wird ein Verzeichnis erstellt und anschließend eine Ausgabe in eine Datei getätigt. Das Einschließen der Lyrics in “crlf(…)” bewirkt, dass Zeilenumbrüche richtig umgesetzt werden; das Verwenden von “>>>” statt “>>” zwingt Lapicon, eine evtl. vorhandene Datei zu überschreiben, anstatt an deren Ende etwas anzuhängen.

Das Nachvollziehen der Grundeinstellungen bleibt jedem selbst überlassen.

Ich hoffe, damit konnte ich ein wenig helfen, wenn es um die Arbeit mit Lapicon geht!

Das klingt jetzt extrem technisch, das gebe ich zu, aber im Prinzip ist es ganz einfach: das Last.FM-API beispielsweise kann über Adressen der Form

http://ws.audioscrobbler.com/2.0/?method=[Funktion]&api_key=[APIKey]&[sonstige Parameter]

aufgerufen werden. Daraufhin wird eine Antwort gesendet, die folgende Form hat:

<?xml version="1.0" encoding="utf-8" ?>
<lfm status="ok">
(...)
</lfm>

Will man diese Antworten nun auswerten, müsste man sie als Programmierer zuerst per Hand auseinandernehmen oder auf entsprechende Bibliotheken zurückgreifen. Hinzu kommt natürlich der Aufwand beim Erstellen der Anfrage, beim Fehler abfangen, etc… Meist hat man dann mehr Daten gesammelt, als man eigentlich benötigt, hatte einen Haufen Schreibaufwand und weiß, bei der nächsten Anfrage geht’s wieder von vorne los. Lapicon übernimmt das alles und ermöglicht so eine gezielte Abfrage und Ausgabe von Daten in drei Zeilen.

Ein Lapicon-Script, dass beispielsweise die Last.FM-ID eines Titels abruft, wäre das folgende:

#lastfm
[track.getInfo : artist=the+kooks&track=see+the+sun] store track/id in trackID
echo ID: <trackID>

Hierbei wäre der gewünschte Track im Code verankert. Genauso gut könnten wir auch den User entscheiden lassen, was er haben will:

#lastfm
read Interpret to artist
read Titel to track
[track.getInfo : artist=<artist>&track=<track>] store track/id in trackID
echo ID: <trackID>

So einfach kann es gehen. Eine genaue Beschreibung des gesamten Befehlssatzes findet man in der Lapicon.txt, die sich im Paket oder hier findet. Ich werde aber demnächst noch eine Kurzeinführung verfassen.

Außerdem habe ich ein paar Lapicon-Scripts geschrieben, die es ermöglichen einzelne Tracks bis hin zu ganzen Alben anonym von Last.FM herunterladen. Dieses Paket, DarkSharpScripts, wird ebenfalls demnächst zum Download bereit stehen. Ich warte damit allerdings noch bis zur Veröffentlichung von LeSharp, da dort das kleine Programm Pico (Path to ID3 Converter) enthalten ist, dass anhand eines Dateipfades ID3-Tags nachträgt. Somit die richtige Ergänzung für die Lapicon-MP3s, die ohne Tags daherkommen.

Ich würde mich freuen, wenn irgendwer Lapicon ausprobieren würde. Am einfachsten geht das übrigens, wenn man eine Datei mit der Endung “.lpc” erstellt, unter Windows darauf doppelklickt und den Lapicon-Interpreter als Standardanwendung auswählt. Dann kann man die Scripts ab sofort per Doppelklick starten.

Download (SourceForge): https://sourceforge.net/project/showfiles.php?group_id=255668&package_id=319513&release_id=677641

Hier ein Beispiel, dass die Top-Tags zu einem bestimmten Titel auflistet:

// LastFM verwenden
#lastfm

// Interpret und Titel vom User erfragen
def artist = read Interpret
def track = read Titel

// Absenden
[track.getInfo : artist=<artist>&track=<track>]* store track/toptags/tag/name in tags

// Ausgeben
forall* tags as tag: echo <tag>

// Fenster offen halten
def dummy = read Enter druecken...

Damit lassen sich Last.FM-API-Anfragen einfach und schnell versenden und die Antworten gezielt auswerten. Natürlich ist das alles noch nicht ausgereift, aber mit ein bisschen Arbeit wird da schon noch etwas draus. Wer allerdings jetzt schon damit herumspielen möchte, findet Lapicon hier:

Download Lapicon 1.0 (nicht aktuell, beim Download die beigefügten Beispiele beachten!)

Ich möchte an dieser Stelle mal meinen Zeitplan offenlegen:

• Reise nach Peru: 25.03.-15.04.
• LastSharp 0.4.1: um den 25. April
• “LessSharp” oder wie auch immer es heißen wird: Mitte Mai

Alles weitere sieht man dann schon…

UPDATE (23.03.2009): Beispiel auf aktuellen Stand des Programms angepasst.