CoreAbstraction

Aus GameBrowser - Wiki

Nach längerer Unterhaltung mit fkrauthan im IRC bezüglich Modularisierung des Clients (also der GameBrowser), hier jetzt mein Vorschlag auf Bitten von fkrauthan.

Die Oberfläche soll, soweit ich das verstanden habe, vom Core möglichst getrennt sein. Derzeit sind beide komponenten aber offenbar noch recht verwoben, so verwendet die GUI zB an manchen Stellen den ThreadPool um Download-Jobs zu starten. Das bedeutet, wenn eine eigene/neue GUI entwickelt werden soll, dann hängt man direkt an den mit u.A. boost entwickelten komponenten. Eine Aufgabentrennung ist auf diese weise auch recht schwer zu realisieren.

Für dieses Projekt würde es sich geradezu anbieten, wenn man die Komponenten Core und GUI nicht nur im quellcode trennt, sondern auch in den Binarys. Die Core-Komponente, welche sämtliche Logik enthält (Aktualisieren der Spieleliste, Datenverwaltung in der SQLite Datenbank, Download von spielen etc) sollte meiner Meinung nach am besten als DLL entwickelt werden, welche dann von der GUI geladen und angesprochen wird. Die DLL stellt einen Satz von Funktionen bereit, zB "refreshGameList(string category)" oder "downloadGame(int id)" uswusf. Ausserdem muss in einer separaten Header-Datei natürlich ein Satz von callbackfunktionen (Funktionspointer) deklariert sein.

Die GUI Komponente wäre dann sehr leichtgewichtig. Sämtliche Daten (also Namen der Kategorien, Spieledaten, etc) würden dann aus der Core-DLL kommen.

Die Schnittstelle sollte am besten mit C-Funktionen realisiert werden. Diese sind sehr portabel und können in vielen Sprachen aufgelöst werden. Wer dann eine Qt GUI Anwendung schreiben will, lädt einfach die DLL, löst die Funktionen auf und benutzt sie. Genauso könnte jemand anderes auch eine Konsolenanwendung in C programmieren und hätte trotzdem die gleiche Funktionalität. Oder in welcher anderen sprache man auch immer will. Vor allem wäre man nicht gezwungen, eine bestimmte bibliothek zu verwenden. Es gäbe eben nur die Core-DLL.

Ein weiterer Vorteil ist die bessere Möglichkeit des Aufteilens der Arbeit. Die Hauptarbeit wird wohl ohne Frage in der Core-Komponente liegen, die GUI zeigt im endeffekt nur die Daten der Core-Komponente an und gibt der Core-Komponente Anweisungen. Ein Entwickler kann sich dann um den Core kümmern, der andere um die GUI, und alles was sie wüssen müssen sind eine handvoll C-Funktionen und ein paar Structs.

Ach ja, der ganze Schmott hier kommt von MasterK :)

Kommunikation über XML Meta-Schnittstelle mittels C-Schnittstelle

XmlMetaSchnittstelle

Die Core-Komponente wird als DLL realisiert. Diese DLL wird von der GUI-Anwendung geladen und initialisiert. Dabei ist es unerheblich, ob die GUI mit C++, C, VB, Java etc entwickelt ist. Die GUI steuert nur mittels XML die Core-DLL. Dazu stellt werden folgende Funktionen und Funktionspointer deklariert:

//diese Funktion wird sowohl von Core-DLL als auch von der GUI-Anwendung implementiert
typedef int (*sendXmlData)(const char* data, int requestId);
 
sendXmlData ptrGuiXmlData = NULL;
//diese Funktion wird von der DLL implementiert und als C-Funktion exportiert
//@param sendXmlData Die Funktion über welche die Core-DLL Nachrichten an die GUI Anwendung sendet
int init([diverse parameter fürs init], sendXmlData)
{
    ptrGuiXmlData = sendXmlData;
    //do init stuff
}
 
//mit dieser Funktion in der DLL sendet die GUI Anweisungen an die Core-DLL
int sendXmlData(const char* data)
{
    mutex.lock
    //string kopieren
    mutex.unlock
 
    //Anweisung zurück an die GUI
    //optimalerweise aber natürlich aus einer anderen Funktion heraus ;)
    ptrGuiXmlData("<?xml .... ", irgendeineZahl);
}

Da es nur jeweils 1 bzw 2 (mit Init) Funktionen gibt, bleibt die Schnittstelle stabil solange das übergebene XML abwärtskompatibel bleibt. Wenn die GUI Anwendung nicht alle Funktionen der Core-DLL implementiert, macht das dann keine Probleme. Wichtig ist nur, dass sowohl auf GUI als auch auf Core-Seite die Übergabe des XML durch zB einen Thread abgesichert ist.

Beispiel "Abfrage aller installierten Spiele"

char* c = "<request name=\"getGameList\" param=\"installed\"/>"
//die GUI sendet die Anfrage an die Core-DLL und macht weiter womit auch immer
sendXmlData(c, 1);

Die Core-DLL fragt die Daten aus der Datenbank ab und baut eine entsprechende Liste auf:

<Games>
  <Game name="Tolles Spiel 7" autor="tggc">
    ...
  </Game>
  <Game name="Mein Spiel" autor="ich">
    ...
  </Game>
</Games>

Dieses XML wird an die Funktion sendXmlData der GUI-Anwendung (der Funktionspointer, welcher beim Start übergeben wurde) übergeben:

ptrGuiXmlData(xml, uebergebeneId);

Die GUI kann dann das XML auswerten und zB die Spieleliste anzeigen.