Spiele mit J2ME schreiben

von Slawa Weis

Wer auf diese Seite findet, der kennt bestimmt die kleinen Spiele die man auf seinem Handy spielen kann. Manschmal fällt auch das Wort Java-Spiele oder J2ME-Spiele. Die Hintergründe wie solche Spiele entstehen und auf das Handy kommen will ich in diesem Tutorial erläutern. Ich muss aber gleich einige entäuschen, denn ich setze die Kenntnisse der Programmiersprache Java voraus. Ich habe einfach keine Zeit und Grund hier einen Kurs in Java zu veranstaltet, das können andere besser (sehe nächsten Abschnitt). Dennoch wären schon einfach Kenntnisse von Java (z.B. wenn ihr schon erfolgreich ein Applet selber geschrieben und ins Internet gestellt habt) oder einer anderen Programmiersprache ausreichend um dieses Tutorial zu verfolgen und in die Programmierung von Handy Java-Spielen einzusteigen.

In diesem Tutorial werde ich ausführlich die Installation und die Bedienung aller Tools und Programme erklären, die benötigt werden um Java-Spiele für Handys und andere mobile Geräte zu schreiben. Wegen der persönlichen Ausstattung werde ich meine Erklärungen und Beispiele auf das Nokia J2ME API für Series 60 und das N-Gage konzentrieren, aber mit einwenig Kreativität lasst sich das Wissen und die Beispiele auch auf andere Hersteller und Geräte übertragen. Java für mobile Geräte ist einigermassen standardisiert, aber dennoch gibt es leider auch unumgängliche Abweichungen oder Erweiterungen zum Standard. Wenn das der Fall ist (z.B. das Bluetooth API für Nokia Series 60 Handys) werde ich das explizit betonnen. Weiterhin ist dieses Tutorial für den Einsatz der Tools auf Windows geschrieben, da aber die Tools und Java selbst plattformunabhängig erstellt werden, kann das Verfolgen der Beispiele ohne weiteres auch auf anderen Betriebssystemplattformen passieren. Die Installation der benötigten Tools und Programme auf anderen Systemen ist ähnlich wie auf Windows, oder ist der jeweiligen Dokumentation zu entnehmen.

Falls Sie Fragen, Anregungen, Verbesserungen, Kritik oder Lob zu diesem Tutorial haben, so zögern Sie nicht mir das per E-Mail slawaweis@animatronik.net oder ICQ 146486665 (bitte gleich erwähnen das Ihr mich wegen diesem Tutorial kontaktiert) mitzuteilen. Ich werde versuchen, so weit es mir die Zeit erlaubt, zu Antworten und eventuell dieses Tutorial zu aktualisieren. Bitte setzen Sie keine direkten Links auf die Bilder auf meinem Server, das sehe ich und werde sofort unterbinden.

Dieses Tutorial sollte eingentlich reichen, um einen Anstoß in die Programmirung von J2ME zu geben. Wer dennoch etwas nicht versteht, vermist oder einfach ein Buch in der Hand haben will, dem empfehle ich folgendes Buch:

"Java 2 Micro Edition" von "Sebastian Eschweiler", erschinen im vmi Buch Verlag 2003, ISBN 3-8266-7248-8. Es kostet EUR 9,95. Allerding muss ich gleich warnen, dieses Buch ist für Leute die Java gut bis sehr gut kennen. Es zeigt nur wie man in die J2ME Programmierung einsteigt, nicht wie man in Java programmiert. Dafür ist es sehr kompakt, sehr preiswert und bietet einen guten Umriss um die Thematik. Das Vertiefen kann man dann selber über die J2ME JavaDoc's erreichen. Dieses Buch geht außerdem auf die Oberflächenprogrammierung und andere interessante Sachen ein, welche ich in diesem Tutorial nicht behandle. Natürlich gibt es andere Bücher, neuerere und teuerere. Allerdings habe ich kein anderes Buch gelesen, deshalb kann ich nicht dafür sprechen. Einfach selber probelesen oder die Rezensionen dazu anschauen.

Wer jetzt keine Ahnung von Java hat, aber immer noch dieses Tutorial liest und unbeding in die Thematik einsteigen will, für den gibt es natürlich auch Hilfe. Für Java allgemein, gibt es kostenlos zugänliche Bücher im Internet:

Natürlich sind die nicht ganz frisch, allerdings für den Anfänger reichen die allemal. Wer ein aktuelles gedrücktes Buch haben will, dem kann ich leider keine Empfehlung geben, denn ich weis nicht was aktuell und gut ist. Es gibt sehr viele Bücher zum Java-Einstieg, also selber anschauen, probelesen, herausfinden was andere darüber denken. Das einzige was ich als Hilfe geben würde ist, Bücher von den Verlagen "dpunkt" oder "O'Reilly" zu nehmen, bei mir stappeln sich am meisten Bücher aus diesen Verlagen. Diese Bücher sind meist von Personen geschrieben, die auch Ahnung von den Sachen haben, über die sie schreiben. Leider sind es auch Bücher von Informatikern für Informatiker (was auch für mich ideal ist), aber mansche können das zu trocken finden. Also, wie gesagt, selber ausprobieren. Ach ja, noch was: die "in 21 Tagen ..." Bücher könnt ihr getrosst liegen lassen.

Wer sich jetzt entscheidet Java von Null zu lernen, dem kann ich nur raten nicht aufzugeben. Als kompletter Anfänger braucht man mindestens 2 Jahre um Java und die wichtigsten Java API's zu beherschen, vorausgesetzt man büffelt 2 Stunden am Tag oder 5 zusammenhängende am Wochenende. Wer also denkt nach ein paar Monaten nichts zu können, keine Sorge das kommt noch. Es wird einmal einen Tag geben, wo es in euren Kopf *klick* macht und plötzlich versteht ihr alles, alle Zussamenhänge und wie man vieles aus dem bekannten ableiten kann. Personen die schon die Grundlagen der Programmierung kennen, d.h. eine andere echte Programmiersprache beherschen (HTML und JavaScript sind keine Programmiersprachen und bei PHP streiten sich die Köpfe), brauchen durchschnittlich 1 Jahr um in Java einzusteigen, wobei der Großteil der Zeit auf das Kennenlernen der API''s draufgeht.

Für dieses Tutorial werden folgende Werkzeuge benötigt:

Alle Werkzeuge sind kostenlos zu bekommen.

Für dieses Tutorial ist es unumgänglich die Kommandozeile benutzen zu können. Darum gibt es hier einen kurzen Einstieg. In Windows geht man auf Start->Programme->Zubehör. Dort gibt es unter WindowsXP/2000 die "Eingabeaufforderung", unter 95/98/ME heißt es "MS-DOS-Eingabeaufforderung". Wenn ihr dieses Programm ausführt, seht ihr unter WindowsXP/2000:

Gebt jetzt 2 Mal cd .. ein. So gelang ihr direkt auf das Hauptverzeichnis der Festplatte, wo Windows installiert ist.

Das war es schon fürs erste, später werden wir von der Kommandozeile viel gebrauch machen.

Was ist eigentlich Java und wie sieht es aus? Java ist mehr als eine Programmiersprache. Es ist quasi eine eigene Welt in einem Betriebssystem. Es gibt Java-Programme und es gibt den Java-Interpreter JVM (Java Virtual Maschine). Java-Programme sind Plattformunabhängig, den die laufen auf der JVM. Die JVM übernimmt die Aufgabe die Java-Programme auf dem darunterliegenden System auszuführen.

So müssen die Java-Programme nur einmal geschrieben und kompiliert werden, aber die JVM muss für jedes System individuell angepasst werden. Das hat Vorteile, aber auch Nachteile. Einerseits kümmert sich ein Programmierer weniger um die Systembedürfnisse und konzentriert sich auf das wesentliche, aber andereseits kann er nicht ausreichend auf die Systemresourcen zugreifen. Da die Java-Programme auf der JVM laufen, sind diese nicht so schnell wie Programme die direkt für das System geschriben sind (wobei das sehr relativ ist, denn mit den neuesten Versionen der JVM, werden die Java-Programme während der Ausführung umgeschrieben und an die tatsächliche Anforderungen angepasst, so das manchmal Java-Programme schneller ausgeführt werden können, als native). Doch Diskusionen über die Ausführungsgeschwindigkeit und Vergleiche mit anderen Möglichkeiten Programme zu schreiben, sollen nicht Gegenstand dieses Tutorials werden. Hier geht es um Java für mobile Geräte und dafür nutzen wir die Vorteile von Java aus.

Gerade habe ich die Begriffe Java-Programme und JVM erklärt. Die JVM gibt es in mehreren Ausführungen: J2SE - (Java 2 Standard Edition), J2EE - (Java 2 Enterprise Edition) und J2ME - (Java 2 Micro Edition). Die J2SE liegt in verschiedenen Versionen vor: 1.0, 1.1.x, 1.2.x, 1.3.x, 1.4.x, 1.5.x, sowie Java 2.0 und Java 5.0 . Sun (die Erfinderfirma von Java) hat sich immer bemüht die großen Veränderungen an Java mit irgendeiner besonderen Bezeichnung oder Nummer zu versehen, damit man es nicht übersieht. So ist auch das Versionswirwar entstanden, wo vieles das selbe bedeutet. Um die Verwirung komplett zu machen, gibt es noch das J2SE SDK, das J2SE JDK und das J2SE JRE. Fangen wie an das Ganze zu ordnen. Zuerst J2SE, J2EE und J2ME.

So, ich hoffe jetzt ist es einigermassen klar, was unter den J2SE, J2EE und J2ME Ausführungen von Java verstanden wird. Kommen wir zu den Versionen. Dazu eine chronologische Liste:

Die wichtigsten Zahlen sind die, die mit 1. beginnen. Version 1.0 war die erste Version, rein für Applets. 1.1.x war schon besser, konnte aber immer noch nicht so viel wie nötig. Erst mit 1.2.x wurde Java zu einer ernsthaften Programmiersprache und Ausführungsplattform. Um den ersten großen Sprung zu markieren, gab Sun der Version 1.2.x die Bezeichnung Java 2.0. Die Versionen 1.3.x und 1.4.x waren mehr der Fehlerbereinigung und dem Aufblasen der API's gedient. Mit der aktuellen Version 1.5.x machte Sun wieder einen großen Sprung und führten eine Reihe neuer Regeln und Quelltextkonsteruketen in die Java-Sprache ein. Außerdem veränderten sie zum ersten Mal seit 1.0 das Format des Byte-Codes von Java-Programmen. Um wieder den großen Schritt zu markieren (und Microsoft mit seiner .NET 2.0 Version davonzulaufen) hat Sun der Version 1.5.x den Beinamen Java 5.0 verpasst.

Irgendwann zwischen 1.2.x und 1.5.x kam die Aufteilung in J2SE, J2EE und J2ME. Wann genau weis ich nicht mehr, aber ab dann bekammen alle Versionen noch den Beinamen J2SE 1.Y.x und Java 5.0 bekamm J2SE 5.0. Diese Versionen gelten übrigens nicht für J2ME, dort werden die Generationen anders gezählt, was ich später erläutere.

Mit dem SDK (Software Development Kit), dem JDK (Java Development Kit) und dem JRE (Java Runtime Enviroment) werden zwei Pakete der JVM bezeichnet, wobei das SDK und das JDK einfach das selbe ist. Das JRE ist nur die reine JVM um Programme auszuführen, wird normalerweise zusammen mit dem eigenen Java-Programm an den Endanwender weitergegeben. Das SDK/JDK ist die JVM plus der Java Compiler, sowie ein paar Tools zum Programmeentwickeln. Das SDK braucht der Endanwender nicht, aber das brauchen wir um Java-Programme zu schreiben. Das SDK enthällt übrigens die JRE komplett, so das wir für uns nur das SDK brauchen. Zu jeder oben beschriebenen Version gibt es ein SDK und ein JRE.

Hier nochmal eine kurze Zusammenfassung dieses Abschnits:

So, ich hoffe das war ausführlich genug zu den Java Versionen. Im nächten Kapitel werden wir die J2SE installieren und konfigurieren.

Nachdem ich im vorherigen Kapitel in die Welt von Java eingeführt habe, geht es hier um den Einsatz der aktuellen Java Version. Zuerst müssen wir sicherstellen, was von Java überhaupt auf euren Rechner vorhanden ist. Die JVM wird Heute von einigen Programmen auf dem Rechner installiert oder ihr habt euch irgendwann das SDK/JDK oder das JRE runtergeladen und installiert. Aus diesen Grund testen wir es. Startet die Kommandozeile und gebt java -version ein. Wenn das erscheint:

Habt ihr schon eine JVM auf dem Rechner. Wenn das erscheint:

Habt ihr noch keine JVM auf dem Rechner. Falls ihr eine JVM drauf habt, testen wir gleich ob es das SDK/JDK ist. Dazu geben wir javac ein:

Falls ihr auch das SDK/JDK auf den Rechner habt, so sollte alles ab 1.4.0 für dieses Tutorial genügen. Falls nicht, solltet ihr das SDK/JDK 1.5.0 installieren. Allerdings hierzu eine Warnung: falls ihr eine JVM unter 1.5.0 schon habt, kann es sein das ein anderes Programm dieses braucht. Da 1.5.0 einige Änderungen mit sich bringt, kann das es passieren, dass das besagte Programm nicht mehr korrekt funktioniert. In diesem Fall sollte man sich die neueste Version des Programms hollen oder wieder die vorherige JVM installieren.

So, kommen wir zu der eigentlichen Installation. Wir brauchen das SDK von J2SE 1.5 um unsere Java-Programme zu compilieren. Das SDK findet ihr hier:

Um nicht das falsche zu bekommen, dort gibt es ein Paket "NetBeans IDE + ...", das brauchen wir nicht. Wir brauchen nur das SDK/JDK. Zuerst den Link zum SDK/JDK anklicken, dann den Lizenzbedingungen zustimmen (ihr könnt diese auch durchlesen :) ) und schon kommt ihr zu den Downloads. Hier "Windows Offline Installation ..." (oder was eben eurem Betriebssystem entspricht) wählen und runterladen. Die Größe des Paketes bei Windows sollte über 50 MB liegen. Für dieses Tutorial habe ich die Datei "jdk-1_5_0_03-windows-i586-p.exe" runtergeladen mit der Größe von 55.11 MB.

Ist die Datei auf der Festplatte, starten wie diese. Wir sehen den Begrüssungsschirm:

die üblichen Lizenzbestimmungen, dennen wir zustimmen müssen:

und jetzt die Installationsparameter. Ich rate dringend alles so zu lassen wie es ist, d.h. alles zu installieren und den Pfad der Installation nicht ändern:

und schon läuft die Installation:

Dann kommen noch einige optionale Ergänzung, die vor allem die zu unterstützenden Sprachen betreffen. Das sollte man auch alles installieren:

Jetzt wird noch mal vom Installer nachgefragt ob die JVM in die Internetbrowser verlinkt werden sollte. Hier ist nach persönlichen Geschmack zu entscheiden ob, wir brauchen es jedenfalls für dieses Tutorial nicht. Für die Verlinkung in einen der Browser, sollte der jenige Browser beendet werden. Liest aber erst kurz 2 Bilder weiter, bevor ihr den Browser schliesst:

und damit sind wir schon fertig:

Hier sollte der Rechner neugestartet werden:

Nach dem Neustart müssen wir noch die Pfade zu dem SDK eintragen, damit wir damit in der Kommandozeile arbeiten können. Dazu gehen wir unter WindowsXP/2000 zu Start->Einstellungen->Systemsteuerung. Dort wählen wir "System" aus. In dem erschienenem Dialog, wählen wir das Tab "Erweitert" und klicken auf die Schaltfläche "Umgebungsvariablen" ganz unten. Im nächsten Dialog sehen wir zwei Listen der Umgebungsvariablen, die erste ist nur für den aktuellen User, die zweite für alle User im System. Die zweite könnt ihr nur ändern, wenn ihr Admin Rechte habt. Wir müssen aber nur in der ersten Liste was machen. Sucht in der ersten Liste die Variable "Path" raus (wobei die Groß-/Kleinschreibung von "Path" egal ist). Wählt den Eintrag aus und klickt auf "Bearbeiten". Wenn der Eintrag nicht vorhanden sein sollte, dann klickt auf "Neu". Jetzt muss man aufpassen! Wir wollen den Pfad ergänzen, nicht ersetzen! Wenn zu der Variable "Pfad" schon ein Wert existiert, so muss dieser erhalten bleiben! Um den Pfad zu ergängen, schreiben wir folgenden Text (falls ihr bei der Installation einen anderen Pfad für das SDK genommen habt, müsst ihr es entsprechend ändern):

vorne an die vorhandene Zeichenkette. Das Zeichen ; trennt dabei die Pfade. Mit unseren beiden Einträgen verweisen wir das System auf die JVM und den Java-Compiler. So sollte das ganze aussehen:

Wobei natürlich die vorhandenen Pfade (wenn da welche waren) hinten dran sind. Jetzt "OK" drücken und dann nochmal mit zweimal "OK" die Dialoge verlassen. Damit haben wir die Pfade in WindowsXP/2000 gesetzt. Um die Pfade unter Windows 95/98/ME zu setzen, müssen anderswohin. Auf "C:\" gibt es die Datei "AUTOEXEC.BAT". Diese müssen wir bearbeiten und ganz unten folgende Zeile hinzufügen (falls der Browser die folgende Zeile irgendwo umbricht, es muss alles in einer Zeile stehen):

Dann die Datei speichern und Windows neustarten.

Nach den ganzen Installations- und Konfigurationsprozeduren testen wir ob alles richtig installiert worden ist. Schliesst alle Kommandozeilen die ihr offen habt und startet eine neue (ist wichtig). Dann gebt java -version und javac -version ein. Wenn folgendes erscheint:

Dann ist die Installation & Konfiguration von J2SE abgeschlossen. Noch was am Rande, vor 1.5.0 gab es den Parameter "-version" für javac nicht. Falls ihr also ein SDK bis 1.5.0 habt, müsst ihr javac einfach so aufrufen.

Im vorherigen Abschnitten haben wir die J2SE von Sun kennengelernt. Es ist eine konkrete JVM, von Sun geschrieben und vertrieben. Sun passt diese JVM an verschiedene Betriebssysteme an. Programme die für die J2SE von Sun geschrieben sind, laufen überall auf der JVM und können alle Bibliotheken von J2SE nutzen. D.h. nichts anderes, als das die Sun JVM aus einer Hand kommt und alles mitbringt was wir brauchen (und viel viel mehr).

J2ME ist anders. Da es eine Unmöglichkeit ist eine JVM zu schreiben, die auf allen möglichen kleinen/mobilen Geräten läuft, gibt es für J2ME von Sun keine JVM, sondern nur ein Spezifikation, wie eine J2ME JVM aussehen muss. Diese Spezifikation fordert einen Standardsatz von festen Klassen, sowie die minimalen Anforderungen an die Hardware. So kann jeder Hersteller eine eigene JVM entwickeln, solange diese im Kern der Sun Spezifikation entspricht. Normalerweise ist eine solche J2ME JVM schon auf dem Gerät vorinstalliert und kann vom Benutzer nicht aktualisiert/installieren/erweitert werden. Da die Sun Spezifikation aber bei weitem nicht ausreicht die inviduellen und besonderen Funktionen eines Gerätes zu nutzen, ist es den Herstellern erlaubt eigene Erweiterungen zusätzlich zu der Spezifikation umzusetzen. Mit solchen Erweiterungen hat man mehr Möglichkeiten das Gerätes zu nutzen, aber man wird dabei auch abhängig von einem Hersteller oder Gerät. Trotzdem hat das auch Vorteile, es ist immer noch die selbe Syntax der Sprache und die meisten Teile des Programmes, die unabhängig von irgendwelchen Erweiterungen sind, können in Bibliotheken gehalten werden, welche dann die verschiedenen Versionen des Programms nutzen.

Sehen wir uns die Sun J2ME Spezifikation genauer an. Hier ist ein kleines Diagramm, wie eine JVM aufgebaut werden muss:

Hier noch mal zum Vergleich das Diagramm der J2SE:

Gehen wir das erste Diagramm von unten nach oben durch. Als erstes sehen wir das Gerät oder sein Betriebssystem. Der Unterschied spielt schon eine Rolle, den während die J2SE JVM auf einem Betriebssystem läuft, kann eine J2ME JVM auch direkt auf der Hardware laufen. Hängt ganz vom Hersteller ab, wie er das realisiert. Es kann sogar das ganze Gerät mit Java programmiert sein. In Fall dieses Tutorials läuft aber die Nokia J2ME JVM auf dem Symbian OS. Für das Programmieren sollte es aber egal sein, was unter der J2ME JVM liegt.

Auf dem Betriebssystem/Gerät setzt die JVM auf. An dieser Stelle muss ich eigentlich von der KVM (Kilo(Byte) Virtual Maschine) sprechen, was eben eine JVM mit wenig Ressourcen bedeutet. Da aber Sun schon für zuvieles doppelte und dreifache Namen vergeben hat, lass ich es und spreche von der JVM. Wenn ihr aber irgendwo auf den Begriff KVM stoßt, es ist das selbe wie die JVM, außer dass es primär für Geräte mit sehr begrenzten Kapazitäten gedacht ist.

Auf der JVM setzt die Configuration Ebene auf. Diese Ebene regelt die Hardwareanforderungen an das Gerät um Java-Programme auszuführen. Außerdem entscheidet die Ebene über den minimalen Standardsatz an Klassen, die eine J2ME JVM mitbringen muss. Es gibt zu Zeit 2 Konfigurationen:

Die erste ist CLDC (Connected Limited Device Configuration):

Die zweite ist CDC (Connected Device Configuration):

An diesen beiden Konfigurationen sehen wir, dass wenn das Gerät CLDC oder CDC unterstützt, dann hat es so viele Resourcen wie von der Spezifikation gefordert und wir können entsprechende Programme schreiben. Die CLDC/CDC Konfiguration einer J2ME JVM oder Gerätes wird vom Hersteller festgelegt und lässt sich normalerweise nicht vom User verändern. Beim Design wurde die CLDC für mobile Geräte wie z.B. Handys und die CDC für z.B. SetTop-Boxen, leistungsfähigere PDAs oder PocketPCs gedacht. Wobei CLDC sich gut durchgesetzt hat, aber CDC bis jetzt kaum verwendet wird. Weitere Konfigurationen gibt es zu Zeit nicht, aber es wäre durchaus möglich das in der Zukunft welche kommen.

Über der Configuration Ebene sehen wir auf dem Diagramm die Profil Ebene. Es ist wieder eine Mindestanforderung, diesmal aber an die Software. Es gibt mehrere Sätze von Java-Klassen/-Bibliotheken, die zu jeweiligen Profilen gehören. Wenn also ein Gerät ein bestimmtes Profil unterstützt, dann wissen wir, welche Klassen wir ohne Bedenken verwenden können. Es gibt verschiedene Profile für J2ME, z.B. "MIDP", "Foundation Profile", "Personal Profile", "Personal Basis Profile", "Information Module Profile", "Digital Set Top Box Profile" und andere. Bis auf das erstgenannte, MIDP, habe ich mich mit keinem anderen Profil beschäftigt. Die brauchen wir auch nicht, weil das meiste davon sowieso nicht für Handys oder Spiele bestimmt ist. Wie schon gesagt, J2ME ist sehr flexibel. Wenden wir unsere ganze Aufmerksamkeit dem MIDP zu.

Das "MIDP" (Mobile Information Device Profile) ist ein Satz von Klassen um beliebige Anwendungen auf den Geräten zu schreiben. Darunter fallen einfache Oberflächenelemente, verschiedene grafische Funktionen um selber irgendwas auf den Bildschirm zu malen, einfache Rasterbildbearbeitung, einfache Netzwerkfuntionen, der Zugriff auf den nicht fluchtigen Speicher des Gerätes (falls es welchen gibt) und einige andere Kleinigkeiten. Also von allem etwas, aber leider nicht ausreichend genug. Doch für unsere Zwecke reicht es allemal. Von dem MIDP gibt es inzwischen 3 Versionen, wobei die dritte so neu ist, dass noch kein Hersteller diese umgesetzt hat (jedenfalls zu der Zeit als dieses Tutorial entstand). Die erste Version, MIDP 1.0, ist stark eingeschränkt, wenn es darum geht Spiele zu schreiben, sie wurde eben nicht für Spiele entworfen. Bei der zweiten Version lag der Schwerpunkt auf den Spielen und so sind da viele nutzliche Erweiterungen hinzugekommen, wenn man vor hat Spiele zu schreiben. Doch blöderweise unterstützt das N-Gage nur MIDP 1.0 und Nokia hat nicht mehr vor das zu ändern. Aus diesem Grund beschränke ich dieses Tutorial auf das MIDP 1.0. Bevor ihr jetzt aufhört das Tutorial zu lesen, lasst mich ein paar Sachen dazu sagen. Wenn ihr J2ME nicht kennt, ist es vollkommen egal wo ihr anfängt, denn MIDP 2.0 beinhaltet MIDP 1.0 komplett, also müsst ihr es sowieso lernen. Dann ist MIDP 1.0 klein genug um es schnell zu begreifen und so schneller in die Programmierung von J2ME einzusteigen. Außerdem habe ich schon früher gesagt, dass dieses Tutorial ausführlich von den Erweiterungen des Nokia J2ME API's für Series 60 Gebrauch machen wird und da hat Nokia schon viele Sachen vorher umgesetzt, die später in das MIDP 2.0 reinkammen. Also keine Sorge, wir werden schon eine gute Grundlage haben. Wenn ihr immer noch nicht zufrieden seit, seht einfach nach, wie viele Spiele es schon auf Basis von MIDP 1.0 gibt und von welcher Qualität diese sind. Bei dem Spieleprogrammieren kommt es an die Kreativität an und nicht daran was großer, schneller oder besser ist.

Auf den Profilen setzen dann die Java-Programme auf. Diese werden ganz normal mit den Compiler der J2SE übersetzt, deshalb brauchen wir auch keinen zusätzlichen Compiler.

Sehen wir uns jetzt an, wie das Ganze auf einem konkretem Gerät aussieht. Dazu als Beispiel das N-Gage und die Spezifikation von der folgenden Webseite (unter dem Punkt "Java Technology"):

An der Spezifikation sehen wir, dass das N-Gage die CLDC 1.0 und das MIDP 1.0 unterstützt. Weiterhin sehen wir noch 3 Parameter. Diese Parameter sind die oben genanten Erweiterungen des Herstellers. Das Nokia UI API ist dazu da, Series 60 Oberflächen zu programmieren. Die Wireless Messaging API (JSR-120) und Mobile Media API (JSR-135) Erweterungen sind wiederum nicht von Nokia, sondern von Sun. Sie sind aber kein Teil der Sun J2ME Spezifikation und müssen deshalb nicht auf jedem J2ME Gerät vorhanden sein.

Damit wären wir auch am Ende der J2ME Einführung. Wenn etwas bis jetzt nicht klar sein sollte und noch Fragen geblieben sind, dann wartet einfach das übernächste Kapitel ab, da werden wir ein kleines Programm schreiben und es auf das Handy bringen. Vielleicht wird dann einiges klarer.

Das Nokia J2ME API für Series 60 ist auf der folgenden Seite zu finden:

Für MIDP 1.0 brauchen wir das "1st Edition, FP 1 (formerly 1.2.1)" Paket, also das älteste. Neuere setzen MIDP 2.0 voraus und sind deshalb für dieses Tutorial ungeeignet. Rechts gibt es eine Auswahlbox, da sollte man "1st Ed, FP 1 (16 MB)" auswählen und auf "Download Now" klicken. Jetzt kommt eine Login-Seite und man muss sich anmelden. Wer da noch nicht registriert ist, kann es jetzt tun, es ist kostenlos und in wenigen Schritten erledigt. Merkt euch das Login/Passwort sehr gut und gebt eine gültige E-Mail Adresse an, wir werden das später brauchen. Ist das erledigt, kommt auch schon der Download der Datei nS60_jme_sdk_v1_2_1.zip, 16.7 MB groß.

Wenn der Download beendet ist, entpackt ihr das ZIP Archiv. Dort befinden sich 4 Dateien. Die PDF Datei ist interessant, falls ihr mehr über die Installation wissen wollt, aber ihr könnt auch gleich das SDK installieren. Dazu wird setup.exe ausgeführt:

Hier einfach auf "Next" klicken:

den üblichen Lizenzbedingungen zustimmen:

Ich weis nicht wozu Nokia das eingeführt hat (in der nächsten Generation des SDK ist es nicht mehr drin), aber man muss sich jetzt eine Seriennummer für das SDK besorgen. Das ist aber kostenlos und geht sehr schnell, wenn ihr eine aktive Internetverbindung habt. Auf "Next" klicken:

alles so lassen wie es ist, außer ihr wollt über ein Proxy gehen. Auf "Next" klicken:

hier müsst ihr nochmal die gleichen Daten eingeben, die ihr bei der Registrierung zum Download bekommen habt, also Login und Passwort. Auf "Next" klicken:

einwenig warten:

Habt ihr bei der Registrierung eine gültige E-Mail angegeben, dann kommt nach kurzer Zeit die E-Mail mit der Seriennummer. Kopiert diese in das Feld in dem Formular. Passt auf, dass ihr keine Leerzeichen um die Seriennummer herum erwischt, sonst klappt die Registrierung nicht. Auf "Next" klicken:

und schon seit ihr durch die Registrierung durch. Jetzt muss man dem Installer nochmal helfen, den der kennt das J2SE 1.5 SDK nicht. Falls ihr ein J2SE SDK unter 1.5 habt, wird dieses gefunden und ihr könnt es auch verwenden, für alle anderen heißt es auf "Browse..." gehen und den Installtionsordner der J2SE 1.5 SDK finden. Wenn ihr nichts an der J2SE 1.5 SDK Installation verändert habt, müsste der Ordern unter dem Pfad zu finden sein: C:\Programme\Java\jdk1.5.0_03. Jedenfalls sollte es so aussehen:

Auf "Next" klicken:

Hier sollte man den Pfad so lassen wie er ist. Auf "Next" klicken:

dann kommt endlich die Zusammenfassung. Auf "Install" klicken:

Installation läuft:

und mit "Finish" ist alles fertig. Jetzt ist das Nokia J2ME API für Series 60 installiert. Falls ihr den Installationspfad nicht verändert habt, findet ihr das SDK unter: C:\Nokia\Devices\Series_60_MIDP_SDK_for_Symbian_OS_v_1_2_1. Ich rate euch dringend keinen Ordner in diesem Pfad mehr umzubennen oder das ganze SDK anderswo zu verschieben.

Zum Schluss, müssen Analog zu der J2SE Installation, zwei Pfade gesetzt werden, damit wir damit in der Kommandozeile arbeiten können. Dazu gehen wir unter WindowsXP/2000 zu Start->Einstellungen->Systemsteuerung. Dort wählen wir "System" aus. In dem erschienenem Dialog, wählen wir das Tab "Erweitert" und klicken auf die Schaltfläche "Umgebungsvariablen" ganz unten. Im nächsten Dialog sehen wir zwei Listen der Umgebungsvariablen, die erste ist nur für den aktuellen User, die zweite für alle User im System. Die zweite könnt ihr nur ändern, wenn ihr Admin Rechte habt. Wir müssen aber nur in der ersten Liste was machen. Sucht in der ersten Liste die Variable "Path" raus (wobei die Groß-/Kleinschreibung von "Path" egal ist). Wählt den Eintrag aus und klickt auf "Bearbeiten". Wenn der Eintrag nicht vorhanden sein sollte, dann klickt auf "Neu". Jetzt muss man aufpassen! Wir wollen den Pfad ergänzen, nicht ersetzen! Wenn zu der Variable "Pfad" schon ein Wert existiert, so muss dieser erhalten bleiben! Um den Pfad zu ergängen, schreiben wir folgenden Text (falls ihr bei der Installation einen anderen Pfad für das Nokia SDK genommen habt, müsst ihr es entsprechend ändern):

vorne an die vorhandene Zeichenkette. Das Zeichen ; trennt dabei die Pfade. Mit unserem Eintrag verweisen wir das System auf den Preverifer (kommt gleich noch) und den Symbian-Emulator. So sollte das ganze aussehen:

Wobei natürlich die vorhandenen Pfade (wenn da welche waren) hinten dran sind. Jetzt "OK" drücken. Jetzt müssen wir aber noch eine Umgebungvariable setzen. Analog zu "Pfad" setzen wir "CLASSPATH". Wie schon einmal gesagt, sollte die Umgebungvariable CLASSPATH nicht vohanden sein, neu erstellen, wenn vorhanden, aufpassen diese nicht zu überschreiben. Vorne wird der folgende Pfad angefügt:

welcher aus einer Zeile besteht (im Browser wird es umgebrochen), und das sollte so aussehen:

Jetzt drei mal "OK" drücken und wir sind damit fertig die Pfade zu setzen. Testen wir, ob alles korrekt installiert wurde. Schliesst alle Kommandozeilen die ihr offen habt und startet eine neue (ist wichtig). Jetzt gebt zuerst preverify, dann emulator -version und zum Schluss set CLASSPATH ein:

Wenn ihr auch ein solches Ergebnis bekommen habt, ist alles korrekt installiert und konfiguriert. Wenn irgendwas nicht geht, dann müsst ihr nochmal diesen Abschnitt lesen und überprüfen ob ihr nichts vergessen habt. Wenn es immer noch nicht geht, E-Mail an mich mit einer ausführlichen Fehlerbeschreibung und den Fehlermeldungen.

Endlich! Nach den ganzen Erklärungs- und Installationsorgien kommen wir endlich zum wesentlichen. Nach diesem Abschnitt werden wir ein Java Programm auf dem Handy haben und wir werden wissen, wie es dahin kommt. Zuerst die Reihenfolge der Erstellung:

Als erstes legen wir uns einen Projektordner an. Dieser kann überall angelegt werden, z.B. in C:\j2meprojects. Man sollte nur vermeiden Leerzeinen in die Ordnernamen reinzusetzen, das gibt unnötigen Ärger. In dem Projektordner legen wir einen Ordner für unser erstes Programm an. Ich will ein grafisches "Hello World!" Programm schreiben, also eines welches in der Mitte des Displays die Zeichenkette "Hello World!" ausgibt. Deshalb nenne ich das Programm "GHelloWorld". Dazu lege ich einen Ordner ghelloworld an und zusammen sollte es C:\j2meprojects\ghelloworld sein. In ghelloworld legen wir dann noch zwei Unterordner sclass und mclass an, dorthin kommen später unsere kompilierten Klassen rein.

Als nächstes starten wir Notepad oder einen anderen einfachen Texteditor. Ich betonne einfach, MS Word und WordPad sind keine einfachen Editoren, wir müssen nur Text speichern. Notepad ist zu finden unter Start->Programme->Zubehör->Notepad und sieht so aus:

Als nächstes wird der gesamte folgende Quelltext ins Notepad kopiert. Ich werde jetzt nicht ausführen wie Java-Programme aufgebaut sind, das kann ein Java-Buch besser und ich hoffe die Kommentare reichen fürs erste aus, das Programm zu verstehen. In den nächsten Kapiteln werde ich den Aufbau von J2ME und MIDP Programmen besser erläutern, hier geht es um den Weg des Programms auf das Handy. Nur soviel noch, MIDP basierte Programme haben viel mit Applets gemeinsam, deshalb werden diese auch MIDlets genannt. Jedenfalls jetzt den gesamten Quelltext kopieren.

Der Quelltext wird dann im angelegten Programmordner gespeichert und bekommt den Namen GHelloWorld.java. Wo wir für die Ordnernamen kleine Buchstaben verwendet haben, wegen der Einfacherheit, so müssen wir die Java-Quelltextdatei unbedingt GHelloWorld.java nennen, also G, H und W groß, alles andere klein (es ist wichtig). Ist das erledigt, müsste es in Notepad so aussehen:

und die Java-Datei unter dem Pfad:

zu finden sein. Als nächstes kompilieren wir diese. Dazu starten wir die Kommandozeile, wechseln mit cd C:\j2meprojects\ghelloworld in den Programmordner und rufen:

auf. Der Parameter "-d" gibt dabei den Ordner an, wohin die compilierte Version des Programms geschrieben werden soll. Wenn alles ohne Probleme geklappt hat, müsste im sclass eine Datei namens GHelloWorld.class und eine namens GHelloWorld$HelloWorldPanel.class aufgetaucht sein. Das ist das übersetzte Programm. Wenn es Fehlermeldungen bei der Übersetzung gab, dann habt ihr entweder bei der Groß-/Kleinschreibung des Dateinamens was falsch gemacht, die Pfade nicht richtig gesetzt, den Ordner sclass falsch bzw. am falschen Platz angelegt oder den Quelltext unzureichend kopiert. Überprüft das. Wenn es immer noch nicht geht, E-Mail an mich mit einer ausführlichen Fehlerbeschreibung und den Fehlermeldungen. Bitte unbedingt die Fehlermeldungen mit senden, hellsehen kann ich nicht.

Auch wenn das Programm übersetzt wurde, es ist noch nicht im richtigen Format. Wir wissen nur, das es keine Fehler im Quelltext gibt. Das Problem an dieser Stelle ist, dass Java eine sehr sichere Sprache ist. In die Class-Dateien werden viele Konstrukte eingebettet die Fehler währen der Ausführung abfangen. Für eine J2ME JVM ist es zu viel Aufwand und da werden auch die meisten Konstrukte von z.B. eine PC-Architektur nicht gebraucht. Deshalb müssen wir die Klassen "verifizieren", ob sie auf einer J2ME laufen werden und die unnötigen Konstrukte entfernen. Dazu gibt es das preverify Tool. Das funktionier aber zu Zeit nur mit einem Java 1.4 kompatiblen Code. Kein Problem, der Java Compiler ist abwärzkompatibel. Um Klassen für die 1.4 Version zu kompilieren rufen wir:

auf. Die zwei neuen Parameter sagen dem Compiler, er soll prüfen on der Quelltext Java 1.4 kompatibel ist und die Ausgabe sollte 1.4 kompatibel sein. Wer einen Java Compiler aus dem J2SE 1.4 SDK benutzt, braucht diese zwei Parameter nicht anzugeben. Als nächstes verifizieren wir die Class-Dateien. Dazu rufen wir

auf. Dieses Tool prüft den Code in dem Ordner sclass und erstellt eine J2ME kompatible Version in dem Ordner mclass. Der Aufruf ist für 1.4 und 1.5 gleich.

In dem 1.5 Compiler ist eine neue Möglichkeit hinzugekommen, gleich J2ME kompatible Classen zu erzeugen. Dazu muss dieser Befehl ausgeführt werden:

und wir haben gleich die richtigen Klassen in mclass.

OK, nochmal alles damit es klarer wird. Habt ihr das J2SE 1.4 SDK, dann führt diese 2 Kommandos nacheinander aus:

Habt ihr das J2SE 1.5 SDK, dann könnt ihr alternativ das:

oder das:

aufrufen um die richtigen Klassen in dem mclass Ordner zu bekommen. Damit man nicht ständig die Befehle per Hand einzugeben hat, kann man sich eine Batch-Datei anlegen. Dazu wird unter Windows noch ein Notepad Fenster geöffnet und die Befehle werden dort eingegeben. Das ganze wird in dem Programmordner unter dem Namen cpje.bat gespeichert und sollte so aussehen (hängt ab, welches SDK und welche Alternative ihr bevorzugt):

Um das Programm jetzt neu zu übersetzen, einfach cpje.bat aufrufen. CPJE steht übrigens für: Compile, Preverify, Jar und Emulate. Zu den zwei letzten kommen wir noch, die Ausgabe sollte jedenfalls die gleiche sein wie bei den einzelnen Kommandos:

Sind die zwei Class-Dateien in dem mclass Ordner erstellt, wenden wir uns den JAD/JAR Dateien zu. Was ist JAD und was ist JAR? Wenn ihr mal Java-Spiele für das Handy in Internet angesehen habt, habt ihr bestimmt gesehen das es normalerweise ein Paar JAD/JAR gibt. Viele halten es für das selbe und viele denken das JAR alleine ausreicht. Das stimmt alles nur zum Teil. Das wirkliche Programm liegt immer in der JAR-Datei, welche ein ZIP-Archiv ist, mit einer immer vorhandenen Datei, dem Manifest. In diesem Manifest sind Meta-Informationen aufgelistet, die den Inhalt des JAR's und/oder der darin enthaltenen Programme beschreiben. Diese Meta-Informationen beschreiben z.B. für welche J2ME Configuration und Profil dieses Programm geschrieben ist, wer der Autor ist, mit welcher Klasse das Programm gestartet wird und weitere nutzliche Sachen. Die JAD-Datei ist eine reine Textdatei und fast dem Manifest der JAR ähnlich. Die JAD-Datei beschreibt auch, was in der JAR-Datei drin ist und wie groß diese ist. Der Grund für die Aufteilung in JAD/JAR liegt darin, das wenn ein Handy aus dem Internet ein Programm runterladen will, so ist die Zeit für den Download sehr teuer und aus diesem Grund möchte das Handy wissen, ob das Programm überhaupt kompatibel ist und genug Speicher dafür vorhanden ist. Zuerst wird also die JAD-Datei runtergeladen und überprüft. Wenn alles stimmt, wird die JAR Datei runtergeladen und installiert. Wenn man ein Java-Programm per Bluetooth oder Kabel auf das Handy bringt, dann wird die JAD-Datei nicht mehr gebraucht, JAR alleine reicht aus um das Programm zu überprüfen und zu installieren. Wegen der Sauberkeit und wegen der J2ME Spezifikation sollte man immer eine JAD- und eine JAR-Datei anlegen und zusammen vertreiben.

Dann schreiben wir zuerst die Manifest-Datei. Nochmal ein Notepad öffnen und folgenden Text reinkopieren:

und das ganze unter MANIFEST.MF abspeichern. Die Bedeutung der Parametern erläutere ich später, aber ich denke die Hälfte könnt ihr auch so erraten. Damit können wir schon die JAR-Datei erstellen. Dazu führen wir die folgende Kommandosequenz aus:

oder speichern diese Sequenz in der cpje.bat Datei ab:

in der Kommandozeile sollte das rauskommen:

und in dem Programmordner sollte eine Datei namens GHelloWorld.jar auftauchen. Damit haben wir die JAR-Datei. Jetzt erstellen wir die JAD-Datei. Dazu starten wir wieder Notepad und geben folgende Parameter ein:

und speichern das unter GHelloWorld.jad. Es sind die selben Parameter, wie schon bei dem Manifest, plus zwei weitere ganz unten. Der eine Parameter gibt den Ort der JAR-Datei an. In unserem Fall müssen die JAD/JAR-Dateien zusammen liegen, aber der Ort kann auch eine Webaddresse sein. Der letzte Parameter gibt die Größe der JAR Datei an. Die Größe finden wir mit dem folgenden Befehl heraus:

wir sehen die Ausgabe:

und vor GHelloWorld.jar die Zahl 1.844. Das ist die Größe der Datei in Bytes. Diese Zahl übernehmen wir auch in die JAD-Datei, nur ohne . und , .

Jetzt haben wir ein Java Programm erstellt. Wir können auch gleich testen ob es geht. Dazu rufen wir den Series 60 Emulator auf:

oder fügen die Sequenz in unsere cpje.bat Datei ein, die jetzt fertig ist:

Wenn wir jetzt immer cpje.bat aufrufen, kompilieren wir das Programm und starten es in einem Vorgang:

und da sollte ein neues Fenster mit dem Emulator und unserem Programm auftauchen:

und wie wir sehen, es läuft. Um das Programm zu beenden, auf die rechte Pfeiltaste (die unter dem Display) klicken. Damit wird auch der Emulator beendet. Um das Programm auf das Handy zu bringen, kopiert man die JAD/JAR-Dateien per Bluetooth in den Eingang des Handys und installiert sie von dort. Ohne Bluetooth kopiert man die JAD/JAR-Dateien per Kartenleser oder USB-Kabel direkt auf die MMC. Jetzt brauchen wir noch die Symbian Anwendung FExplorer:

das ist ein Datei-Manager und er ist kostenlos. FExplorer wird wie üblich installiert und mit dem können wir auf die MMC zugreifen:

selektiert die JAR-Datei und drückt das Steuerkreuz, damit wird der Installationsvorgang ausgelöst:

Hier kann man auch gleich unsere Metadaten sehen, die wir in das Manifest eingetragen haben. Einfach auf OK oder Steuerkreuz drücken:

Hier wird man abgefragt, wohin das Java-Programm installiert werden soll, im internen Speicher oder auf der MMC. Für unser Programm ist es aber egal wo. Weiter geht es mit OK oder Steuerkreuz und schon ist die Anwendung installiert. Wir verlassen FExplorer und gehen ins Menu->Extras->Progr.. Dort finden wir auch unser Programm:

Vielleicht sollte man sich überlegen, den Namen das nächste Mal kürzer zu wählen, damit man den auch lesen kann :). Das Programm selektieren und wir können es mit dem Steuerkreuz starten und voila:

es läuft, wie im Emulator. Glückwunsch, ihr habt ein Java-Programm übersetzt und auf das Handy gebracht. Mit der rechten Pfeiltaste kann man das Programm beenden. Weil es so schön war, starten wir es gleich nochmal und nochmal und ... es ist immer ein schönes Gefühl etwas fertig gestellt zu haben :D.

Zum Abschluss dieses Teils möchte ich die JavaDoc Dokumentation ansprechen. Das sind die Dokumentationen der Schnittstellen zum API des System. Was das genau ist, liest ihr besser in einem Buch nach. Programmierer die Java kennen, wissen dass ohne die JavaDocs man nicht leben kann. Deshalb möchte ich auf die JavaDocs des Nokia SDK's verweisen, die ihr unter:

findet. Dort seht ihr z.B. Ordner wie MIDP1.0_API oder Nokia_UI_API. Das sind die JavaDocs zu den einzelnen API's, die man mit Series 60 nutzen kann. Die JavaDocs sind in HTML gehalten und in jedem Ordner gibt es eine Datei "index.html". In MIDP1.0_API liegen die Beschreibungen der javax.microedition.lcdui.* und javax.microedition.midlet.* Klassen, die haben wir in unserem "Hello World!" Programm verwendet. Hier könnte man z.B. nachsehen, was für Funktionen die Klasse javax.microedition.lcdui.Graphics hat und was z.B. "drawString" macht. In Nokia_UI_API werden die Schnittstellen zu den Nokia UI Elementen beschrieben, von dort haben wir z.B. die com.nokia.mid.ui.FullCanvas Klasse verwendet.

Jetzt solltet ihr wissen, wie alle Tools installiert und konfiguriert werden. Desweiteren sollte der Weg eines Programms von dem Quelltext auf das Handy bekannt sein. Wenn noch nicht alles bei euch klappen sollte, keine Panik, bei mir klappte es auch nicht sofort. Alles in Ruhe nochmal durchgehen und sich vergewissern, dass nichts vergessen wurde. Falls ihr kleine Probleme habt, dann hilft euch vielleich Google Groups:

Einfach die richtigen Wörter eintippen und vielleicht findet ihr die Lösung des Problems.