Maemo/Hildon Softwareentwicklung

Nils Faerber
Mit einer leichten Verzögerung sind nun die ersten Nokia 770 Geräte im normalen Verkauf und so wird es Zeit zu untersuchen, wie man dafür Software entwickeln kann. Es stellt sich heraus, daß Nokia bei der Entwicklung nicht nur Wert auf die Software des Gerätes selbst gelegt hat, sondern auch auf einen abgerundeten Satz von Entwicklungswerkzeugen. Daher möchten wir an dieser Stelle die für die Entwicklung eigener Applikationen benötigten Werkzeuge vorstellen sowie zeigen, wie diese benutzt werden können.

Ausgangssituation

Die Maemo/Hildon Plattform [1] basiert auf einem recht normalen Linux System mit standard GLibC, auf dem aktuellen Nokia 770 basierend auf einem Linux 2.6.13 Kernel. Wer also jetzt schon Applikationen für Linux Workstations entwickelt, sollte keine großen Überraschungen befürchten müssen. Die grafische Oberfläche basiert auf X11 und verwendet GTK+ in der Version 2.6 als Toolkit. Zur verbesserten Benutzerinteraktion und zur Anpassung einiger GTK+ Widgets kommt noch eine weiteres darauf aufsetzendes Toolkit zum Einsatz, die "hildon-libs" sowie weitere plattformspezifische Funtkionen aus der "libosso". Einige wenige GTK+ Widgets werden durch spezialisierte "hildon" Funktionen ergänzt. Die Interaktion der Applikationen mit dem Desktop ist sehr an Gnome angelehnt, einige Funktionen verwenden bspw. intensiv GConv sowie DBus. Als Window Manager wird von GPE [2] her bekannte Matchbox [3] eingesetzt.

Bis hierher ist alles der Workstation recht ähnlich. Eine zentrale Schwierigkeit gilt es noch zu überwinden, nämlich die CPU. Auch wenn Maemo/Hildon eine allgemeine Softwareplattform ist, also unabhängig von der CPU, so ist die Zielplattform eindeutig ein embedded Gerät. Die meisten embedded Geräte verfügen jedoch nicht über eine Intel-x86 kompatible CPU. Mit anderen Worten, an irgendeinem Punkt muß die entwickelte Software für die Zielplattform speziell übersetzt werden, das Cross-Compiling. Nokia hat auch an dieses Problem gedacht.

Download Orgie

Alle Teile der Entwicklungsumgebung zusammen sind ein beträchtlicher Brocken, wir kommen später dazu, warum dies so ist. Zunächst hilft jedoch alles nichts, es müssen einige hundert Megabyte an Paketen beschafft werden. Am einfachsten geht die Installation auf einem Debian System. Das Maemo/Hildon System selbst setzt ebenfalls auf Debian auf, wodurch auch die Entwicklungsumgebung für Debian basierte Distributionen (Debian, Ubuntu, etc.) am besten getestet und integriert ist. Grundlage für alle Entwicklungen ist die Scratchbox[4]. Von Maemo wird zur Zeit lediglich die Version V0.9.8.5 unterstützt. Entsprechende Binär-Pakete im DEB und RPM Format sind auf der Donwloadseite von Scratchbox.org zu finden. Für andere Distributionen gibt es dort auch noch ein TAR Archiv mit den Binaries sowie den Sourcecode, denn Scratchbox ist ein OpenSource Tool. Insgesamt müssen zunächst ca. 200MB heruntergeladen werden:

An den Paketnamen ist bereits zu erkennen, daß die Scratchbox Umgebung ihre eigene Toolchain mitbringt und zwar für jede Zielplattform eine eigene, also eine für x86 PCs, eine für ARM, die CPU des Nokia 770. Ich würde an dieser Stelle dringend empfehlen die Paket-basierte Variante der Installation zu wählen, also via Debian oder RPM Paketen - dies erleichtert die Installation und spätere Updates erheblich und im Folgenden werde ich mich auf die Installation der Debian Pakete beziehen. Während der Installation der Scratchbox Pakete könnte auch schon das "Maemo Development Platform" Paket von [5] heruntergeladen werden - immerhin nochmals ca. 125MB. Die aktuellste Version ist derzeit das Release V1.0 vom April diesen Jahres. Für besonders Wagemutige gibt es noch einen V1.1 Release Candidate RC5.

Als erstes muß Scratchbox installiert werden. Während des Installationsprozesses werden automatisch Scratchbox User angelegt. Hierbei sollten alle User angegeben werden, die später mit Scratchbox arbeiten können sollen. Diese Benutzer werden dabei zum einen bei Scratchbox angemeldet aber auch zur neu erstellten Gruppe "sbox" hinzugefügt. Mit anderen Worten kann es zum ersten Start von Scratchbox auch nötig sein, den Benutzer neu anzumelden. Anschließend wird das "Maemo Development Platform" Paket benötigt. Das entsprechende Paket, bspw. Maemo_Dev_Platform_RS_v1.0_i386.tgz, muß nach /scratchbox/packages kopiert werden.

Einrichtung der Umgebung - oder was soll das alles?

Nun wird es richtig interessant und es soll sich auch bald aufklären, wofür dies alles benötigt wird. Als der entsprechende Benutzer muß nun die Scratchbox gestartet werden, mit dem Befehl "scratchbox". An dieser Stelle sollten zwei Umgebungsvariablen für die Shell innerhalb der Scratchbox gesetzt werden, am besten im ".bash_profile", also: 
[sbox-HOST: ~] > cat > .bash_profile
export LANGUAGE=en_GB
export PAGER=less
und mit CTRL-D "speichern".

Anschließend muß ein sogenanntes Target erstellt werden. Ein Target ist eine virtuelle Umgebung für eine bestimmte Zielplattform. Als erstes sollte dies eine Umgebung für den Entwicklungsrechner selbst sein: 

[sbox-HOST: ~] > sbox-config -ct SDK_PC
Der Name "SDK_PC" ist frei wählbar und könnte auch "x86", "PC-Dose" oder ähnlich lauten. Später wird noch ein zweites Target angelegt und die Namen dienen dann deren Unterscheidung und späterer Auswahl.

Scratchbox stellt anschließend für das neue Target drei Fragen. Zuerst nach dem in dieser Umgebung zu verwendenden Compiler. Zur Auswahl stehen die zuvor installierten Scratchbox-Toolchains. Die erste Umgebung soll für die Entwicklungsworkstation Code erzeugen, also muß die i686 Toolchain ausgewählt werden. Als zweites kann die CPU-Transparenz Methode ausgewählt werden. Dies erkläre ich bei der Erzeugung des zweiten Targets weiter unten. Hier soll nun zuerst "none", also keine, angegeben werden. Zuletzt wird nach dem zu verwendenden Devkit gefragt - installiert wurde das Debian Devkit und sollte auch als einziges zur Auswahl stehen und gewählt werden. Keine Fehlermeldungen? Perfekt! Dann kann nun das neue Target mit dem Scratchbox Befehl 

[sbox-HOST: ~] > sbox-config -st SDK_PC
ausgewählt und aktiviert werden! Zu diesem Zeitpunkt ist Scratchbox vergleichbar mit einem virtuellen PC auf den jetzt noch das System installiert werden muß. Dies erfolgt mit sogenannten "Rootstrap" Paketen, nämlich dem Maemo Development Platform Paket. Dies wird nun mit dem Scratchbox Befehl 
[sbox-SDK_PC: ~] sbox-config -er /scratchbox/packages/Maemo_Dev_Platform_RS_v1.0_i386.tgz
in die virtuelle Umgebung installiert. Abschließend folgen noch zwei Initialisierungskommandos für die Compiler- und Fakeroot-Umgebung: 
[sbox-SDK_PC: ~] sbox-config -cc
[sbox-SDK_PC: ~] sbox-config -cf
Zum Test der entwickelten Programme wird ein separater X-Server benötigt, der eine vereinfachte Maemo/Hildon Umgebung beherbergen wird. Am besten eignet sich hierfür Xephyr [6], da Xephyr im Gegensatz zu XNest auch einen virtuellen X-Server mit anderer Farbtiefen und anderen Erweiterungen als der Host X-Server zur Verfügung stellen kann. Da Xephyr in nur wenigen Distributionen vorhanden ist, befindet sich eine Version davon in den V1.1RC Maemo Rootstrap Images. Aktuelle Debian und Ubuntu Distributionen enthalten Xephyr als Teil der Xorg Distribution. Zum vereinfachten Start kann innerhalb der Scratchbox ein kleines Shell-Script erstellt werden: 
[sbox-SDK_PC: ~] cat > start-xephyr.sh
#!/bin/sh -e
prefix=/scratchbox/users/${LOGNAME}/targets/SDK_PC/usr
export LD_LIBRARY_PATH=${prefix}/lib; export LD_LIBRARY_PATH
exec ${prefix}/bin/Xephyr :2 -host-cursor -screen 800x480x16 -dpi 96 -ac
und wieder mit CTRL-D "speichern". Innerhalb Scratchbox ist auch "vi" als Editor verfügbar. 
[sbox-SDK_PC: ~] chmod u+x ./start-xephyr.sh
[sbox-SDK_PC: ~] ./start-xephyr
startet den virtuellen X-Server mit den nötigen Parametern. Auflösung und Farbtiefe entsprechen dem Nokia 770 Gerät. Und damit es endlich etwas bunt wird und man etwas zu sehen bekommt, so wird die Maemo Umgebung gestartet: 
[sbox-SDK_PC: ~] > export DISPLAY=:2
[sbox-SDK_PC: ~] > af-sb-init.sh start

Verwendung der Tools

Nun fragen Sie sich sicherlich, warum Sie gerade gut 500MB Ihrer Festplatte geopfert haben, um anschließend ein nur mäßig gefülltes Fenster angezeigt zu bekommen. Also, was Sie gerade installiert haben ist ein sehr cleveres Werkzeug zur Umgehung eines alten Problems, des Cross-Compiling. Applikationen "cross" zu entwickeln ist nicht neu. Die Gnu Compiler Tolchain unterstützt dies für viele Zielplattformen seit Jahren. Für einfache Applikationen ist dies in der Regel auch kein Problem. Allerdings stößt man mit dieser Methode schnell an Grenzen, wenn weitere Werkzeuge wie die Gnu Autotools eingesetzt werden. Viele Tools versuchen mit Hilfe der zu verwendenden Toolchain Testprogramme zu erzeugen und diese auszuführen, aus verschiedenen Gründen. Das Erzeugen funktioniert beim cross-Entwickeln meist noch, doch die Ausführung muß selbstverständlich fehlschlagen, da dann versucht wird, auf der Entwicklungsplattform Code der Zielplattform auszuführen.

Scratchbox bietet nun die Funktion der "CPU-Transparenz". Wird innerhalb der Scratchbox Umgebung Code für die Zielplattform ausgeführt, so wird dies automatisch erkannt und über den gewählten CPU Transparenz Mechanismus an eine Instanz weitergeleitet, die den Code dann tatsächlich ausführen kann. Für den Fall der Entwicklung für das Nokia 770 ist die Ziel-Plattform ARM und für diese stehen zwei Transparenz Varianten zur Verfügung, entweder der Software-Emulator QEmu oder "sbrsh", eine auf einer Variante der SSH basierende Ausführung des Codes auf einem separaten Gerät, wie dem wirklichen Nokia 770. Alle anderen Programme verwenden zunächst ganz normal die lokale x86 CPU.

Scratchbox hat aber noch einen weiteren entscheidenden Vorteil. Durch die Installation eines virtuellen Systems durch das Rootstrap Paket beinhaltet die Entwicklungsumgebung automatisch alle für die Entwicklung notwendigen Programme und Bibliotheken in genau der Version, die für die Entwicklung notwendig ist. Die Entwicklungsumgebung ist so von dem Host-System der Workstation vollkommen unabhängig. Außerdem kann so in der virtuellen Umgebung von Scratchbox und nested X-Server (Xephyr) eine vom Host-System unabhängige grafische Oberfläche gestartet werden - vergleichbar mit dem Start eines vollständigen KDE Desktops in einer virtuellen Umgebung eines Gnome Desktops.

Ein Beispiel

Als Applikationsbeispiel wird eine einfache Notizblockapplikation verwendet [7]. Innerhalb der Scratchbox ist auch wget verfügbar und ist so die bequemste Methode, das Source-Archiv herunterzuladen. Haben Sie das Archiv bereits heruntergeladen, können Sie es auch direkt in die Scratchboxumgebung kopieren; dann ist der Pfad nur etwas länger 
# cp maemopad_1.1.tar.gz /scratchbox/users//home//
wobei durch Ihren verwendeten Benutzernamen ersetzt werden muß.

Das Source-Archiv der Beispielapplikation ist ein ganz normales TAR Archiv und kann normal ausgepackt werden. In dem angelegten Verzeichnis finden sich anschließend neben anderen Dateien auch das Shell-Skript "autogen.sh" zur Erzeugung der Gnu Autotools Skripte. Der berühmt berüchtigte open source Dreisprung sollte uns also fast zum Erfolg führen, also "./autgen.sh", "./configure" und "make". Beim Configure beobachten wir zunächst kurz: 

...
checking build system type... i686-pc-linux-gnu
checking host system type... i686-pc-linux-gnu
...
Configure hat unser System korrekt als einen x86 Linux PC erkannt. Dies ist jetzt nicht weiter bemerkenswert, wird sich aber später ändern! Nach dem finalen "make" sollte sich nun in "src/" ein Binary "maemopad" befinden. Um dieses in der Maemo Umgebung zu testen, kann es nicht einfach gestartet werden. Nokia hat in die Oberfläche einige Sicherungsmechanismen eingebaut. Einer davon ist, daß Applikationen sich nach erfolgreichem Start bei der Oberfläche registrieren müssen und damit verkünden, daß ihr Start erfolgreich war. Erfolgt dies nicht, werden sie von einer Überwachungsinstanz zwangs-beendet. Da die vollständige Registrierung aber die Installation einiger Dateien aus dem "data/" Verzeichnis benötigt und dies für einen kleinen schnellen Test zu aufwendig ist, gibt es einen Behelfstrick, das Skript "run-standalone.sh". Mit dem Befehl 
[sbox-SDK_PC: ~/maemopad/src] > run-standalone.sh ./maemopad
kann das Programm zu Testzwecken auch einzeln gestartet werden. Und siehe da, so könnte es aussehen

Päckchen packen

Zuguterletzt noch zwei wichtige und interessante Schritte des Maemo Entwicklungszyklus. Angenommen das Projekt ist hinreichend getestet und man möchte das ganze in ein installationsfähiges Paket umwandeln. Für das verwendete Maemopad Beispiel ist alles richtig konfiguriert und dies daher einfach zu erledigen: 
[sbox-SDK_PC: ~/maemopad] > dpkg-buildpackage -rfakeroot -b
baut automatisch das vollständige installierbare Debian Paket. Dies befindet sich anschließend im übergeordneten Verzeichnis als "maemopad_1.1_i386.deb".

Cross Build

Dazu wird nun ein zweites Target angelegt, und zwar eines für die Zielplattform, im Fall des Nokia 770, für ARM. Dieser Schritt ist natürlich nur einmal notwendig! Später kann dieses Target einfach nur noch ausgewählt und muß nicht neu angelegt werden.

Zunächst wird wieder das passende Maemo Development Platform Paket benötigt, diesmal die ARM Version (s.o.), also bspw. "Maemo_Dev_Platform_RS_v1.0_arm.tgz". Dieses nach dem Herunterladen wieder nach /scratchbox/packages/ kopieren und dann entsprechend wie zuvor ein Target damit erzeugen: 

[sbox-SDK_ARM: ~] > sbox-config -ct SDK_ARM
Als Compiler nun den ARM Compiler auswählen, als CPU Transparenz Methode "qemu-arm" und als Devkit "debian"! Anschließend das neue Target auswählen 
[sbox-SDK_ARM: ~] > sbox-config -st SDK_ARM
[sbox-SDK_ARM: ~] > sbox-config -cf
Und das ARM Rootstrap Paket installieren: 
[sbox-SDK_ARM: ~] > sbox-config -er /scratchbox/packages/Maemo_Dev_Platform_RS_v1.1rc5_arm.tgz
Jetzt kommt der wirklich spannende Teil: 
[sbox-SDK_ARM: ~/maemopad] > ./configure
...
checking build system type... arm-unknown-linux-gnu
checking host system type... arm-unknown-linux-gnu
...
Autoconf hat die virtuelle ARM-Umgebung erkannt! Es geht sogar davon aus, daß "native" auf ARM für ARM compiliert wird, also keine cross-Compilierung vorgenommen wird! Ermöglicht wird dies durch Scratchbox und die CPU-Transparenz. Doch nur "configure" wird dadurch etwas hinters Licht geführt, alle in der Umgebung laufenden Programm sind weiterhin x86 Programme, laufen also bei normaler CPU Geschwindigkeit ohne Emulation. Nach einem "make" liefert "file" als Dateiinhalt folgende Ausgabe: 
[sbox-SDK_ARM: ~/maemopad] > file src/maemopad
maemopad: ELF 32-bit LSB executable, ARM, version 1 (ARM), for GNU/Linux 2.0.0, dynamically linked (uses shared libs), not stripped
Genau wie für x86 kann jetzt auch ein ARM Debian Paket für das Zielsystem erzeugt werden: 
[sbox-SDK_ARM: ~/maemopad] > dpkg-buildpackage -rfakeroot -b
Anschließend findet sich wieder im übergeordneten Verzeichnis das erstellte Debian Paket "maemopad_1.1_arm.deb".

Fazit

Mit der Maemo Development Platform und den durch Nokia geförderten Open Source Werkzeugen wie Scratchbox und QEmu hat Nokia die Open-Source Gemeinde in Punkto embedded-cross-Entwicklung um einige Meilen voran gebracht! Dinge die vorher praktisch nur auf esoterischen Maschinen direkt zu bauen waren, man denke an GTK+, lassen sich innerhalb der Scratchbox Umgebung performant und komfortabel bauen. Auch ist die pseudo-Umegung innerhalb des virtuellen X-Servers Xephyr ein extrem gutes Test-Werkzeug bei der Applikationsentwicklung für Maemo/Hildon. Einzig der recht hohe Plattenspeicherplatzbedarf ist etwas kritikwürdig; andererseits aber auch nachvollziehbar - was soll's, in Zeiten in denen 200GB unter 100EUR kosten ;)

Referenzen

  1. Maemo Platform http://www.maemo.org
  2. GPE Homepage http://gpe.linuxtogo.org
  3. Matchbox, X11 Window Manager für embedded Geräte http://projects.o-hand.com/matchbox/
  4. Scratchbox V0.9.8 Download http://www.scratchbox.org/download/scratchbox-0.9.8/
  5. Maemo Development Platform (SDK) Download http://www.maemo.org/downloads/download-sdk.html
  6. Xeyphyr - Next Generation XNest http://www.freedesktop.org/Software/Xephyr
  7. Maemopad Beispielapplikation http://repository.maemo.org/stable/1.0/applications/maemopad/
  8. Maemo SDK Tutorial http://www.maemo.org/platform/docs/tutorials/Maemo_tutorial.html
Dieser Artikel ist © 2006 by Nils Faerber, Siegen.