MIDP
Som vi så i den første artikel om Java 2 Mobile Edition (J2ME) er der tale om en væsentlig mere kompliceret arkitektur end J2SE- og J2EE-platformene. Det skyldes, at det ikke er muligt at definere en fælles platform for de mobile enheder, da variationerne paradoksalt nok er langt større end hvad der gælder skrivebords- og servermiljøerne.
Java Community Process, som er den brancheorganisation, der varetager udviklingen af Java-platformen, løser dette problem ved at opdele J2ME i en række moduler, som adresserer forskelle i enhedernes evner og anvendelser.
Som gennemgået i sidste artikel består første lag i platformen af (indtil videre) to såkaldte konfigurationer, som groft sagt deler enhederne op efter deres hardware-mæssige formåen.
I næste lag, oven på konfigurationerne, findes profiler, som underdeler konfigurationerne i bestemte typer af anvendelser. Men der findes beslægtede profiler inden for begge konfigurationer. Lommmecomputere og mobiltelefoner er repræsenteret både i den lette konfiguration CLDC (Connected Limited Device Configuration) og den tykke konfiguration CDC (Connected Device Configuration).
De fleste profiler er endnu under udarbejdelse af Java Community Process, men profilen Mobile Information Device Profile (MIDP) er en færdig specifikation, som er rettet imod mobile informationsenheder. Det dækker over mobiltelefoner og lette lommecomputere.
MIDP adresserer områder som brugerflade, lagring, netværkstilgang og applikationernes livscyklus. MIDP er implementeret i en række enheder og styresystemer, og et MIDP-program kaldes en MIDlet.
Værktøjerne
Værktøjerne
Mobil udvikling udføres nemmest ved hjælp af emulatorer. En emulator er et stykke pc-software, som opfører sig lige som den enhed, man udvikler til. På den måde slipper man for at skulle overføre koden til enheden, hver eneste gang man skal teste en lille ændring eller debugge.
Mange producenter af mobilenheder og lommecomputere fremstiller emulatorer til udviklingsbrug, og de er som oftest helt identiske med deres modpart i den fysiske verden. Med andre ord kan man være temmelig sikker på, at applikationerne opfører sig på samme måde som i emulatoren.
Sun tilbyder en række gratis værktøjer til udvikling af J2ME-applikationer. Java 2 Platform Micro Edition Wireless Toolkit er en pakke med forskellige værktøjer, herunder en række generiske emulatorer, samt en række rigtige emulatorer, blandt andet til en Motorola i85s-telefon.
Det er også nemt at benytte J2ME Wireless Toolkit med en Palm-emulator, men for at kunne benytte Palms emulator kræves der et ROM-billede, som er en kopi af Palms styresystem. Sådan en kan man overføre fra sin egen Palm-lommecomputer, eller man kan registrere sig som udvikler på Palms website.
Den sidste mulighed er dog ganske ufatteligt omstændig, så det bedste bud er at skaffe sig en fysisk Palm. Det er en helt uskadelig operation at overføre ROM'en, så man kan trygt låne en kollegas lommecomputer, uden at være bange for at det går ud over enheden eller data.
Selve ROM-billedet overføres simpelt via emulatoren, som downloades fra Palms website.
Emulatoren ligner faktisk en Palm til forveksling, og det er muligt at skifte skin, således at oplevelsen bliver ganske virkelighedsnær. De funktioner, som berører selve emulatoren kan tilgås via en menu, som kommer frem ved at højreklikke på emulatoren.
KToolbar
Men tilbage til J2ME Wireless Toolkit. Værktøjssættet består af en række småprogrammer, og i Windows-versionen befinder de sig i Start-menuen. Det vigtigste værktøj er KToolbar, som kan kompilere, køre og debugge MIDlet-applikationerne.
Når Toolkittet installeres, skal man lige lægge mærke til hvilken mappe, man installerer værktøjerne i, for disse mappers placering har betydning for, hvor vores hjemmelavede kode senere skal placeres. Men det vender vi tilbage til.
KToolbar er et grafisk program til at kompilere og teste J2ME-applikationer med. Til at starte med kan man prøve at afvikle nogle af de demo-applikationer, som følger med Toolkittet. Først vælger man en enhed fra dropdown-boksen med titlen Device. Her i eksemplet vælger vi Motorola_i85s. Klik på knappen Open Project, og vælg "demos" fra den fremkomne dialogboks.
KToolbar
Nu klikkes der ganske simpelt på knappen "Run" og voila, så loades applikationen ind i Motorola-emulateren. Sværere er det faktisk ikke. For at få lidt føling med miljøet og emulatorerne kan man eksperimentere med de øvrige emulatorer og eksempler. Hvis man benytter Palm-emulatoren, skal man første gang browse sig frem til den mappe, hvor emulatoren befinder sig i.
Men der er ingen vej udenom: Vi skal nu skabe den berømte Hallo Verden-applikation i en J2ME-udgave, og derved finder vi ud af, hvorledes sådan en karl ser ud, og hvordan vi får kompileret koden og smidt det færdige resultat ind i emulatorerne.
Her benytter vi jo CLCD-profilen MIDP, og MIDP-applikationer, MIDlets, skrives ved at nedarve klassen javax.microedition.midlet.MIDlet. Derudover skal vi benytte en række klasser fra API'et javax.microedition.lcdui, der som navnet siger giver os brugerfladekomponenter (ui) til brug på LCD-skærme.
Vi vil ikke gå i detaljer med kodens virkemåde, med metodernes navne er så sigende, at man forhåbentlig kan gætte sig til virkemåden bag. Sidst i denne artikel er der links til ressourcer på nettet, hvor der er mere information om basal MIDlet-udvikling.
Koden
Grundlæggende set er en MIDlet bygget op på en måde, som for eksempel kendes fra applets. Tre metoder skal defineres: startApp(), som starter applikationen, pauseApp() som håndterer en pause-tilstand, hvis nærmere beskaffenhed afgøres af den konkrete enhed, og stopApp(), som håndterer tilstanden hvor MIDlet'en stoppes.
import javax.microedition.midlet.MIDlet;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
public class HejVerden extends MIDlet implements CommandListener {
private Form form;
public HejVerden() {
// Her skaber vi en Form, som repræsenterer brugerfladen
form = new Form("Test MIDlet");
// Så skriver vi på vores Form:
form.append("PC World Online siger goddaw!!");
// Og indsætter en kontrol, som brugeren kan afslutte app'en med:
form.addCommand( new Command( "Afslut", Command.EXIT, 1 ) );
// Vores HejVerden-instans skal registeres som
// en listener til formens kontroller:
form.setCommandListener( this );
}
public void startApp() {
// Her skal vi have en reference til enhedens display, som vi
// så planter vores form på:
Display display = Display.getDisplay(this);
display.setCurrent( form );
}
// Vi har ingen specielle ønsker om hvad der skal ske når app'en pauses:
public void pauseApp() { }
// Når app'en slutter, fjerner vi vores form:
public void destroyApp(boolean unconditional) {
form = null;
}
// Her håndterer vi vores kontrol ("Afslut")
// Der er kun én kontrol på vores form, så vi ved hvad der skal ske:
public void commandAction(Command c, Displayable d) {
// Destruer denne MIDlet
destroyApp(true);
// Her giver vi enhedens JVM besked om, at vi er døde:
notifyDestroyed();
}
}
- og længere er den ikke, heldigvis. Nu skal vi se det ske, og det er faktisk ret nemt med KToolbar.
Portabel kode - eller ej
Åbn KToolbar, og klik på knappen "New Project". I dialogen, som kommer frem, skriver vi:
- og klikker på "Create project". Endnu en dialog viser forskellige oplysninger, og vi klikker OK.
Nu står der følgende meddelelse i KToolbars konsolvindue:
Creating project "MinMidlet"
Place Java source files in "F:\Programmer\Win2000\J2ME\apps\MinMidlet\src"
Place Application resource files in "F:\Programmer\Win2000\J2ME\apps\MinMidlet\res"
Place Application library files in "F:\Programmer\Win2000\J2ME\apps\MinMidlet\lib"
- og det er jo lige til at forstå. Så vi kopierer koden fra før over i en tekstfil, og gemmer tekstfilen som HejVerden.java i mappen F:\Programmer\Win2000\J2ME\apps\MinMidlet\src . Så klikker vi på knappen Build for at kompilere, og forhåbentlig får vi ingen fejlmeddelelser:
Project settings savedBuilding "MinMidlet"Build complete
Og så kan denne ydmyge MIDlet testes i emulatorerne, ved at vælge en emulator i dropdown-boksen og klikke på "Run". I Motorola- og Palm-emulatoren ser det sådan ud:
I Palm-versionen er Afslut-kommandoen implementeret som en menu, der fremkommer, når man klikker øverst på displayet.
En MIDlet prøver (som det måske fremgår af eksemplet) at oversætte nogle generaliserede tilstande, som enhederne kan komme i, ved hjælp af metoder, som er ret abstrakte i forhold til hvorledes enhederne er skruet sammen, specielt i forhold til ind- og uddata-mekanismer.
Ideen er, som altid i Java, at kunne programmere kode som er mindre afhængig af den specifikke kontekst, med hensyn til hardware og underliggende styresystem, end hvis man udviklede til en specifik enhed eller styresystem.
Problemet er, som tidligere nævnt, at forskellene på enhederne er langt større end de forskelle, som der findes i skrivebords-computere eller serversystemer, og det gør løftet om at skrive portabel kode lidt mere tvivlsom i J2ME-verdenen end i de andre miljøer.
Udvikleren er nok bedst tjent med at vælge en pragmatisk strategi, og frem for alt prøve at indsnævre mængden af enheder, som man vælger at udvikle til. En lommecomputer er trods alt væsentligt anderledes end en mobiltelefon med et tre-liniers display, og denne forhindring kan generaliseret kode nok ikke overkomme.
Når det er sagt, så er der trods alt en hel del, som den fælles base i en profil som MIDP kan løse. Herunder findes den rudimæntere forretningslogik, som enhederne kan håndtere, og datatransportmekanismen, som man slipper for at skulle konstruere for hver ny enhed, og andre forhold, som for eksempel lagring af data på enhederne.
Med andre ord kan man nok ikke forvente, at koden er fuldstændig portabel i en praktisk forstand, men mindre kan jo også gøre det.
Læs mere
En udmærket introduktion til MIDlets kan læses på Suns website. En oversigt over emulatorer og enheds-specifikke værktøjer kan findes på Sun-programmøren Bill Days website. Sitet Microjava beskæftiger sig udelukkende med J2ME.
