LTR Artikel

From jalimo (inactive) Wiki
Jump to: navigation, search

Contents

jalimo - Java unter mobile Linux

von Christian Küster, Sebastian Mancke & Robert Schuster

Java ist die am weitesten verbreitete Programmiersprache für mobile Anwendungen. Auf mobilen Linux Plattformen war es jedoch lange Zeit nur schwer möglich überhaupt Java Anwendungen ein zu setzen. Um dies zu verbessern ist vor zwei Jahren das jalimo Projekt entstanden. Es beschäftigt sich mit der einfachen Bereitstellung von Java-Laufzeitumgebungen für mobile und eingebettete Linux Systeme und macht die Verwendung von Java im Linux mobile Einsatz genau so einfach wie auf dem Desktop und Server. Dabei ist jalimo keine neue JVM oder Java Klassenbibliothek sondern eine Integration und Anpassung vorhandener Projekte und Implementierungen.

Java eignet sich aus verschiedenen Gründen besonders gut für den mobile & embedded Einsatz. Der wesentliche Vorteil ist der, dass die Einarbeitungszeit in die Programmierung mobiler Anwendungen für Desktop-Entwickler sehr gering sind. Damit erschließt es den mobilen Plattformen einen großen Kreis von OpenSource-Anwendugsentwicklern.

Java != Java

Der Java-Standard stellt für unterschiedliche Einsatzszenarien verschiedene Editionen, Konfigurationen und Profile bereit. Dabei durch zu blicken ist nicht immer ganz leicht. Im wesentlichen interessieren uns hier jedoch die folgenden: Die Java Standard Edition (Java SE) ist das was normalerweise mit dem Begriff Java assoziiert wird und auf dem Desktop zum Einsatz kommt. Aktuell ist derzeit die Version 6. Die letzten Sprachänderungen gab es in der Vesion 5. Weiterhin gibt es die Micro Edition (Jave ME), die wiederum in zwei Teile aufgeteilt ist. Die J2ME Connected Device Configuration (CDC) entspricht in etwas der Standard Edition in einem Versionsstand von Java 1.2. Die J2ME Connected Limited Device Configuration (CLDC) ist das, was wir als Java auf Mobiltelefonen kennen. Unter J2ME CLDC wird nur eine Teil des Sprachstandards unterstützt außerdem unterscheiden sich die APIs von den größeren Brüdern anstatt sich auf ein Subset davon zur begrenzen.

Jalimo konzentriert sich auf die Bereitstellung von Laufzeitumgebungen, die denen der Desktops möglich nahe kommen und ist daher auf Java SE ausgerichtet. Wo dies mit vertretbarem Aufwand möglich ist werden jedoch auch andere Laufzeitumgebungen unterstützt. --sm Anmerkung: Wenn der obige Absatz in einen Kasten verschoben wird, muss der letzte Satz (jalimo -> Java SE) dennoch im Haupttext enthalten sein!

Unterstützte Plattformen

Jalimo ist als breites Projekt angelegt, das heißt es unterstützt eine Vielzahl von Plattformen und Java Implementierungen. Am Besten unterstützt sind derzeit Maemo (http://maemo.org/) und OpenMoko (http://openmoko.org). Maemo ist die von Nokia geförderte Plattform, die derzeit auf den Nokia Internet Tablets zum Einsatz kommt. OpenMoko ist die Smartphone Distribution die auf dem Neo FreeRunner der OpenMoko Inc. verwendet wird. Für diese Beiden Distributionen existieren binär-Pakete auf der jalimo Projekt-Seite (http://jalimo.org). Des weiteren wurden die jalimo Pakete auch direkt in das OpenMoko-Projekt aufgenommen und stehen dort ohne weiteren Aufwand zur Verfügung. Eine besondere Ziel-Plattform sind des weiteren die Bugs von BugLabs (http://www.buglabs.net/). Hierbei handelt es sich um ein Baukastensystem mit dem sich individuelle mobile Ideen abbilden lassen. Die Plattform basiert komplett auf Java und die Mitarbeiter von BugLabs beteiligen sich aktiv am jalimo-Projekt. BugLabs bietet eine direkte Unterstützung der entsprechenden Pakete in ihrer Distribution.

Die Unterstützung der Plattformen wird durch die Integration in OpenEmbedded erreicht. Dies bringt eine enorme Flexibilität, so dass auf einfache Weise weitere Plattformen hinzu genommen werden können. Beispiele hierfür sind der eReader Iliad der Firma IRex (http://www.irextechnologies.com/products/iliad), oder Embedded-Baords wie das Beagleboard (http://beagleboard.org/) oder die Gumstixs (http://www.gumstix.com/). Um den Aufwand beherrschbar zu halten werden hierfür keine fertigen Binär-Pakete gepflegt. Auf Anfrage kann dies jedoch erfolgen.

Laufzeitumgebungen

Bei kleinen Geräten mit beschränkten Ressourcen ist es besonders wichtig eine adäquate Laufzeitumgebung zu wählen. Das jalimo Projekt stellt unterschiedliche Laufzeitumgebugen bereit, die im Folgenden vorgestellt werden.

CacaoJVM und JamVM

Lange bevor Sun den Java-Quellcode freigegeben hatte sind bereits einige freie Laufzeitumgebungen entstanden. Sie basieren alle auf der Klassenbilbliothek GNU Classpath, deren Versionsstand inzwischen etwa Java 1.5 erreicht hat. Zwei dieser Vertreter sind die CacaoJVM und die JamVM. Beide zeichnen sich durch einen kleinen Footprint und hohe Flexibilität aus. Damit sind sie sehr gut für den Einsatz auf mobilen Endgeräten geeignet. Die JamVM besticht durch ihren minimalistischen Ansatz. Sie basiert auf einem reinen Interpreter und kann daher Java-Programm sehr schnell starten. Die cacaoJVM bringt hingegen einen sehr schnellen just in time (JIT) Compiler mit. Die Verwendung bietet sich daher bei Java-Applikationen an, die während ihrer Laufzeit extensiver mit ihren Ressourcen umgehen. Dafür ist die cacaoJVM etwas träger beim Start kleiner Applikationen.

Sun PhoneME

Wem die J2SE Ausrichtung der Laufzeitumgebungen zu groß ist, für den bietet das jalimo Projekt die PhoneME von Sun. Dabei handelt es sich um eine schlanke VM, die die J2ME CDC und CLDC Profile umsetzt. Sie lässt sich in Verbindung mit den Paketen des MIDPath-Projektes (http://midpath.thenesis.org) verwenden, welches auch in jalimo integriert ist. MIDPath bietet eine freie Implementierung der MIDP Bibliotheken und einiger JSRs, die aus dem Bereich Mobiltelefon-Java bekannt sind.

OpenJDK is coming

Derzeit befindet sich die Bereitstellung des OpenJDK in Arbeit. Unter (http://jalimo.evolvis.org/repository/) existieren bereits inoffizielle Pakete für einige Plattformen. Die grundsätzliche Integration ist vollzogen. Leider besitzt die zugehörige Virtuelle Maschiene (HotSpot) jedoch noch keinen JIT-Compiler für die Arm-Plattform. Damit kann es noch einige Zeit dauern bis dies komplett einsetzbar ist. Es ist jedoch auch jetzt schon möglich die Klassenbibliothek des OpenJDK zusammen mit der CacaoJVM zu verwenden. Dabei ist natürlich zu beachten, dass das OpenJDK aufgrund seiner Größe nicht für jeden Einsatzzweck in Frage kommt.

GUI Bibliotheken

Ein wesentlicher Unterschied von mobilen Linux Distributionen zu ihren Desktop-Pendants sind die grafischen Oberflächen. Hier kommen häufig angepasste Frameworks und Window-Manager zum Einsatz. Damit wird es essentiell auch unter Java eine GUI-Bibliothek zur Verfügung zu haben, die sich gut in den mobilen Desktop integriert. jalimo setzt in erster Line auf das Eclipse-SWT-Toolkit (http://www.eclipse.org/swt/). Der Vorteil von SWT liegt in der Umsetzung auf nativen GTK-Widgets. Das ist zum einen Ressourcen schonend und bietet auf der anderen Seite eine gute Integration in die GTK-basierten Umgebungen. Der Einsatz von AWT und Swing ist zwar grundsätzlich auch möglich, jedoch auf den mobilen Endgeräten nicht so ausgereift. Dies wird besonders auf der Maemo-Plattform deutlich, die durch ihr GTK basiertes Hilden-Framework von Haus aus nur schwer mit fremden Toolkits umgehen kann.

OpenEmbedded

Ziel des Jalimo Projektes ist die breite Verbesserung der Java Unterstützung für mobile und eingebettete Linux-Plattformen. Um dies zu erreichen und dabei den Wartungsaufwand beherrschbar zu halten hat das Projekt früh auf OpenEmbedded gesetzt.

OpenEmbedded ist eine Cross-Compiling-Umgebung und Metadistribution, die es erlaubt einzelne Programme bis hin zu einer kompletten Linux-Distribution für Embedded-Systeme zu erstellen. Dies alles wird in einem einzigen zusammenhängenden Schritt vollzogen, bei dem sämtliche dafür benötigten Softwarekomponenten aus dem Quellcode erstellt werden. Dies beinhaltet sowohl die Cross-Compiler Toolchain, als auch alle anderen Helferprogramme.

Programme und Pakete werden in einer ähnlichen Weise wie in der Linux-Distribition Gentoo eingepflegt. Entwickler bringen Baurezepte ein, die Beschreiben wie und in welcher Form die Applikation kompiliert werden muss, welche Abhängigkeiten sie hat, welche sie erfüllt und wie die Zuordnung der Dateien zu den Binärpaketen ist. Die Ausgaben von OpenEmbedded bestehen je nach Konfiguration aus den bekannten Paketen im IPK, DEB oder RPM Format, aber auch aus direkt bootbaren Dateisystem-Images.

Der Vorteil von OpenEmbedded liegt auf der Hand: Ist eine Applikation oder Laufzeitumgebung wie Java einmal in OpenEmbedded integriert, ist es möglich diese Software für eine Vielzahl verschiedener Geräte anzubieten. Sind Aktualisierungen nötig, braucht nur das ursprüngliche Baurezept angepasst werden, um alle unterstützten Systeme von der Aktualisierung profitieren zu lassen. Die Distribtion enthält automatisch alle Abhängigkeiten und Programme die für einen Betrieb nötig sind. OpenEmbedded unterstützt eine große Anzahl verschiedenster Embedded-Geräte von Smartphones und PDAs bis zu WLAN-Routern. Es gibt über tausend verschiedene Pakete die von einfachen Kommandozeilenwerkzeugen bis hin zu komplexen GUI-Applikationen wie Firefox reichen.

Die Integration von jalimo in OpenEmbedded hilft also auf einfachste Weise neue Plattformen zu erschliessen und den Portierungsprozess so aufwandslos wie möglich zu gestalten.

Jetzt mal praktisch

Einleitung

Im Hinblick auf die Tools und die Programmierumgebung unterscheidet sich die Entwicklung einer mobilen Java-Anwendung mit jalimo nur wenig von der Entwicklung einer Java-Desktop-Anwendung. Dieser Vorteil ist vor allem dadurch gegeben, dass jalimo auf das volle J2SE setzt und nicht bloß die Java Micro Edition unterstützt. Es ist also möglich mit denselben Werkzeugen und Entwicklungsumgebungen wie für Desktop-Anwendungen zu entwickeln ohne das dafür spezielle SDKs oder IDE-Erweiterungen benötigt werden. Selbst die Anwendung kann mit etwas Sorgfalt bei der Entwicklung für den Desktop eingesetzt werden. Verschiedene Entwicklungslinien für Desktop und Mobilgerät sind nicht nötig, wenn die spezifischen Eigenheiten über eine Konfigurationsmöglichkeit abstrahiert werden.

In den folgenden Abschnitten wird erläutert, welche Pakete auf den mobilen Geräten installiert werden müssen, um eine Laufzeitumgebung für die Java-Anwendungen bereitzustellen. Im Anschluss wird darauf eingegangen, wie eine Beispielanwendung am Desktop mit Hilfe der Entwicklungsumgebung Eclipse erstellt und mit Hilfe des Buildsystems maven einfach in Pakete für verschiedene Zielgeräte umgewandelt werden kann. Das Beispiel wird sich am mobilen Gerät Nokia Internet Tablet orientieren. Das Nokia Internet Tablet wird mit der auf Linux und GTK/GNOME basierenden eigens dafür entwickelten Plattform Maemo betrieben. Das Oberflächen-Framework Hildon des Internet-Tablets basiert daher auf GNOME, unterliegt jedoch verschiedenen Anpassungen, die die Verwendung auf Handhelds erleichtern. Die aktuellste stabile Version ist zur Zeit Maemo 4.

Installation

Die Installation der Jalimo-Pakete wird mit Hilfe des Maemo-Paketemanagers durchgeführt. Intern basiert das Paketmanagement von Maemo auf dpkg, dem Debian-Paketformat. Jalimo unterstützt sowohl die aktuelle Maemo Version als auch ältere Versionen der Plattform. Die für diesen Artikel verwendete Version ist Maemo 4. Der Paketmanager auf dem Nokia Internet Tablet muss zunächst in einen anderen Modus geschaltet werden, der es erlaubt, auch Kataloge anderer Distributoren von Paketen einzupflegen. Wie dieser sogenannte Red-Pill-Modus eingeschaltet wird, kann im Maemo-Wiki nachgeschlagen werden [4]. Damit ist es möglich das Jalimo-Repository als Katalog einzutragen. Im Programmmanager muss zu diesem Zweck ein neuer Katalog erstellt werden, um das Jalimo-Repository einzutragen. Die Felder müssen wie folgt gefüllt werden:

Katalogname: Jalimo
Internetadresse: http://jalimo.evolvis.org/repository/maemo
Verteilung: maemo4.0
Komponenten user

Danach müssen die Kataloge aktualisiert und folgende Pakete installiert werden, um eine Ausführungsumgebung für Java auf dem Nokia Internet Tablet verwenden zu können:

 classpath-common
 libswt-gtk-3.4-jni
 cacao 

Weitere Abhängingkeiten werden automatisch vom Paketmanager aufgelöst. Auf dem Gerät ist nun eine Laufzeitumgebung für Java-Applikationen eingerichtet. Verwendet man den in späteren Abschnitt beschriebenen Weg, mit Hilfe des Maven Packaging Plugins, ein eigenes Paket aus der entwickelten Java-Applikation zu bauen, werden diese Abhängigkeiten automatisch mit eingefügt. Einem potenziellen Benutzer bleibt die Installation der Laufzeitumgebung also erspart.

Auf der Openmoko-Plattform gestaltet sich der Vorgang noch einfacher, da die jalimo-Pakete in die offiziellen Repositories übernommen wurden. Da es jedoch für die vorinstallierte Distribution noch keinen Paketmanager gibt, bleibt nur die Möglichkeit über die Eingabe auf der Kommandozeile. Ein

 opkg update
 opkg install cacao classpath

installiert die nötigen Pakete auf dem OpenMoko-Mobiltelefon.

SWT-Beispielanwendung

Ziel dieses Abschnittes wird die Entwicklung einer einfachen Java SWT-Anwendung sein, die auf einem mobilen Gerät ausgeführt und am Desktop erstellt wird. In Abbildung XX ist der Quellcode einer Beispiel-Anwendung, die eine einfache GUI implementiert, in der es möglich ist einen Datei-Dialog zu öffnen. In Abbildung XX ist die Anwendung dargestellt, wie sie bei der Ausführung auf dem Desktop aussieht. Zu sehen ist die Funktionalität in der Methode createGui(), die im Hauptfenster einen Knopf anlegt, der den SWT-Dateidialog öffnet. Weitere SWT-Widgets können ebenfalls wie vom Desktop gewohnt auch verwendet werden.

package org.jalimo.examples.swt;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
public class SwtExample2{
	Display display;
	Shell shell;
	Button fileButton;
	FileDialog fd;[
	public static void main(String[] args) {
		new SwtExample2();
	}
	public SwtExample2() {
		Display.setAppName("Linux Technical Review ;-)");
		display = new Display();
		shell = new Shell(display);
		createGUI();
		shell.open();
		while (!shell.isDisposed()) {
			if (!display.readAndDispatch())
				display.sleep();		}}
	private void createGUI(){
		fd = new FileDialog(shell, SWT.OPEN);
		fd.setText("Dateien");
		Menu bar = new Menu(shell, SWT.BAR);
		MenuItem item2 = new MenuItem(bar, SWT.PUSH); item2.setText("Exit");
		item2.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent se) {
				shell.close();
				System.exit(0);
			}
		});
		shell.setMenuBar(bar);
		shell.setLayout(new FillLayout(SWT.VERTICAL));
		Group upper = new Group(shell, SWT.NONE);
		upper.setLayout(new FillLayout());
		fileButton = new Button(upper, SWT.PUSH);
		fileButton.setText("open file\ndialog");
		fileButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent se) {
				fd.open(); }
		});
	} }

Bei der Einrichtung der Eclipse-Arbeitsumgebung gibt es im Verhältnis zur Entwicklung einer normalen Desktop-Anwendung keine Unterschiede. Die Laufzeitumgebung auf dem Mobilgerät implementiert weitestgehend den Java-5-Standard. Somit kann auf dem Desktop wie gewohnt mit einem OpenJDK oder Sun-JDK entwickelt werden. Auch das Starten der Anwendung während der Entwicklung kann wie gewohnt aus Eclipse heraus geschehen. Desktop.png

Im Hinblick darauf, dass die Anwendung auf einem mobilen Gerät laufen soll, sollten einige Punkte bei der Entwicklung beachtet werden. Es sollten möglichst wenige Voraussetzungen an die Größe des möglichen Displays auf der die Anwendung laufen soll gestellt werden. Ebenfalls könnte die Anwendung möglicherweise auch auf unterschiedlichen Displaygrößen laufen. Dabei gilt, dass die Displays natürlich in ihrer Auflösung und vor allem ihrer Größe deutliche Unterschiede zu Desktop-Bildschirmen haben. Bei der Entwicklung ist also zu wichtig, dass Knöpfe und andere GUI-Elemente ausreichend groß sind, damit die Bedienbarkeit auf kleinen Displays gewährleistet ist. Unter Umständen stehen zum Entwicklungszeitpunkt nicht alle Geräte zur Verfügung auf denen die Applikation laufen wird. Daher sollte man sich ein Bild der Applikation machen, in dem die Fenstergröße auf dem Desktop entsprechend reguliert wird. Die Performance eines mobilen Gerätes unterscheidet sich natürlich immer noch deutlich von der eines Desktop-Rechners. Gerade der Start der virtuellen Maschine bedeutet für ein mobiles Gerät einen größen Aufwand. Es sollte daher in Java Ressourcen schonend implementiert werden. Eine andere SWT-Version für den Desktop wird nicht benötigt. Bei der Verwendung von SWT und Java-Komponenten müssen allerdings einige derzeitige Limitationen auf Maemo beachtet werden. Dazu gehört die fehlende Unterstützung für SWT-HTML- und spezielle Hildon-Widgets sowie die Java-Preferences-API.

Packaging

Um die Distribution der mobilen Java-Anwendung zu erleichtern, existiert ein Paketierungs-Plugin für das Build-System Maven 2 von Apache [3]. Maven [2] erleichtert den Entwicklungsprozess erheblich, in dem alle Abhängigkeiten der Applikation automatisch verwaltet werden. Zunächst ist eine pom.xml zu erstellen, die es ermöglicht die Java-Anwendung zu kompilieren. Die gesamte Darstellung der verwendeten pom.xml wird aus Übersichtsgründen hier ausgelassen. Um die Anwendung nun mit dem Paket-Plugin zu paketieren sind zusätzlich Einträge in der pom.xml des Projektes nötig. Einerseits muss eine Abhängigkeit in das <build>-Tag der pom.xml wie in Abbildung XX zu sehen ist.

<build>
    <plugins>
	...
	<plugin>
             <groupId>de.tarent.maven.plugins</groupId>
             <artifactId>maven-pkg-plugin</artifactId>
             <version>2.0.3</version>
             <configuration>
             <defaultDistro>maemo_chinook</defaultDistro>
             <shortDescription>jalimo example</shortDescription>
             <defaults>
              <mainClass>org.jalimo.examples.swt.SwtExample2</mainClass>
              <section>user/other</section>
              <revision>r2</revision>
              <maintainer>Jalimo &lt;jalimo-info@lists.evolvis.org&gt;</maintainer>
              <datarootFiles>
                <datarootFile>
                  <from>jalimo-swt-example2.desktop</from>
                  <to>applications/</to>
                </datarootFile>
              </datarootFiles>
              <prermScript>test</prermScript>
              <preinstScript>test</preinstScript>
              <postrmScript>test</postrmScript>
              <postinstScript>test</postinstScript>
            </defaults>
 
      </configuration>
...
</build>

Zusätzlich muss Maven noch ein Plugin-Repository mitgeteilt werden, in welchem sich das referenzierte Plugin befindet. Zu diesem Zweck muss in das pluginRepositories-Tag der pom.xml der in Abbildung XX zu sehenden Eintrag hinzugefügt werden. Ist noch kein pluginRepositories-Tag in der pom.xml vorhanden, muss dieses direkt unterhalb des <project>-Tags eingefügt werden.

       <pluginRepository>
                <id>evolvis-release-repository</id>
                <name>evolvis.org release repository</name>
                <url>http://maven-repo.evolvis.org/releases</url>
                <snapshots>
                        <enabled>false</enabled>
                </snapshots>
        </pluginRepository>

Wie man erkennen kann, ist es auch möglich Informationen über die Anwendung im Paketierungsschritt anzugeben. Interessantestes Beispiel sind Installationsscripte, die nach und vor der Installation vom Paketmanager, wie ipkg oder dpkg ausgeführt werden. Ebenfalls ist es möglich ein Desktop-File beizulegen, welches der Benutzer dann als Menüpunkt. In diesem Beispiel landet die Desktop-Datei im Programmanager der Hildon-Oberfläche. Sowohl die Installationsscripte als auch die Desktop-Dateien legen müssen im Projektverzeichnis unter src/main/auxfiles abgelegt. Dort sucht Maven nach Dateien, die in der pom.xml referenziert sind. Eine Desktop-Datei kann wie in Abbildung XX zu sehen ist, angefertigt werden.

[Desktop Entry] 
Encoding=UTF-8 
Version=1.0 
TYPE=Application 
Name=Jalimo SWT Example 2 
Comment=2nd Example FOR Jalimo, using the SWT libraries. 
Exec=/usr/bin/jalimo-swt-example2

Um das Paket für Ihr Zielsystem zu paketieren, geben Sie bitte auf der Kommandozeile folgende Maven-Anweisung ein: $ mvn pkg:pkg -Ddistro=maemo_chinook Mit dem Parameter -Ddistro=Distributionsname kann beeinflusst werden, für welches Zielsystem das Paket angelegt wird. In diesem Beispiel für die Maemo Version 4, deren Codename chinook ist. Das Ergebnis des Vorgangs landet im target-Verzeichnis des Projektbaums. Ein Paket für das Openmoko-Smartphone lässt mit dem Distro-Argument “openmoko-2007.11” erstellen. Eine Liste weiterer möglicher Zielsysteme für die zur Zeit ein Pakete erstellt werden können, findet sich im Projekt-Wiki des Maven-Packaging-Plugins [1]. Zur Installations der Applikation muss das erstellte Paket mit einem Remote-Zugang auf das Zielgerät kopiert werden. Im Falle von Maemo kann die Kommandozeile dafür verwendet werden, den Paketmanager zu steuern und die Datei zu installieren. Dies erfolgt über das Kommando “dpkg” mit dem Parameter “-i”, gefolgt von dem zu installierenden Paket.

Die Auführung des Programms kann über zwei Wege durchgeführt werden. Einerseits kann man sich über ein Fernverbindung via Secure Shell auf dem Nokia Internet Tablet einloggen und die Applikation auf der Console ausführen. Das Maven-Packaging-Plugin sollte eine Datei in /usr/bin/ mit verpackt haben, so dass es möglich ist dieses auf der Kommandozeile auszuführen. In unserem Fall, heißt die Anwendung /usr/bin/jalimo-swt-example2. Einfacher geht es jedoch, wenn den kompletten Anweisungen gefolgt und eine Desktop-Datei angelegt wurde. Wenn dies der Fall ist, dann kann die Applikation aus dem Programmmanager ausgeführt werden. Wie die Anwendung auf dem Nokia Internet Tablet aussieht, ist in Abbildung XX zu sehen. Screenshot-2009-01-16-16-37-11.png Die selbe Applikation, nur mit einem anderen maven-Kommando für das Openmoko verpackt, sieht auf diesem Gerät wie in Abbildung XX aus. Jal.png

In den vorhergehenden Abschnitten wurde gezeigt, dass die nötigen Schritte um eine grafische Anwendung für ein mobiles Linux-Gerät zu entwickeln, sich nicht wesentlich von der Anwendung für den Desktop unterscheidet. Zu diesem Zweck wurde eine simple grafische Oberfläche mit SWT entwickelt und mit Hilfe des maven-Paketierungs-Plugins für das Nokia Internet Tablet auf einem Zielgerät installiert. Die Anwendung kann mit gleichem Java-Byte-Code auf allen unterstützten jalimo-Plattformen verwendet werden. Weitere Produktlinien für den Quellcode zur Unterstützung anderer Zielgeräte sind nicht nötig.

Referenzen

[1] http://wiki.evolvis.org/mvn-pkg-plugin/index.php/Built-in_Distribution-Definitions [2] http://maven.apache.org/ [3] http://wiki.evolvis.org/mvn-pkg-plugin/index.php/Main_Page [4] http://wiki.maemo.org/Red_Pill_mode

Fazit, Status und Ausblick

Das jalimo Projekt existiert nun seit 2 Jahren. Die vom Projekt direkt unterstützten Sachen wie SWT-basierte Anwendungen mit der cacao JVM oder jamvm laufen out of the box und haben sich bereits im Produktiveinsatz bewährt. Darüber hinaus sind viele Sachen möglich, die aber gelegentlich etwas Handarbeit bedürfen. Bei komplexeren und darüber hinaus gehenden Anwendungen bietet das Projekt einen guten Ausgangspunkt und bietet genügend Offenheit zum Mitmachen.