Tags:    java Denne gang vil vi kigge på et lidt mere avanceret eksempel, samt snakke lidt omkring GUI's (Graphical User Interfaces) med J2ME, da det naturligvis er en vigtig del! Denne artikel forudsætter at du har læst 1. del og prøvet de ting den artikel beskriver.

Lidt om GUI's

Man kunne måske forestille sig at det var rigtig besværligt at lave et simpelt GUI på en mobiltelefon: Ikke to telefoner er ens – de er nærmest allesammen forskellige på alle punkter! Nogen har farveskærm, andre har ikke. Nogen har brede skærme, andre har høje skærme, og nogen har endda bare små skærme. Derudover skal man også huske på at de ikke allesammen har den samme slags knapper – de har ikke engang nødvendigvis lige mange . Men faktisk er det intet problem med J2ME! Din GUI bliver automatisk tilpasset til den rigtige størrelse osv. Har du fx 3 commands tilføjet, men telefonen kun har 2 knapper til at udføre funktioner, så sørger implementationen automatisk for at oprette en menu og putte dine commands ind i den i stedet. Der er masser af eksempler på at J2ME implementationen står for en masse ting, så du ikke skal bekymre dig for det. Det betyder så på den anden side også at der er ting du ikke kan bestemme, eller som du i hvert fald ikke kan være sikker på sker! Man snakker derfor også om to strategier når man designer GUI's til J2ME:

Abstraktion ("Abstraction"), hvor alt er så abstrakt at det passer ind over alt. Her specificerer man ikke så meget selv, men overlader til implementationen at bestemme hvordan ting skal se ud. Du skriver fx ikke at brugeren skal klikke på knap nummer 2 for at komme videre, men beder i stedet brugeren om at klikke på "Næste" – husk at den enhed som brugeren kører dit program på måske ikke har en knap nummer 2 – måske har den ikke engang knapper, men er touchscreen-baseret eller lignende.

Opdagelse ("Discovery"), hvor ens applikation lærer om den enhed den bliver kørt på, og tilpasser sit udseende efter det. Et eksempel kunne være at aflæse bredden på skærmen, og derefter tilpasse sine GUI kontroller efter det.

De fleste vælger den første strategi, ikke mindst fordi det er klart lettest og kræver mindst kode. Der er dog en undtagelse, nemlig hvis man koder spil. Her er det at foretrække at tilpasse MIDlet'en efter den enhed den kører på. Der kan endda være tilfælde hvor man vælger at compile og distribuere forskellige versioner til forskellige telefoner – dette ødelægger dog lidt det smarte princip i Java's platformuafhængighed, men man kan jo ikke få det hele

Hvad skal vi bruge?

Læg mærke til en af de pakker vi importerer, nemlig javax.microedition.lcdui. LCDUI står for Liquid Crystal Display User Interface, og er med andre ord den pakke der sørger for at vi kan vise ting på vores lille skærm. I den finder du Displayable klassen, der et eller andet sted er det primære når vi arbejder med GUI's. Du kommer dog ikke direkte i kontakt med den, men Screen nedarver fra den, og fra den nedarver Alert, List, Form og TextBox – nu har vi pludselig fat i noget vi har hørt om før, fx Form. Vi har også javax.microedition.lcdui.Item, hvor fx TextField, StringItem og mange flere nedarver fra. Det er disse pakker vi baserer vores GUI's på! Det er derfor også nu det er en god ide at kigge på dokumentationen til WTK'et, hvis du ikke allerede har gjort det. Der medfølger API dokumentation, der kan lære dig en hel masse om de forskellige kontroller og klasser. Har du installeret WTK'et der hvor det selv foreslår det, skal du kigge i C:\\WTK21\\docs\\api\\midp. Åbn index.html, og kig dig lidt omkring. Væn dig til at bruge det, for det er et virkeligt godt sted at kigge når du kommer i tvivl om noget!

Men som sagt vil jeg vise jer et lidt mere avanceret eksempel, hvor vi bruger nogle af de ting jeg har fortalt lidt om. Jeg synes det kunne være sjovt at lave en meget simpel "regnemaskine" – navnet er nok lidt overvurderet, for der er egentlig bare tale om to tekstfelter hvor der kan skrives et tal i hver. Når man vælger "Beregn", lægges de to tal sammen og resultatet vises. Det er et simpelt, men også ganske skægt eksempel . Det viser lidt forskelligt!

import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;

public class SimpelCalc
	extends MIDlet
	implements CommandListener
{
	private Form mainForm;
	private TextField txtTal1, txtTal2;
	private StringItem resultat;
	private Command afslut, beregn;


	public SimpelCalc()
	{
		mainForm = new Form("En lille regnemaskine!");
		
		txtTal1 = new TextField("Tal 1", "", 10, TextField.NUMERIC);
		mainForm.append(txtTal1);

		txtTal2 = new TextField("Tal 2", "", 10, TextField.NUMERIC);
		mainForm.append(txtTal2);

		resultat = new StringItem("Resultat:", "");
		mainForm.append(resultat);

		afslut = new Command("Afslut", Command.SCREEN, 1);
		mainForm.addCommand(afslut);

		beregn = new Command("Beregn", Command.SCREEN, 0);
		mainForm.addCommand(beregn);

		mainForm.setCommandListener(this);
	}

	public void startApp()
	{
		Display.getDisplay(this).setCurrent(mainForm);
	}

	public void commandAction(Command c, Displayable s) 
	{
		if(c == afslut)
			notifyDestroyed();
		if(c == beregn)
		{
			resultat.setText(""+(Integer.parseInt(txtTal1.getString()) + Integer.parseInt(txtTal2.getString())));
		}
	}

	public void pauseApp() { }

	public void destroyApp(boolean unconditional) { }

}

Forklaring og afslutning

Forhåbentligt genkender du en del fra sidste gang. Er der noget du er i tvivl om, kan det nok anbefales at læse forrige artikel igen . Men hvad er så nyt i dette eksempel? For det første bruger vi nogle nye kontroller, nemlig de to TextField's. De kan, ikke overraskende, modtage en eller anden form for tekst. I dette tilfælde sætter vi en constraint på, der siger at vores TextField's kun godtager tal (NUMERIC). Der er en langt række andre constraints man kan sætte, men dem kan du læse om i API dokumentationen som jeg nævte før – klik blot på TextField i menuen til venstre . Der kan du også læse hvilke værdier det er vi bruger når vi opretter vores TextFields, men for lige at sige det kort: En tekst værdi der vil stå foran tekst feltet (kaldet en label), der beskriver indholdet. Derefter en eventuel tekst der skal stå som standard i feltet – vi sender en tom streng med, og derefter en max længde på feltet, og så den constraint jeg nævnte før. Derudover vi et StringItem, som vi efterlader tomt – vi sætter nemlig værdien senere. Til sidst gør vi noget af det samme som i første eksempel, nemlig at oprette commands! Vi gør det dog på en lidt anden måde, for denne gang vil vi nemlig gerne huske vores commands. Derfor deklarerer vi dem først, og opretter dem bagefter. På den måde kan vi nu referere til dem i vores commandAction() metode, og dermed også tjekke hvilken kommando der er kaldt – smart! Hvad der sker i vores commandAction() burde være let at gennemskue, så det vil jeg ikke forklare nærmere.

Du burde nu have en bedre forståelse for det at skabe et GUI med J2ME. Der er stadig masser af muligheder, men kig i API'et! Her kan du se alle de ting du kan bruge, samt hvordan du bruger dem. Klik på "Screen" og "Item", og kig under " Direct Known Subclasses" – det er de ting du kan bruge i dine programmer.

Det var alt hvad jeg kunne finde på at vise denne gang. Håber i kunne bruge det

Hvad synes du om denne artikel? Giv din mening til kende ved at stemme via pilene til venstre og/eller lægge en kommentar herunder.

Del også gerne artiklen med dine Facebook venner:  

Karma barometer (30 dage)

IT jobs | Kontakt | Om Udvikleren.dk | Om karma | IT nyheds arkiv | Annoncering

X