Vysoká škola ekonomická v Praze Fakulta informatiky a statistiky Katedra informačních technologií
Student
: Ondřej Dušek
Vedoucí bakalářské práce
: Ing. Rudolf Pecinovský, CSc.
Recenzent bakalářské práce
: Lucie Bittnerová
TÉMA BAKALÁŘSKÉ PRÁCE
Možnosti využití platformy Java ME ve vstupních kurzech programování
ROK : 2008
Prohlášení
Prohlašuji, že jsem bakalářskou práci zpracoval samostatně a že jsem uvedl všechny použité prameny a literaturu, ze kterých jsem čerpal.
V Praze dne 30.6.2008
.......................................................... podpis
Poděkování
Děkuji vedoucímu práce za podnětné rady a připomínky při psaní této práce i za zapůjčené materiály k nastudování související problematiky.
Abstrakt – česky Cílem této práce je implementovat výukovou knihovnu Tvary pro kreslení a jednoduchou animaci tvarů. Součástí je také ukázka použití zmíněné knihovny na aplikaci, která simuluje provoz ve městě. Teoretická pasáž je zaměřena na charakteristiku platformy Java ME, její odlišnosti od populární Java SE a některé nové vlastnosti. Další část je věnována popisu samotné implementace zmíněné knihovny a zejména odlišnostem, které změna platformy přinesla. V závěru kapitoly je uveden návod, jak připravit aplikaci využívající této knihovny do fáze, kdy bude spustitelná na mobilním zařízení.
Abstrakt – anglicky The main goal of this thesis is to implement learning library Shapes for shapes drawing and simple animation. Part of the thesis is also a sample application, which shows usage on a traffic simulation in a town. The theoretical passage is focused on the Java ME platform characteristics, its differences from the popular Java SE and some new features. The next part is devoted to the description of the implementation process of the mentioned library and especially to distinguish the differences that have been caused by the platform switch. In conclusion of the chapter there is a user guide describing how to make an application based on this library ready to work on any mobile device.
Obsah 1 Úvod..................................................................................................................................................1 2 Java Platform, Micro Edition (Java ME)...........................................................................................2 2.1 Konfigurace...............................................................................................................................2 2.1.1 Connected Limited Device Configuration (CLDC)...........................................................2 2.1.2 Connected Device Configuration (CDC)...........................................................................4 2.2 Profily........................................................................................................................................4 2.2.1 Mobile Information Device Profile (MIDP)......................................................................4 2.2.2 Information Module Profile (IMP)....................................................................................6 2.2.3 Foundation Profile..............................................................................................................6 2.2.4 Personal Basis Profile........................................................................................................6 2.2.5 Personal Profile..................................................................................................................6 2.3 Rozšiřující balíčky.....................................................................................................................7 3 Programování v CLDC a MIDP........................................................................................................8 3.1 Generic Connection Framework (GCF)....................................................................................8 3.1.1 Streamové sockety.............................................................................................................9 3.1.2 Datagramové sockety.......................................................................................................10 3.2 MIDlet......................................................................................................................................11 3.2.1 Aktivní stav......................................................................................................................11 3.2.2 Pozastavený stav..............................................................................................................11 3.2.3 Ukončený stav..................................................................................................................11 3.2.4 Sada midletů.....................................................................................................................13 3.2.5 Distribuce midletů............................................................................................................13 3.3 Uživatelské rozhraní................................................................................................................16 3.3.1 Vysokoúrovňový přístup..................................................................................................17 3.3.2 Nízkoúrovňový přístup....................................................................................................20 3.4 Record Management System (RMS).......................................................................................25 4 Knihovna Tvary...............................................................................................................................29 4.1 Implementace...........................................................................................................................30 4.1.1 Třída CanvasManager......................................................................................................30 4.1.2 Třída Painter.....................................................................................................................32 4.1.3 Třída Direction8...............................................................................................................33
4.1.4 Třída NamedColor...........................................................................................................33 4.1.5 Třída Multimover.............................................................................................................33 4.1.6 Třída Picture.....................................................................................................................34 4.1.7 Třída Text.........................................................................................................................34 4.2 Tvorba aplikací používajících knihovnu Tvary.......................................................................35 4.2.1 Vytvoření projektu............................................................................................................35 4.2.2 Vytvoření aplikace............................................................................................................36 4.2.3 Spuštění aplikace a tvorba JAR archivu..........................................................................37 4.2.4 Nastavení kódování..........................................................................................................38 5 Závěr................................................................................................................................................39
1 Úvod V uplynulém desetiletí jsem byl svědkem velkého rozmachu mobilních zařízení, jako jsou GPS navigace, elektronické diáře a v neposlední řadě i mobilní telefony. Z počátku se jednalo o přísně jednoúčelové přístroje, jejichž dostupnost byla díky vysoké ceně značně omezená. Avšak silná konkurence přála rychlému technologickému vývoji v této oblasti a nyní jsou zmíněná mobilní zařízení univerzální natolik, že jejich funkce mnohdy splývají a přijatelná cena je dělá dostupnými pro naprostou většinu obyvatelstva. Vývoj nativních programů pro tato zařízení je díky velkému množství výrobců velmi obtížný. Logickým krokem je proto abstraktní vrstvou odstínit některé odlišnosti a zavést jednotný programovací jazyk. Přesně to dělá v dnešní době široce podporovaná platforma Java ME. Tato práce si klade za cíl implementaci výukové knihovny pro kreslení a jednoduchou animaci tvarů na tuto platformu, jež umožní snadnou přenositelnost programů bez hlubších znalostí prostředí Java ME. Součástí je i teoretický základ, jenž seznámí čtenáře s možnostmi zmíněné platformy a jejími odlišnostmi oproti známější edici určené osobním počítačům. Zvolené téma jsem vybral, protože je mi programovací jazyk Java blízký zejména platformní nezávislostí, velkým rozšířením a snadnou čitelností. Doposud jsem se setkával pouze s platformou Java SE a tato práce pro mě byla motivací seznámit se s možnostmi programování pro mobilní zařízení. Teoretická a i praktická část práce předpokládá, že čtenář je obeznámen s vývojem programů na platformě Java SE a rozumí všem základním pojmům, vztahujícím se k objektově orientovanému programování v jazyce Java.
1
2 Java Platform, Micro Edition (Java ME) Platforma programovacího jazyka Java je dostupná v několika edicích. Pro osobní počítače je určená standardní edice Java SE, pro vývoj serverových aplikací Java EE a pro mobilní zařízení s omezenými zdroji právě Java ME. Na rozdíl od osobních počítačů a serverů jsou však rozdíly mezi jednotlivými typy mobilních zařízení výrazně větší, a to jak ve výkonu, dostupné paměti, tak i z hlediska uživatelského vstupu a výstupu. Z tohoto důvodu Java ME definuje soubor specifikací různých pro lišící se podmnožiny mobilních zařízení, takzvané konfigurace a profily. Podpora prostředí Javy pro jedno konkrétní zařízení je pak dána právě konfigurací a podporovanými profily. Podporu některých specifických funkcí dále přidávají rozšiřující balíčky.
2.1
Konfigurace
Konfigurace určuje softwarové prostředí pro podmnožinu mobilních zařízení s danou minimální hardwarovou výbavou. Zpravidla jsou kladeny požadavky na typ i frekvenci procesoru, paměti a síťové připojení. V současné době jsou k dispozici konfigurace Connected Limited Device Configuration (CLDC) a Connected Device Configuration (CDC). 2.1.1
Connected Limited Device Configuration (CLDC)
Označení Connected Limited Device Configuration lze vysvětlit jako konfigurace zařízení s omezenými zdroji, jež je připojeno k síti. Takovou konfiguraci specifikace [9] definuje následovně: ●
160 až 512 kilobajtů paměti pro platformu Java
●
16bitový nebo 32bitový procesor
●
malá spotřeba energie, obvykle napájeno z baterie
●
připojení k síti s limitovanou šířkou pásma
Tyto požadavky splňují převážně malá zařízení jako jsou mobilní telefony či některé diáře. Specifikace nevyžaduje display ani zařízení uživatelského vstupu, to řeší až rozšiřující profil, stejně jako paměť pro trvalé uchování dat aplikací. Proto mohou CLDC využít i zařízení bez obrazovky, jejichž výstupem je například sada diod. Na hostitelský systém nejsou kladeny žádné specifické požadavky, implementaci virtuálního stroje provádí výrobci zařízení podle specifikace a referenční implementace. Nepodporuje-li systém vícevláknové prostředí, musí ho virtuální stroj simulovat.
2
V současné době je k dispozici CLDC 1.0 a jeho revize CLDC 1.1. Liší se množinou podporovaných funkcí a požadavky na paměť cílového zařízení. Konfigurace CLDC 1.0 vychází z Java SE verze 1.3 a s ní sdílí shodnou syntaxi zápisu. Obsahuje třídy nebo jejich část, které jsou převzaté právě z této platformy. Kromě toho přidává nový balíček javax.microedition.io pro podporu síťového připojení. Seznam vlastností podle referenční příručky [15], jejichž podpora nebyla do CLDC 1.0 zahrnuta, je následující: ●
Vlastnosti třídy Object ○
finalizace
○
klonování
●
Slabá reference (weak reference)
●
Čísla s podporou plovoucí desetinné čárky ○
datové typy double a float
○
obalové třídy Double a Float
●
Rozhraní Comparable
●
Většina metod pro podporu reflexe
●
Rozhraní nativních podprogramů (JNI)
●
Vlastnosti vláken ○
Skupiny vláken ThreadGroup
○
Vlákna neblokující ukončení programu (daemon thread)
○
Přerušení vlákna voláním metody interrupt()
○
Názvy vláken
●
Některé chybové třídy, zařízení se zotavují specificky (například resetem)
●
Některé kolekce, dostupné jsou pouze třídy Vector, Stack a Hashtable
●
Některé funkce data a času ○
Třída Calendar slouží pouze ke zjišťování jednotlivých složek data a času
○
Třída TimeZone podporuje pouze časové pásmo GMT, ostatní jsou volitelná
3
●
Třídy vstupních a výstupních proudů v balíčku java.io, kromě proudů pro pole bajtů
Revize CLDC 1.1 je určená pro novější zařízení s větší kapacitou dostupné paměti. Podle specifikace [12] přidává oproti CLDC 1.0 následující vlastnosti: ●
Podpora čísel s plovoucí desetinnou čárkou
●
Slabá reference (weak reference)
●
Třídy Calendar, Date a TimeZone jsou blíže svým protějškům z Java SE
●
Určuje ošetření chybových stavů, možné jsou dva způsoby
●
2.1.2
○
Zastavení virtuálního stroje
○
Vyhození chyby
Vlastnosti vláken ○
Možnost určit název stejně jako v Java SE
○
Přerušení vlákna voláním metody interrupt()
Connected Device Configuration (CDC)
CDC je konfigurace určená pro výkonnější zařízení, jako jsou některé osobní diáře, set-top boxy apod. Typické vlastnosti těchto zařízení jsou podle technologického přehledu CDC [7]: ●
2 megabajty operační paměti
●
2,5 megabajtů paměti pro čtení
●
32bitový procesor
Oproti CLDC neobsahuje CDC žádná omezení vyplývající z nedostatečného výkonu nebo paměťové kapacity cílových zařízení. Nejnovější CDC 1.1 vychází z Java SE verze 1.4.
2.2
Profily
Profil doplňuje konfiguraci o další funkcionalitu specifickou pro určitou skupinu zařízení. Zpravidla přidává třídy pro práci s uživatelským vstupem, zobrazovacím zařízením, lokálním úložištěm dat, apod. 2.2.1
Mobile Information Device Profile (MIDP)
MIDP je rozšiřující profil pro konfiguraci CLDC. Přidává podporu nových funkcí typických 4
pro mobilní telefony a diáře. Taková zařízení musí mít display s přibližně čtvercovými body s minimálním rozlišením 96x54 bodů a barevnou hloubkou 1 bit na pixel. Dále je vyžadována klávesnice mobilního telefonu typu ITU-T nebo klasická QWERTY klávesnice a volitelně může zařízení disponovat dotykovou obrazovkou. Potřeba je i paměť pro trvalé ukládání dat aplikací. Hostitelský systém musí umožnit virtuálnímu stroji číst i zapisovat do této paměti a komunikovat prostřednictvím bezdrátové sítě. Kromě toho je požadován mechanismus poskytující časovou základnu k označování záznamů datového úložiště a pro podporu časovačů (třída Timer), bitově mapovaný přístup k obrazovce zařízení a zachytávání událostí uživatelského vstupu. MIDP přináší třídy pro podporu následujících vlastností (podrobněji viz kapitola 3): ●
Zobrazování výstupu na displayi
●
Zpracování událostí uživatelského vstupu z klávesnice nebo dotykové obrazovky
●
Řízení běhu programu pomocí tzv. midletů
●
Trvalé ukládání dat aplikací
V současné době je k dispozici verze MIDP 1.0 a 2.0, připravuje se 3.0. Ve verzi 2.0 jsou navíc některé nové vlastnosti: ●
Podpora zvuku
●
Nový bezpečnostní model
●
Vylepšené uživatelské rozhraní
●
Herní rozhraní pro snazší vývoj her založené na vrstvách
●
Šifrovaná komunikace protokolem HTTPS
●
Automatické spouštění midletů
V připravované verzi 3.0 se podle shrnutí odborného článku [1] počítá s následujícími novinkami: ●
Minimální velikost displaye 176x220 bodů a barevná hloubka 16 bitů
●
Podpora konfigurace CLDC i CDC
●
Více podporovaných formátů multimediálních souborů (například JPG)
●
Koncept sdílení knihoven mezi midlety, tzv. liblety
●
Více spuštěných midletů současně
●
Práva aplikací 5
●
Podpora protokolu IPv6
●
Podpora animovaných obrázků
●
Podpora více displayů
●
Vlastní fonty písma
●
Přizpůsobení uživatelského rozhraní
●
Zahrnutí balíčku Mobile Media API pro práci s multimédii
2.2.2
Information Module Profile (IMP)
IMP je poslední z uvedených profilů rozšiřujících konfiguraci CLDC. Dle specifikace [13] je určen pro zařízení, jejichž možnosti uživatelského rozhraní nejsou dostatečné pro běh MIDP (například síťové karty, routery, automaty). Obsahuje podmnožinu tříd převzatou z profilu MIDP 1.0: ●
Řízení aplikace (pomocí midletů)
●
Trvalé úložiště dat
●
Podpora sítě
●
Podpora časovačů
2.2.3
Foundation Profile
Foundation Profile je základní profil rozšiřující konfiguraci CDC. Přidává třídy pro podporu síťového přístupu a vstupně-výstupních operací. V kombinaci s CDC poskytuje téměř kompletní nabídku tříd z Java SE, kromě balíčků grafického uživatelského rozhraní. Je určen pro zařízení jako jsou síťové tiskárny, routery, apod. 2.2.4
Personal Basis Profile
Tento profil zahrnuje Foundation Profile a k tomu přidává další funkcionalitu. Jedná se o částečnou podporu uživatelského rozhraní vytvářeného pomocí podmnožiny tříd z balíčku java.awt a možnost pracovat s tzv. xlety, což je obdoba appletů pro digitální televize a set-top boxy. 2.2.5
Personal Profile
Profil s názvem Personal Profile obsahuje veškerou funkcionalitu zmíněného Personal Basis Profile. Navíc disponuje plnou podporou uživatelského rozhraní AWT, appletů a částečnou
6
podporou komponent JavaBean. Personal Profile je poslední mezistupeň před platformou Java SE, je určen zařízením jako jsou například výkonné diáře nebo webové prohlížeče.
2.3
Rozšiřující balíčky
Rozšiřující balíčky přidávají podporu specifických funkcí, jimiž mohou některá zařízení disponovat. Balíčky jsou nezávislé a jejich podpora je nepovinná, takže cílové zařízení může podporovat jejich kombinaci podle toho, kterými funkcemi je vybaveno. Vybrané balíčky dle přehledu platformy Java ME [8] podporují následující funkce: ●
Bezdrátová technologie Bluetooth (JSR 82)
●
Integrace aplikací do hostitelského systému pro manipulaci s dokumenty na základě MIME typu nebo URL (JSR 211)
●
Práce s multimédii (JSR 135)
●
3D aplikace pomocí přístupu k rozhraní OpenGL ES (JSR 239)
●
Webové služby a jazyk XML (JSR 172)
●
Šifrovací funkce, digitální podepisování a podpora karet karet SmartCard (JSR 177)
●
Pokročilé uživatelské rozhraní a grafika (JSR 209)
●
Vzdálené volání metod RMI (JSR 66)
●
Rozhraní pro přístup k databázím JDBC (JSR 169)
●
Podpora digitálních TV tunerů (JSR 927)
7
3 Programování v CLDC a MIDP 3.1
Generic Connection Framework (GCF)
Vzhledem k limitovaným prostředkům cílových zařízení platformy Java ME je balíček tříd java.io příliš robustní. Proto byl vytvořen Generic Connection Framework, zjednodušený a univerzální balíček tříd javax.microedition.io umožnující komunikovat pomocí různých protokolů. GCF je podporován i konfigurací CLDC a profily MIDP.
Ilustrace 3.1: Hierarchie rozhraní a souvisejících tříd GCF, zdroj [3] Třída Connector slouží k vytvoření libovolného připojení pomocí volání jedné ze tří statických metod open: ●
open(String name)
●
open(String name, int mode)
●
open(String name, int mode, boolean timeouts)
Parametr name určuje schéma použitého protokolu, adresu a parametry připojení. Zadává se ve tvaru: {schéma}:[{adresa}][{parametry}]
Jednotlivé parametry připojení se zadávají ve tvaru: ;název=hodnota
8
Parametr mode zmíněné metody může nabývat hodnot konstant READ, READ_WRITE a WRITE, které určují možnosti vytvářeného spojení. Nastavení posledního parametru timeout na hodnotu true indikuje, že kód aplikace je schopný odchytávat výjimku InterruptedIOException při překročení časového limitu. Naopak hodnota false
říká, že výjimka nikdy nenastane. Nastavení true však podporu časového limitu negarantuje,
je závislá na konkrétní implementaci a použitém protokolu. Volání uvedené metody open vrací instanci třídy Connection reprezentující spojení. Ta má jedinou metodu close() sloužící k jeho uzavření po skončení práce. Takto získané spojení je nutné přetypovat na některou z dále uvedených tříd podle typu spojení. 3.1.1
Streamové sockety
Streamové (proudové) sockety se používají při vytváření trvalého spojení k cíli. Tento typ spojení garantuje, že se žádná data neztratí, ani nepřijdou ve špatném pořadí. Používá se například ve známém protokolu TCP. Streamové spojení se vytvoří zadáním schématu socket v metodě open. Výsledný parametr name metody potom může vypadat například: socket://www.seznam.cz:80
Instanci třídy Connection získanou uvedeným voláním metody open je poté třeba přetypovat na rozhraní StreamConnection. Jeho metody již poskytují přístup ke klasickým vstupním a výstupním proudům. Kromě běžného připojení ke vzdálenému cíli je možné vytvořit i serverové spojení. Server zpravidla naslouchá na nějakém portu a připojující se klienty odbavuje v nových vláknech. Takové spojení se vytvoří jednoduše neuvedením adresy v parametru volané metody open. Poté se vrácená instance Connection přetypuje na rozhraní StreamConnectionNotifier. Jeho jediná metoda acceptAndOpen()
vytváří spojení s klientem a vrací příslušný objekt StreamConnection.
Vytvoření serverového spojení lze demonstrovat na jednoduchém příkladě převzatém z referenční příručky [15]: StreamConnectionNotifier serverSocket = (StreamConnectionNotifier)Connector.open("socket://:8000"); for (;;) { // Získat další připojení final StreamConnection socket = (StreamConnection)serverSocket.acceptAndOpen();
9
}
3.1.2
// Zpracovat připojení v novém vlákně Thread t = new Thread() { public void run() { OutputStream os = null; try { os = socket.openOutputStream(); // Zde komunikovat s klientem... } catch (IOException ex) { // Zpracovat chybu } finally { if (os != null) { try { os.close(); os = null; } catch (IOException ex) { } } try { socket.close(); } catch (IOException ex) { } } } }; t.start();
Datagramové sockety
Datagramové sockety nacházejí uplatnění v síťových aplikacích, kde je preferována rychlost nebo jednoduchost oproti spolehlivosti. Data jsou přenášena v jednotlivých vzájemně nezávislých packetech, přičemž každý má svého adresáta. Mohou dorazit na přeskáčku, nebo nemusí dorazit vůbec. Tento typ spojení se používá například v protokolu UDP. Datagramové spojení se vytváří uvedením schématu datagram ve volání metody open. Výsledný parametr name této metody potom vypadá například takto: datagram://www.seznam.cz:13
Získaný objekt Connection se poté přetypuje na rozhraní DatagramConnection. Pomocí jedné z jeho metod newDatagram se vytvoří samotný objekt Datagram, který lze poté odeslat voláním send(Datagram dgram)
respektive přijmout voláním receive(Datagram dgram).
10
3.2
MIDlet
Programy spouštěné pod profily MIDP se nazývají midlety. Specifikace [11] určuje, jakým způsobem se bude běh těchto programů řídit. K tomu se používá abstraktní třída MIDlet z balíčku javax.microedition.midlet.
Po odvození spouštěcí třídy od této se musí implementovat tyto tři
metody: ●
startApp()
●
pauseApp()
●
destroyApp(boolean unconditional)
Tyto metody jsou volány při přechodu do jednoho ze tří definovaných stavů midletu. 3.2.1
Aktivní stav
Aplikace normálně běží a je zobrazena na display mobilního zařízení. Midlet se do tohoto stavu dostává těsně před voláním metody startApp(). 3.2.2
Pozastavený stav
V tomto stavu je midlet zinicializovaný, ale neběží. Měl by uvolnit používané prostředky. Tento stav nastává: ●
Po vytvoření instance třídy MIDlet voláním konstruktoru, než dojde ke spuštění (přechodu do aktivního stavu).
●
Po volání metody pauseApp() následovaném voláním notifyPaused().
●
Pokud metoda startApp() vyhodí výjimku MIDletStateChangeException.
Midlet se může pokusit dostat z tohoto stavu voláním metody resumeRequest(). Bude-li mu vyhověno, dojde k volání startApp() a následnému přechodu do aktivního stavu. 3.2.3
Ukončený stav
Midlet uvolnil všechny prostředky a je ukončený. Před přechodem do tohoto stavu se zavolá metoda destroyApp(boolean
unconditional).
Parametr unconditional určuje násilné
ukončení, kterému nejde zabránit. Je-li nastaven na hodnotu false, lze ukončení přerušit vyhozením výjimky MIDletStateChangeException. Ukončit běh programu může také programátor, zavoláním metody notifyDestroyed(). 11
Ilustrace 3.2: Stavy midletu a události volané při jejich změně, zdroj [10]
Následující příklad ukazuje, jak může vypadat midlet: import javax.microedition.midlet.MIDlet; import javax.microedition.midlet.MIDletStateChangeException; public class Příklad extends MIDlet { // první volání metody startApp() private boolean once = false; public Příklad() { super(); // inicializace programu } protected void startApp() throws MIDletStateChangeException { if (once == false) { once = true; // došlo ke spuštění aplikace
}
// kód programu } // přechod z pozastaveného stavu do aktivního
protected void pauseApp() { // přechod z aktivního do pozastaveného stavu } protected void destroyApp(boolean unconditional) throws MIDletStateChangeException { // přechod z aktivního nebo pozastaveného do ukončeného stavu }
12
}
K volání metody startApp() dochází opakovaně, proto proměnná once rozlišuje mezi spuštěním aplikace a přechodem z pozastaveného do aktivního stavu. Veškerou inicializaci aplikace, kterou je možné provést, dokud midlet není zobrazen na displayi, se doporučuje provádět v konstruktoru třídy. 3.2.4
Sada midletů
Aplikace se na mobilní zařízení distribuují komprimované v JAR archivu. V takovém archivu se ale nemusí nacházet jenom jeden midlet, může jich tam být více. Jednotlivé aplikace ve společném archivu potom sdílí prostředky, jako jsou statické třídy, instance a záznamy datového úložiště. K vzájemné synchronizaci lze použít klasických prostředků k synchronizaci vláken. 3.2.5
Distribuce midletů
Sady midletů se distribuují v Java Archivu (JAR), jenž obsahuje metadata v souboru MANIFEST.MF ve složce META-INF. Aby nebylo třeba stahovat celý archiv ke zjištění kompatibility sady s konkrétním zařízením, přikládá se k němu takzvaný deskriptor s příponou jad. Manifest i deskriptor jsou textové soubory obsahující určité vlastnosti sady midletů. Jejich popis dle specifikace [10] je uveden v následující tabulce:
13
Vlastnost
Popis
MIDlet-Name
Název sady midletů, určeno pro identifikaci konkrétní sady uživatelem.
MIDlet-Version
Verze sady ve formátu a.b.c, přičemž priorita číslic klesá zleva doprava.
MIDlet-Vendor
Poskytovatel sady
MIDlet-Icon
Název PNG souboru v archivu, jenž se zobrazí jako ikona sady.
MIDlet-Description
Popis sady
MIDlet-Info-URL
URL souboru s podrobnějším popisem. Obsah tohoto souboru se může zobrazit uživateli před instalací sady.
MIDlet-
Atributy jednotlivých midletů oddělené čárkou (název, soubor ikony, spouštěcí třída). Čísla jednotlivých midletů musí stoupat popořadě od jedničky.
MIDlet-Jar-URL
URL odkaz na archiv této sady
MIDlet-Jar-Size
MIDlet-Jar-Size
MIDlet-Data-Size
Minimální velikost požadovaného prostoru v trvalém úložišti v bajtech
MicroEdition-Profile
Profil potřebný ke spuštění aplikace
MicroEdition-Configuration
Konfigurace potřebná ke spuštění aplikace
Tabulka 1: Tabulka vlastností sady midletů K těmto vlastnostem lze také přistupovat voláním metody getAppProperty(String key) třídy MIDlet.
Specifikace [10] určuje, které z uvedených vlastností budou uvedeny v manifestu
a deskriptoru sady.
14
Vlastnost
Manifest obsahuje Deskriptor obsahuje
MIDlet-Name
povinně
povinně
MIDlet-Version
povinně
povinně
MIDlet-Vendor
povinně
povinně
MIDlet- pro každý midlet
povinně
MicroEdition-Profile
povinně
MicroEdition-Configuration
povinně
MIDlet-Description
volitelně
volitelně
MIDlet-Icon
volitelně
volitelně
MIDlet-Info-URL
volitelně
volitelně
MIDlet-Data-Size
volitelně
volitelně
MIDlet-Jar-URL
povinně
MIDlet-Jar-Size
povinně
Tabulka 2: Vlastnosti obsažené v manifestu a deskriptoru sady První tři vlastnosti musí být shodné v obou souborech, jinak se sada odmítne nainstalovat. Ostatní se mohou lišit. V takovém případě dostanou přednost hodnoty uvedené v deskriptoru. Soubor deskriptoru může vypadat jako v následujícím příkladě: MIDlet-1: Midlet,,town.Midlet MIDlet-2: Priklad,,town.Priklad MIDlet-Jar-Size: 39150 MIDlet-Jar-URL: townme.jar MIDlet-Name: townme MIDlet-Vendor: Vendor MIDlet-Version: 1.0 MicroEdition-Configuration: CLDC-1.0 MicroEdition-Profile: MIDP-1.0
15
3.3
Uživatelské rozhraní
Pro přístup k obrazovce zařízení slouží třídy z balíčku javax.microedition.lcdui. Třída Display
reprezentuje obrazovku, pro každý midlet je vytvořena právě jedna instance, získá se
voláním statické metody getDisplay(MIDlet m). Jakmile je k dispozici instance, lze použít následujících metod: ●
getCurrent()
●
setCurrent(Displayable nextDisplayable)
●
setCurrent(Alert alert, Displayable nextDisplayable)
●
callSerially(Runnable r)
●
isColor()
●
numColors()
Na displayi určitého midletu lze najednou zobrazit právě jednu virtuální obrazovku reprezentovanou rozhraním Displayable. K tomu slouží metoda setCurrent, jejíž parametrem je zvolená virtuální obrazovka. Volitelný parametr alert určuje výstrahu, jejíž zobrazení předchází (viz podkapitola o vysokoúrovňovém přístupu). Aktuálně viditelnou virtuální obrazovku lze získat voláním getCurrent. Informaci o tom, jestli má zařízení k dispozici barevný display, vrací metoda isColor.
Počet podporovaných barev respektive stupňů šedi se zjistí voláním numColors.
Události uživatelského rozhraní včetně překreslování displaye se zpracovávají postupně a má je na starosti jediné vlákno. Metoda callSerially umožňuje tomuto vláknu spustit programátorem definovaný kód. Ke spuštění dojde krátce po dokončení překreslování displaye, proto lze tuto metodu využít například ke střídání obrázků v jednoduché animaci. Virtuální obrazovky mohou obsahovat příkazy reprezentované třídou Command, přístupné pomocí funkčních kláves zařízení. Příkaz se vytvoří voláním konstruktoru: Command(String label, int commandType, int priority)
Parametr label určuje nápis zobrazený u funkční klávesy. Druhý parametr označuje sémantický význam příkazu a musí mít hodnotu jedné z konstant BACK, CANCEL, EXIT, HELP, ITEM, OK, SCREEN nebo STOP. Nijak neovlivňuje funkci příkazu, jen umožňuje zařízení zobrazit příkaz obvyklým způsobem (například volbu storno na pravé straně obrazovky, OK uprostřed, apod). Poslední parametr priority ovlivňuje umístění příkazů stejného typu. Nižší číslo znamená důležitější příkaz a přístupnější umístění. Je-li příkazů více než funkčních kláves zařízení, zobrazí se pod některou 16
z nich nabídka umožnující výběr ze zbylých příkazů. K zachytávání událostí příkazů slouží posluchač CommandListener s jedinou metodou: commandAction(Command c, Displayable d)
Parametr c je zvolený příkaz a d virtuální obrazovka, na níž je umístěn. V MIDP jsou možné dva přístupy k uživatelskému rozhraní. Vysokoúrovňový přístup reprezentovaný virtuální obrazovkou Screen a nízkoúrovňový reprezentovaný plátnem Canvas. 3.3.1
Vysokoúrovňový přístup
Tento přístup je vhodný, vyžaduje-li aplikace maximální přenositelnost. Samotné kreslení provádí konkrétní implementace, což přináší některá omezení. Aplikace nemůže přímo přistupovat k vstupnímu zařízení, ani nemá možnost určit vizuální stránku jednotlivých komponent. Výhodou tohoto přístupu je jednoduchost a přenositelnost. Vysokoúrovňový přístup využívají následující třídy odvozené od Screen: ●
Alert
●
Form
●
List
●
TextBox
Třída Alert reprezentuje virtuální obrazovku, jež zobrazí výstrahu a počká stanovený čas. Poté vrátí původní obsah displaye nebo novou zvolenou obrazovku. Výstrahou je textový řetězec volitelně doplněný obrázkem. Místo stanoveného času lze zadat konstantu FOREVER, což znamená vyčkání na interakci uživatele. Třída Form umožňuje zobrazit libovolnou kombinaci položek vytvořených odvozením od třídy Item.
O určení rozvržení ani o případné vertikální rolování se není potřeba starat, je zajištěno
aktuální implementací. Objekty se spravují prostřednictvím metod append, insert, delete, get a set. Pořadí objektů určuje pozice v seznamu formuláře. Pomocí posluchače ItemStateListener je možné zachytávat změnu stavu všech položek na formuláři. Jeho jediná metoda itemStateChanged vrací položku, jejíž stav byl změněn. K nastavení tohoto posluchače slouží metoda: setItemStateListener(ItemStateListener iListener)
Do formuláře lze umístit jednu z následujících položek odvozených od třídy Item: 17
(textový řetězec)
●
StringItem
●
ImageItem
(obrázek)
●
TextField
(textové pole)
●
DateField
(pole pro zadání data a času)
●
Gauge
●
ChoiceGroup
(měřidlo) (seznam)
Textové pole určené třídou TextField umožňuje nastavit omezení povolených znaků následující metodou: setConstraints(int constraints)
Parametry jsou určeny jednou z konstant téže třídy uvedených v následující tabulce: Konstanta
Omezení textového pole
ANY
Libovolný text
EMAILADDR
E-mailová adresa
NUMERIC
Celočíselná hodnota
PHONENUMBER
Telefonní číslo
URL
URL adresa
PASSWORD
Maskování znaků pomocí nějakého symbolu; lze kombinovat s ostatními Tabulka 3: Konstanty k omezení zadávaných znaků textového pole
Položka formuláře ChoiceGroup zobrazuje seznam volitelných elementů, které se skládají z textového popisu a obrázku. V konstruktoru třídy lze pomocí konstant určit typ skupiny. Hodnota EXCLUSIVE
povolí označit pouze jeden element, hodnota MULTIPLE umožní označit libovolně
elementů. Následující příklad ukazuje vytvoření formuláře k odeslání dotazu, kde uživatel může zvolit, zda chce komunikovat prostřednictvím telefonu nebo elektronické pošty. Podle toho se pak nastavuje omezení zadávaných znaků pro textové pole. // Jednotlivé položky ve formuláři final TextField zpráva = new TextField("Text dotazu", "", 128, TextField.ANY); final ChoiceGroup volba = new ChoiceGroup("Odpovědět na", ChoiceGroup.EXCLUSIVE, new String[] {"Telefon", "E-mail"}, null); final TextField kontakt = new TextField("Kontakt", "", 32, TextField.PHONENUMBER); // Samotný formulář
18
final Form formulář = new Form("Informace", new Item[] {zpráva, volba, kontakt}); // Příkaz k odeslání a zrušení final Command odeslat = new Command("Odeslat", Command.OK, 0); final Command zrušit = new Command("Zrušit", Command.CANCEL, 0); formulář.addCommand(odeslat); formulář.addCommand(zrušit); // Posluchač změn jednotlivých položek ve formuláři formulář.setItemStateListener(new ItemStateListener() { public void itemStateChanged(Item item) { if (item.equals(volba)) { // Vymaže pole kontakt.setString(null);
} });
// Nastaví omezení kontakt.setConstraints(volba.isSelected(0) ? TextField.PHONENUMBER : TextField.EMAILADDR);
}
// Posluchač příkazů formulář.setCommandListener(new CommandListener() { public void commandAction(Command c, Displayable d) { if (odeslat.equals(c)) { // Odeslání formuláře } else if (zrušit.equals(d)) { // Storno } } }); // Zobrazí formulář na obrazovce Display.getDisplay(this).setCurrent(formulář);
Další z virtuálních obrazovek odvozených od Screen je třída List. Chová podobně jako formulářová položka ChoiceGroup, jen seznam zobrazí přes celou obrazovku. Pomocí následujících konstant lze nastavit jeho chování: Konstanta Chování seznamu IMPLICIT
Zobrazí seznam stylem podobným kontextové nabídce, kde se aktuálně označená položka považuje za volbu uživatele.
EXCLUSIVE
Ze seznamu lze vybrat pouze jednu položku.
MULTIPLE
Je možné vybrat libovolně položek.
Tabulka 4: Konstanty k určení chování celoobrazovkového seznamu Pouze seznam prvního typu umožňuje zachytávat události při změně výběru. U ostatních dvou typů je nutné počkat, až uživatel volbu potvrdí některým z přiřazených příkazů a v nastalé události 19
posluchačem CommandListener zjistit jeho volbu. Je-li seznam nastaven konstantou IMPLICIT, každá jeho změna vyvolá událost commandAction, kde zvolený příkaz je roven konstantě SELECT_COMMAND.
Poslední celoobrazovkovou komponentou je třída TextBox. Chová se shodně s formulářovou verzí textového pole, jediný rozdíl spočívá v nemožnosti zachytávat průběžně události změn textu. TextBox
umí informovat pouze o zvolení přiřazeného příkazu použitím metod zděděných
od abstraktní třídy Displayable. 3.3.2
Nízkoúrovňový přístup
Nízkoúrovňový přístup umožňuje přímo určit barevné hodnoty jednotlivých obrazových bodů, nicméně je třeba počítat s lišícím se rozlišením a podporovaným počtem barev různých zařízení. Samotné kreslení se realizuje prostřednictvím třídy Canvas odvozené od Displayable, překrytím její abstraktní metody: paint(Graphics g)
To je také jediný způsob, jak získat objekt Graphics náležící plátnu, jenž poskytuje metody ke kreslení. Specifikace [10] zakazuje podržení tohoto objektu mimo metodu paint. Kromě kreslení na plátno je také možné kreslit do obrázku Image. Jeho metoda getGraphics poskytne příslušný objekt a s tím již lze nakládat dle potřeby. K volání zmíněné metody paint plátna dochází v případech: ●
Zobrazení plátna na display metodou setCurrent
●
Potřeby překreslit obrazovku po zmizení výstrahy Alert nebo systémového dialogu
●
Volání metody repaint
Instance třídy Canvas dále poskytuje metody getHeight, getWidth pro zjištění velikosti plátna v obrazových bodech. Překrytím hideNotify a showNotify lze získávat informaci o viditelnosti plátna, přičemž mezi voláním obou metod v uvedeném pořadí nedochází k jeho překreslování. V nízkoúrovňovém přístupu se k určení polohy vykreslovaných bodů užívá souřadnic horizontální osy X a vertikální osy Y. Počátkem je levý horní roh obrazovky. Udávané hodnoty na osách symbolizují jakousi pomyslnou mřížku mezi jednotlivými obrazovými body. To je důležité při kreslení a vyplňování tvarů objektem Graphics.
20
drawRect(0, 0, 4, 2)
fillRect(0, 0, 4, 2)
Ilustrace 3.3: Kreslení a vyplňování tvarů v MIDP, zdroj [15] Metodou translate téhož objektu je možné posunout počátek os souřadnic o zadaný počet obrazových bodů, následkem čehož bude posunutí pozice všech nově nakreslených tvarů. Parametry se určuje horizontální a vertikální vzdálenost od aktuálně nastaveného počátku. Jejich absolutní hodnoty vzhledem k bodu (0, 0) lze získat voláním getTranslateX a getTranslateY. Kreslení prostřednictvím objektu Graphics běžně ovlivňuje celou plochu plátna respektive obrázku. Nicméně je k dispozici možnost omezit ovlivněnou plochu definováním výseku, mimo který nemají kreslící metody žádný efekt. K tomu slouží následující metody: ●
setClip(int x, int y, int width, int height)
●
clipRect(int x, int y, int width, int height)
Jejich parametry určují levý horní a pravý dolní roh obdélníku výseku. První z uvedených, setClip,
nastaví výřez nezávisle na tom, co bylo doposud nastaveno. Druhá, clipRect, udělá
průnik z aktuálního výseku a nově zadaných souřadnic, takže výslednou oblast může pouze zmenšit. Výseků se využívá také v metodě repaint k překreslení zadané části plátna objektu Canvas.
Dojde k volání překryté metody paint, kde předaný objekt Graphics má nastaven určený
výřez. MIDP neobsahuje třídu Color, použitá barva pro kreslení se zadává voláním jedné z metod objektu Graphics: ●
setColor(int RGB)
●
setColor(int red, int green, int blue)
●
setGrayScale(int value)
První z uvedených očekává parametr ve formátu 0x00RRGGBB, kde RR je hodnota červené, GG zelené a BB modré složky v šestnáctkové soustavě. Parametry druhé varianty setColor jsou klasické hodnoty barevných složek RGB o velikosti 0 – 255. Průhlednost není podporována. Poslední 21
z uvedených metod nastaví barvu na některý ze stupňů šedi, vyjádřený světlostí na stupnici 0 – 255. Kromě barvy lze nastavit i typ čáry pro kreslení obrysu tvarů voláním metody setStrokeStyle. Jejím parametrem je jedna z konstant následující tabulky: Konstanta Styl čáry SOLID
Běžná plná čára
DOTTED
Přerušovaná čára
Tabulka 5: Konstanty k určení typu čáry Objektem Graphics lze kromě tvarů kreslit i obrázky a text. Odlišnost od Java SE spočívá v zadávání kotvícího bodu, k němuž se vztahují zadané souřadnice. Je určen kombinací horizontální a vertikální polohy dané konstantami v následující tabulce: Konstanta Horizontální poloha bodu LEFT
Levý okraj
HCENTER
Střed
RIGHT
Pravý okraj
Konstanta Vertikální poloha bodu TOP
Horní okraj
VCENTER
Střed
BASELINE
Účaří písma
BOTTOM
Dolní okraj
Tabulka 6: Konstanty k určení kotvícího bodu Konstanta BASELINE je určena pouze k vykreslování písma, na obrázky ji nelze použít. Stejně tak nelze pomocí VCENTER umisťovat text. Použití kotvícího bodu demonstruje následující příklad: g.translate(0, 20); g.setColor(255, 128, 0); g.fillRect(0, 0, 100, 20); g.setColor(0, 0, 0); g.drawString("některé znaky", 50, 0, Graphics.HCENTER | Graphics.BASELINE); g.drawString("účaří přesahují", 50, 20, Graphics.HCENTER | Graphics.BASELINE);
Ilustrace 3.4: Ukázka umístění textu pomocí kotvícího bodu
22
Metody pro kreslení textu užívají font písma, nastavený voláním setFont objektu Graphics. Jeho parametrem je instance třídy Font získaná voláním jedné ze statických metod téže třídy: ●
getDefaultFont()
●
getFont(int face, int style, int size)
První z uvedených vrací standardní font pro použité zařízení. Druhá ho definuje uvedením typu, řezu a velikosti písma. Nepodporuje-li použité zařízení zadaný font, vrátí alespoň podobný podporovaný. Parametry metody getFont se zadávají uvedením jedné z konstant třídy Font, jednotlivé řezy písma spolu lze kombinovat. Konstanta
Typ písma
FACE_SYSTEM
Systémové písmo
FACE_MONOSPACE
Neproporcionální písmo
FACE_PROPORTIONAL
Proporcionální písmo
Konstanta
Řez písma
STYLE_PLAIN
Obyčejné písmo
STYLE_BOLD
Tučné písmo
STYLE_ITALIC
Kurzíva
STYLE_UNDERLINED
Podtržené písmo
Konstanta
Velikost písma
SIZE_SMALL
Malé písmo
SIZE_MEDIUM
Střední písmo
SIZE_LARGE
Velké písmo
Tabulka 7: Konstanty k určení fontu písma Nízkoúrovňový přístup poskytuje možnost pracovat se vstupním zařízením. Jak je uvedeno v požadavcích MIDP, očekává se, že zařízení disponuje klávesnicí a případně dotykovou obrazovkou. Práci s klávesnicí zařízení zprostředkovává třída Canvas překrytím následujících metod: ●
keyPressed(int keyCode)
●
keyReleased(int keyCode)
●
keyRepeated(int keyCode)
První dvě události keyPressed a keyReleased vznikají při stlačení a při uvolnění klávesy. Další událost keyRepeated informuje o držení klávesy. Nemusí být podporována na všech zařízeních, její dostupnost lze ověřit voláním hasRepeatEvents. Tyto tři zmíněné události mají parametr keyCode, 23
který označuje kód stisknuté klávesy. Pokud je jeho hodnota kladná, odpovídá kódu stisknutého znaku ve sadě Unicode. Specifikace [10] garantuje přítomnost kláves daných konstantami: ●
KEY_NUM0
●
KEY_NUM6
●
KEY_NUM1
●
KEY_NUM7
●
KEY_NUM2
●
KEY_NUM8
●
KEY_NUM3
●
KEY_NUM9
●
KEY_NUM4
●
KEY_POUND
●
KEY_NUM5
●
KEY_STAR
Kromě nich však bývají na některých zařízeních k dispozici i klávesy k hraní her. Proto jsou definovány i takzvané herní akce. Jedná se o akce, které implementace virtuálního stroje automaticky namapuje na existující klávesy. Jejich konstanty jsou následující: ●
UP
●
GAME_A
●
DOWN
●
GAME_B
●
LEFT
●
GAME_C
●
RIGHT
●
GAME_D
●
FIRE
K jedné herní akci může být přiděleno i více kláves. K zjištění, jestli byla stisknuta některá z herních akcí, slouží metoda getGameAction, jejíž parametrem je kód klávesy. Pokud tento kód neodpovídá žádné akci, je vrácena nula. Naopak metoda getKeyCode převede herní akci na kód klávesy. Nicméně je třeba vzít na vědomí, že vrácená klávesa je pouze jednou z přiřazených. Kód klávesy je číslo, které uživateli aplikace pravděpodobně nic neřekne. A pokud je záporné, nelze jej ani převést na odpovídající znak. Proto metoda getKeyName s parametrem kódu klávesy vrací název zadané klávesy, který lze uživateli zobrazit na výstup. Na některých zařízeních je k dispozici i dotyková obrazovka. V takovém případě má smysl překrýt níže uvedené metody třídy Canvas: ●
pointerPressed(int x, int y)
●
pointerReleased(int x, int y)
●
pointerDragged(int x, int y)
První dvě událostí značí, že došlo ke stlačení respektive uvolnění bodu obrazovky, jehož souřadnice předávají parametry x a y. Jestli zařízení tyto události generuje, lze zjistit voláním metody 24
hasPointerEvents.
Poslední z uvedených událostí, pointerDragged, je volána opakovaně
a svědčí o posunu stisknutého bodu. Metodou hasPointerMotionEvents se zjišťuje její dostupnost.
3.4
Record Management System (RMS)
Možnosti trvalého ukládání dat jsou velmi různorodé vzhledem k diferenciaci cílových zařízení. Některá disponují souborovým systémem běžně užívaným v oblasti stolních počítačů, jiná mají k dispozici pouze omezenou paměť v řádu desítek až stovek kilobajtů a vytváření souborů nemusí umožňovat. Proto specifikace [10] definuje novou vrstvu pro přístup k paměti, zvanou Record Management System. Třídy pro práci s ní obsahuje balíček javax.microedition.rms. Logickou strukturu tvoří úložiště záznamů, které jsou identifikovány jejich názvy – textovými řetězci. V daném úložišti se nacházejí jednotlivé záznamy tvořené polem bajtů, určené indexem. Indexy mají vlastnosti primárního klíče, takže jsou jedinečné, ale netvoří po sobě jdoucí řadu. Práci s úložištěm zprostředkovává třída RecordStore. Instanci získáme voláním její statické metody: openRecordStore(String recordStoreName, boolean createIfNecessary)
První parametr určuje název a druhý chování v případě, že požadované úložiště neexistuje. Hodnota true
zajistí
jeho
vytvoření.
RecordStoreNotFoundException.
V
opačném
případě
dojde
k
vyhození
výjimky
Pole názvů všech vytvořených úložišť vrací statická metoda
listRecordStores.
K uloženým datům mohou přistupovat všechny midlety v sadě. Pro další sady jsou neviditelná, aby se zabránilo konfliktům existujících názvů úložišť. K jednomu úložišti lze přistupovat simultánně opětovným voláním openRecordStore. Po skončení práce se uzavře metodou closeRecordStore. Je-li otevřeno vícekrát, dojde k zavření až po posledním volání této metody. Ke sledování změn v úložišti slouží posluchač RecordListener s následujícími metodami: ●
recordAdded(RecordStore recordStore, int recordId)
●
recordChanged(RecordStore recordStore, int recordId)
●
recordDeleted(RecordStore recordStore, int recordId)
První informuje o vytvoření nového záznamu, druhá o jeho změně a třetí o odstranění. Parametry udávají otevřené úložiště a index ovlivněného záznamu. Posluchač se přihlašuje voláním addRecordListener
a odhlašuje voláním removeRecordListener objektu RecordStore. 25
Pro práci se záznamy slouží následující metody: ●
addRecord(byte[] data, int offset, int numBytes)
●
deleteRecord(int recordId)
●
getRecord(int recordId)
●
getRecord(int recordId, byte[] buffer, int offset)
●
setRecord(int recordId, byte[] newData, int offset, int numBytes)
Metoda addRecord přidá nový záznam a vrátí jeho index, její parametry jsou ukládaná data, pozice začátku čtení a počet přečtených bajtů. Metoda deleteRecord odstraní záznam se zadaným indexem. Uložený záznam se získá voláním jedné z metod getRecord, přičemž druhá z nich umožňuje načíst pouze část pole bajtů danou začátkem a délkou. Pro úpravu stávajícího záznamu lze zavolat setRecord. Převod dat na požadované pole bajtů výrazně zjednodušují třídy pro práci s výstupními proudy ByteArrayOutputStream
a DataOutputStream, ukázkou je následující příklad:
// Vytvoření výstupních proudů ByteArrayOutputStream baos = new ByteArrayOutputStream(); DataOutputStream dos = new DataOutputStream(baos); // Zapsání dat dos.writeBoolean(logickáHodnota); dos.writeByte(bajt); dos.writeChar(znak); dos.writeInt(číslo); dos.writeLong(dlouhéČíslo); dos.writeShort(krátkéČíslo); dos.writeUTF(řetězec); dos.close(); // Převod na pole bajtů byte[] data = baos.toByteArray();
Analogicky lze použít třídy ByteArrayInputStream a DataInputStream výstupních proudů k čtení dat z pole bajtů jako v dalším příkladě: // Vytvoření vstupních proudů ByteArrayInputStream bais = new ByteArrayInputStream(data); DataInputStream dis = new DataInputStream(bais); // Čtení dat logickáHodnota = dis.readBoolean(); bajt = dis.readByte(); znak = dis.readChar(); číslo = dis.readInt(); dlouhéČíslo = dis.readLong(); krátkéČíslo = dis.readShort(); řetězec = dis.readUTF();
26
dis.close();
Záznamy v úložišti je možné procházet pomocí objektu RecordEnumeration. Ten se získá voláním následující metody: enumerateRecords(RecordFilter filter, RecordComparator comparator, boolean keepUpdated)
První parametr filter určuje, které položky do enumerace zahrnout. Pomocí druhého parametru lze nastavit pořadí vracení jednotlivých záznamů. Je-li třetí parametr nastaven na hodnotu true, budou se vždy vracet aktuální záznamy. Naopak hodnota false nastaví vracení záznamů platných k sestavení enumerace, takže může být vrácen index záznam, který již byl odstraněn. Stejně tak nemusí odpovídat pořadí modifikovaných záznamů. Výhodou je úspora použitých zdrojů. Je-li k dispozici objekt RecordEnumeration, jednotlivé záznamy se prochází obdobně jako klasickou enumerací voláním metod: ●
hasNextElement()
●
nextRecord()
●
nextRecordId()
Je možné také procházení odzadu pomocí metod: ●
hasPreviousElement()
●
previousRecord()
●
previousRecordId()
Na rozdíl od klasické enumerace lze voláním reset obnovit výchozí pozici a procházet opětovně. Metoda rebuild aktualizuje enumeraci tak, aby odrážela aktuální stav úložiště. Po ukončení práce by měla být zavolána metoda destroy, která uvolní alokované prostředky. Filtrování záznamů se provádí implementací rozhraní RecordFilter s jedinou metodou: matches(byte[] candidate)
Podle dodaných dat v poli bajtů se programátor může rozhodnout, jestli záznam zařadit do enumerace a poté třeba vrátit logickou hodnotu true nebo false. K určení pořadí záznamů je k dispozici rozhraní RecordComparator s metodou: compare(byte[] rec1, byte[] rec2)
Po porovnání dat se vrátí jedna z hodnot určených konstantami v následující tabulce:
27
Konstanta
Význam
EQUIVALENT
Oba záznamy jsou z hlediska určení pořadí ekvivalentní
FOLLOWS
První záznam by měl následovat za druhým
PRECEDES
První záznam by měl předcházet druhému
Tabulka 8: Konstanty k určení pořadí záznamů enumerace datového úložiště
28
4 Knihovna Tvary Knihovna Tvary je soubor tříd pro snadné kreslení a animaci jednoduchých tvarů. Kreslení probíhá na plátně v kartézské soustavě souřadnic, jednotkou je obrazový bod. Kromě toho je k dispozici mřížka, jež plátno rozděluje na síť polí definované velikosti. Pomocí správce plátna lze tvary přidávat do seznamu malovaných a tím zajistit jejich kreslení, nebo je ze seznamu odebírat. Animací se rozumí následné posouvání tvarů po plátně, popřípadě změna jejich velikosti. Součástí knihovny je i třída určená k zobrazování jednoduchých dialogů (informační, potvrzovací a dialog k zadání hodnoty). Knihovna je vhodná pro začínající programátory. Jako učební pomůcka jim umožňuje jednoduše pracovat s grafickým výstupem programu. Vizualizace některých problémů během výuky programování přispívá ke snadnějšímu pochopení jeho principů. Podrobnější informace o knihovně lze nalézt v knize Myslíme objektově v jazyku Java 5.0 [4].
Ilustrace 4.1: UML diagram knihovny Tvary
29
4.1
Implementace
Praktická část této práce spočívá v implementaci knihovny Tvarů na platformu Java ME. Z mobilních zařízení dosáhly největšího rozšíření právě mobilní telefony, proto implementace využívá konfiguraci CLDC a profil MIDP. Většina telefonů a podobných zařízení v současnosti disponuje podporou novějších verzí CLDC 1.1 a MIDP 2.0. Při tvorbě koncových aplikací bez přehnaných nároků na kompatibilitu považuji za vhodné používat právě těchto verzí. Nicméně knihovna tvarů není koncovou aplikací, může sloužit k vývoji dalších programů nebo knihoven. Proto využívá starší verze CLDC 1.0 a MIDP 1.0. Její uživatelé tak nejsou zbytečně ochuzeni o možnost vyvíjet programy pro množství starších zařízení. V popisu konfigurace CLDC 1.0 jsem uvedl, že obsahuje pouze některé (často neúplné) třídy z platformy Java SE. Nejrelevantnější z hlediska implementace knihovny Tvary je absence podpory čísel s plovoucí desetinou čárkou a omezená nabídka kolekcí. Výpočty používající desetinná čísla jsem musel upravit, aby bylo dosaženo stejného výsledku s čísly celými. Některé z nich zahrnují i počítání druhé odmocniny, k čemuž se v Java SE volá Math.sqrt. Tato metoda však v CLDC 1.0 není podporována a proto jsem použil knihovnu Integer Square Root function [17]. Poskytuje hned několik metod pro výpočet celočíselné odmocniny v závislosti na požadované přesnosti. Problém s kolekcemi jsem vyřešil použitím dostupných tříd Vector, Hashtable a s tím související úpravou kódu (např. Set nepodporuje duplikáty, proto je po jeho nahrazení vektorem třeba kontrolovat, jestli vkládaný prvek již neobsahuje). 4.1.1
Třída CanvasManager
Třída CanvasManager (správce plátna) poskytuje metody pro správu plátna, vykreslovaných tvarů a umožňuje pomocí posluchačů zachytávat události uživatelského vstupu. V implementaci pro Java SE vytváří klasické okno JFrame a k zobrazování tvarů využívá objekt JPanel. Metody posluchačů pouze deleguje vytvořenému oknu. V implementaci pro Java ME jsem použil nízkoúrovňového přístupu, přičemž okno správce plátna nahrazuje třída odvozená od Canvas. Důsledkem bylo odstranění některých metod souvisejících s oknem, postrádajících v MIDP smysl. Jedná se o metody: ●
setName(String name)
●
getName()
●
getX()
30
●
getY()
●
getPosition()
●
setPosition(int x, int y)
●
setPosition(Position position)
●
setVisible(boolean viditelné)
Naopak jsem přidal metody getDisplayableWidth a getDisplayableHeight, které vrací maximální zobrazitelnou velikost plátna v obrazových bodech. Použitý profil MIDP neumožňuje ukládat obrázky ani přistupovat k barevným hodnotám jednotlivých bodů, proto nebylo možné implementovat metodu saveAsPicture. Další odlišnosti vznikly v posluchačích uživatelského vstupu. Původní knihovna používá klasické posluchače klávesnice a myši z Java SE, rozhraní KeyListener
a MouseListener. Spravují se metodami:
●
registerKeyboard(KeyListener posluchač)
●
registerMouse(MouseListener posluchač)
●
cancelKeyboard(KeyListener posluchač)
●
cancelMouse(MouseListener posluchač)
V Java SE jsou vstupními zařízeními klávesnice a myš, v konfiguraci CLDC klávesnice mobilního zařízení a dotyková obrazovka. Z hlediska vyvolávaných událostí se dají zařízení uživatelského vstupu mobilních zařízení považovat za zjednodušenou verzi těch plnohodnotných, dostupných na stolních počítačích. Proto jsem ponechal názvy zmíněných metod shodné, liší se pouze předávanými parametry. Jedná se o rozhraní IKeyListener pro klávesnici mobilního telefonu a IPointerListener pro dotykovou obrazovku. Obě nabízejí standardní události dostupné třídě při použití nízkoúrovňového přístupu, podrobnější popis je uveden v jejich dokumentaci.
Canvas
S výše zmíněnými posluchači souvisí i další doplňující metody přidané správci plátna. Neobsahují žádnou funkcionalitu navíc, pouze volají příslušné protějšky objektu Canvas. Jejich seznam je následující: ●
getGameAction(int keyCode)
●
getKeyCode(int gameAction)
●
getKeyName(int keyCode)
●
hasRepeatEvents()
●
hasPointerEvents()
31
●
hasPointerMotionEvents()
Vnitřní třídy MultiKeyListener a MultiPointerListener umožňují správci plátna obsloužit více zaregistrovaných posluchačů, ale to s sebou přináší i možné snížení výkonu aplikace procházením položek vektoru posluchačů při vyvolání každé události. Proto doporučuji použít pouze jednoho posluchače klávesnice respektive dotykové obrazovky. V takovém případě nebudou tyto třídy použity. Aplikaci využívající knihovny tvarů je možné vypnout volbou příkazu Konec na obrazovce správce plátna nebo Storno na kterémkoliv dialogu. Ukončení není provedeno automaticky, místo toho se zavolá metoda exitPressed rozhraní IExitListener. V těle této metody by měl programátor ukončit midlet voláním notifyDestroyed. Nastavení posluchače IExitListener ve správci plátna se provádí metodou: setExitListener(IExitListener exitListener)
Kromě ukončení aplikace má zmíněný posluchač také za úkol předávat některým třídám knihovny objekt Display, jenž reprezentuje obrazovku spuštěného midletu. Proto je při jeho vytváření nutné implementovat i metodu getDisplay. Její volání umožňuje zobrazit plátno třídě CanvasManager (při registraci posluchače) a dialogové formuláře třídě IO. 4.1.2
Třída Painter
Třída Painter (kreslítko) zajišťuje vykreslování jednotlivých tvarů. Její instanci získá tvar implementací metody draw rozhraní IPaintable. Kreslítko má k dispozici objekt Graphics, s jehož pomocí maluje obrysy tvarů, nebo je vyplňuje. V použité verzi MIDP však tento objekt nedisponuje požadovanou metodou ke kreslení a vyplňování trojúhelníku. Tento problém jsem vyřešil použitím knihovny JMicroPolygon [16]. Její třídy GeomUtils a PolygonGraphics jsou k dispozici v balíčku net.sourceforge.jmicropolygon. První z nich je knihovní třídou zajišťující některé početní operace pro druhou zmíněnou PolygonGraphics. Ta poskytuje následující metody: ●
drawPolygon(Graphics g, int[] xPoints, int[] yPoints)
●
fillPolygon(Graphics g, int[] xPoints, int[] yPoints)
●
fillPolygon(Graphics g, int[] xPoints, int[] yPoints, Stack stack)
●
fillTriangle(Graphics g, int x0, int y0, int x1, int y1, int x2, int y2)
Poslední fillTriangle je použita kreslítkem k vyplňování trojúhelníku. Zbylé metody drawPolygon
a fillPolygon jsou určené ke kreslení a vyplňování polygonu určeného vrcholy.
32
V knihovně Tvary použity nejsou, ale jejich přítomnost je vhodná zejména s ohledem na možné budoucí rozšíření o další tvary. Implementace
třídy
Painter
také
neobsahuje
vnitřní
třídu
ImageObserver
určenou
k asynchronnímu načítání parametrů obrázků. V MIDP se obrázky načítají okamžitě v aktuálním vlákně, takže všechny jejich parametry jsou v době volání příslušných metod již k dispozici. 4.1.3
Třída Direction8
Třída Direction8 je výčtovým typem osmi hlavních a vedlejších směrů (světových stran). Každý směr má k dispozici metody k otočení a k určení přírůstku souřadnic při pohybu. Použitá konfigurace CLDC 1.0 vychází z jazyka Java 1.3 a nepodporuje přímo typ enum, proto jsem třídu implementoval podle příslušného návrhového vzoru v odborné publikaci [5]. 4.1.4
Třída NamedColor
Pomocí této třídy se určuje barva tvarů a textu. Obsahuje některé předdefinované barvy přístupné jako veřejné atributy a umožňuje uživateli definovat vlastní na základě názvu a hodnot barevných složek. Jedna barva může mít i více názvu, pomocí nichž ji lze dohledat metodou getColor. V MIDP není k dispozici třída Color, jež uchovává hodnoty barevných složek. Proto jsou jejich hodnoty uloženy v jednotlivých bajtech čísla Integer, a to v pořadí ARGB (průhlednost, červená, zelená, modrá). Na rozdíl od Java SE však MIDP nepodporuje průhledné barvy, podle dokumentace [10] je hodnota nejvyššího bajtu ignorována. Přesto jsem se jejich podporu rozhodl ve třídě NamedColor zachovat. Díky tomu je zachována kompatibilita s původní verzí třídy včetně všech předdefinovaných barev. V připravované specifikaci MIDP 3.0 se již s průhledností barev počítá a po drobné úpravě třídy Painter
4.1.5
ji bude možné plně použít i v knihovně Tvary.
Třída Multimover
Třída Multimover (multipřesouvač) zajišťuje pohyb více tvarů současně. Rychlost nebo doba přesunu se přepočítá na počet kroků s pevně danou periodou, během níž se objekt přesune o část z celkové vzdálenosti, určenou poměrem 1 / počet kroků. Implementuje-li posouvaný tvar rozhraní IMultimovable,
je po dokončení přesunu zavolána jeho metoda moved.
Přesun tvaru se iniciuje jednou z následujících metodou multipřesouvače: ●
move(IMovable ip, Position position, double sekund)
33
●
move(IMovable ip, Position position, int rychlost)
●
move(IMovable ip, int xn, int yn, double sekund)
●
move(IMovable ip, int xn, int yn, int rychlost)
První parametr určuje přesouvaný tvar a druhý (respektive druhý a třetí) cílovou pozici. V posledním parametru se zadává doba přesunu v sekundách nebo počet uražených bodů za sekundu. Protože čísla s plovoucí desetinou čárkou nejsou v použité verzi CLDC podporovaná, upravil jsem první a třetí ze zmíněných metod do následující podoby: ●
move(IMovable ip, Position position, long ms)
●
move(IMovable ip, int xn, int yn, long ms)
Požadovaný čas přesunu se v této implementaci knihovny tedy zadává v milisekundách jako celé číslo typu long. 4.1.6
Třída Picture
Kromě jednoduchých tvarů lze na plátně zobrazit i obrázek. K tomu slouží třída Picture. Změna jeho velikosti je v původní knihovně tvarů realizována pomocí afinní transformace. Tento způsob však MIDP 1.0 nepodporuje, proto jsem použil kód z článku [6] na webových stránkách Sun Developer Network. Tato změna má dopad na chování třídy Picture, protože již není vhodné měnit velikost při každém požadavku k nakreslení, jako tomu bylo u použití afinní transformace. Implementace této třídy pro Java ME v paměti uchovává původní obrázek i ten se změněnou velikostí. Při změně velikosti se pracuje vždy s původním obrázkem. Vzhledem k omezené operační paměti však není vhodné vždy udržovat v paměti dva obrázky namísto jednoho, zejména pokud je třeba změnit velikost pouze jednou (při načtení). Proto jsem přidal další konstruktor, jenž ihned po načtení obrázku změní jeho velikost a dále udržuje v paměti pouze změněnou verzi: Picture(int x, int y, int width, int height, String name)
4.1.7
Třída Text
Třída Text umožňuje vypsat na plátno text určený zvoleným typem písma, řezem a velikostí. V tomto ohledu jsou však možnosti MIDP omezené, k dispozici jsou pouze tři typy písma a tři stupně velikosti. Z důvodu kompatibility jsem zachoval původní metodu setFont, zadané parametry se však aproximují na použitelné hodnoty. Dále jsem přidal její novou verzi, jež nastaví font způsobem běžně užívaným v MIDP: setFont(int face, int style, int size)
34
4.2
Tvorba aplikací používajících knihovnu Tvary
K vývoji aplikací na platformě Java ME slouží nástroj Sun Java Wireless Toolkit (WTK). Tato podkapitola popisuje, jakým způsobem s jeho pomocí vytvořit aplikaci, připravenou ke spuštění na libovolném zařízení s podporou CLDC 1.0 a MIDP 1.0. Momentálně jsou k dispozici dvě verze WTK. První slouží k vývoji aplikací využívajících konfigurace CLDC a druhá CDC. Knihovna Tvary je určena pro zařízení s podporou CLDC, proto je třeba stáhnout a nainstalovat verzi označenou jako „Sun Java Wireless Toolkit for CLDC“. K tomu lze využít následujícího odkazu: http://java.sun.com/products/sjwtoolkit/download.html
WTK vyžaduje pro vytváření aplikací Java SE Development Kit (JDK), před zahájením instalace doporučuji ověřit, zda je na cílovém počítači k dispozici. Následující text se týká aktuální verze WTK 2.5.2 pro platformu Microsoft Windows, v ostatních se mohou některé postupy lišit. 4.2.1
Vytvoření projektu
Po dokončení instalace se WTK spustí pomocí zástupce Wireless Toolkit 2.5.2 vytvořeného na ploše libovolného uživatele.
Ilustrace 4.2: Dialogové okno pro vytvoření nového projektu programu WTK Nyní je třeba vytvořit nový projekt klepnutím na tlačítko New Project. Objeví se dialog vyzývající k zadání názvu projektu v poli Project Name a názvu třídy ke spuštění aplikace MIDlet Class Name. Název projektu lze zvolit libovolně, jediné jeho omezení vyplývá z faktu, že se použije k vytvoření adresáře. Proto je nutné volit označení v souladu s pravidly pojmenovávání adresářů systému. Třída ke spouštění aplikace je odvozená od abstraktní třídy MIDlet a je nutné zadat její celý název, včetně balíčku. V době vytváření projektu nemusí existovat, její přítomnost se vyžaduje 35
až při sestavování a spouštění. Po potvrzení dialogu se objeví okno vlastností právě vytvořeného projektu. Zde je třeba nastavit cílovou platformu na první záložce označené jako API Selection. Její výběr závisí na požadované verzi CLDC, MIDP a rozšiřujících balíčcích vytvářené aplikace. K vývoji aplikace využívající knihovnu Tvary postačuje zvolit MIDP 1.0 v poli Target Platform a potvrzením dialogu se vrátit zpět na hlavní okno WTK. 4.2.2
Vytvoření aplikace
Nyní je třeba vytvořit spouštěcí třídu odvozenou od MIDlet, případně další třídy aplikace. WTK nedisponuje funkcí k úpravě zdrojových kódu aplikace, lze k tomu použít libovolný textový editor. Aby bylo možné použít dialogová okna ve třídě IO a ukončit program, midlet musí nastavit ve správci plátna posluchač ukončení, třídu implementující rozhraní IExitListener. Nejjednodušším způsobem je implementovat toto rozhraní přímo do spouštěcí třídy. Demonstrací takové třídy je následující příklad: import import import import
javax.microedition.midlet.*; javax.microedition.lcdui.*; shapes.CanvasManager; shapes.IExitListener;
public class Start extends MIDlet implements IExitListener { // Obrazovka tohoto midletu private final Display display = Display.getDisplay(this); // Příznak k určení prvního zavolání metody startApp private boolean once = false; public void startApp() throws MIDletStateChangeException { if (once == false) { // Došlo ke spuštění aplikace, midlet je v aktivním stavu once = true; // Je třeba nastavit posluchač ukončení ve správci plátna CanvasManager.getInstance().setExitListener(this); // Vytvoření a spuštění nového vlákna new Thread() { public void run() { // Kód aplikace } }.start(); } else { // Přechod z pozastaveného stavu do aktivního } } public void pauseApp() { // Přechod z aktivního stavu do pozastaveného } public void destroyApp(boolean unconditional)
36
throws MIDletStateChangeException { // Přechod do ukončeného stavu } public void exitPressed() { // Uživatel se rozhodl ukončit aplikaci notifyDestroyed(); } public Display getDisplay() { return display; } }
Kromě způsobu použití posluchače ukončení je také důležité spuštění aplikace, kde se pro samotný kód programu vytváří nové vlákno. To je nezbytné v případě, že takový kód obsahuje volání metod blokujících běh aktuálního vlákna. Z knihovny Tvarů to jsou například metody tříd IO, Mover a Resizer. 4.2.3
Spuštění aplikace a tvorba JAR archivu
Po vytvoření zdrojového kódu aplikace je třeba všechny soubory zkopírovat do adresáře projektu. Jedná se o následující adresář ve složce profilu aktivního uživatelského účtu: \j2mewtk\2.5.2\apps\
Například v systému Microsoft Windows XP uživatele Franta bude adresář projektu Šachy: C:\Documents and Settings\Franta\j2mewtk\2.5.2\apps\Šachy)
Význam vybraných podadresářů každého projektu popisuje následující tabulka: Podadresář projektu Význam src
Zdrojový kód aplikace
lib
Použité knihovny
classes
Zkompilované soubory tříd
bin
JAR archiv hotového projektu
Tabulka 9: Význam podadresářů složky projektu programu WTK Zdrojový kód aplikace včetně spouštěcí třídy se tedy zkopíruje do podadresáře src a použité knihovny do podadresáře lib, v případě knihovny Tvary se jedná o soubor shapes-me.jar. Nyní je již možné aplikaci zkompilovat a spustit kliknutím na tlačítko Build respektive Run v hlavním okně WTK. K vytvoření JAR archivu slouží položka v menu Project - Package - Create Package. Výsledný archiv lze nalézt v podadresáři bin včetně přidruženého deskriptoru. Dvojice těchto souborů tvoří 37
hotovou aplikaci, kterou již lze nahrát a spustit v mobilním telefonu nebo jiném zařízení. 4.2.4
Nastavení kódování
Používá-li zdrojový kód aplikace jiné než standardní kódování systému, pravděpodobně se ho nepodaří zkompilovat. Východiskem je úprava konfiguračního souboru podle uživatelské příručky WTK [14]. Nejprve je třeba nalézt soubor ktools.properties, nachází se v instalačním adresáři WTK v podsložce wtklib\Windows. Tento soubor se zkopíruje do stejné podsložky v pracovním adresáři (<profil uživatele>\j2mewtk\2.5.2\) a pomocí textového editoru se do něj vloží následující řádek například pro kódování UTF-8: javac.encoding=UTF-8
38
5 Závěr Cílem této práce bylo implementovat knihovnu Tvary pro kreslení a jednoduchou animaci tvarů na platformu Java ME, což se až na drobná omezení (ukládání obrázků, pomalá změna velikosti, průhlednost barev) podařilo. Knihovna je dostupná včetně zdrojových kódu na přiloženém CD. Jako demonstraci jsem přiložil program vyvíjený v kurzu 4IT251 Moderní programovací techniky. Jedná se o jednoduchou simulaci provozu ve městě. Zmíněná omezení obrázků by se dala odstranit vytvořením další verze knihovny určené pro novější telefony s podporou MIDP 2.0. Aby je bylo možné ukládat do souboru, bylo potřeba zvýšit nároky na cílová zařízení použitím některého z rozšiřujících balíčků pro práci se souborovým systémem a pro ukládání obrázků. Podpora průhlednosti barev by se implementovala přistupováním k barevným hodnotám jednotlivých bodů obrázku a úpravou hodnoty alfa kanálu. Tento způsob by však mohl znamenat značné zpomalení při vykreslování tvarů a proto bych s další verzí knihovny doporučil počkat na finální verzi specifikace MIDP 3.0, kde je plná podpora průhlednosti již zahrnuta.
39
Seznam použité literatury [1]
Abiro. JSR 271 - Mobile Information Device Profile (MIDP) 3.0 [online]. URL [cit. 22.6.2008]
[2]
KOMA Vít. JavaBeans [online]. URL [cit. 22.6.2008]
[3]
ORTIZ, Enrique C. The Generic Connection Framework [online]. URL [cit. 22.6.2008]
[4]
PECINOVSKÝ Rudolf. Myslíme objektově v jazyku Java 5.0. 1. vyd., 2004. ISBN 80-247-0941-4 [cit. 22.6.2008]
[5]
PECINOVSKÝ Rudolf. Návrhové vzory. 1. vyd., 2007. ISBN 978-80-251-1582-4 [cit. 22.6.2008]
[6]
Sun Microsystems. Java ME Guideline: How to resize images to screen size [online]. URL [cit. 22.6.2008]
[7]
Sun Microsystems. Java ME Technology - CDC Overview [online]. URL [cit. 22.6.2008]
[8]
Sun Microsystems. Java ME Technology APIs & Docs [online]. URL [cit. 22.6.2008]
[9]
Sun Microsystems. JSR-000030 J2ME Connected, Limited Device Configuration [online]. URL [cit. 22.6.2008]
[10] Sun Microsystems. JSR-000037 Mobile Information Device Profile (MIDP) [online]. URL [cit. 22.6.2008] [11] Sun Microsystems. JSR-000037 Mobile Information Device Profile (MIDP) [online]. URL [cit. 22.6.2008] [12] Sun Microsystems. JSR-000139 Connected Limited Device Configuration 1.1 - Final Release [online]. URL [cit. 22.6.2008] [13] Sun Microsystems. JSR-000195 Information Module Profile - Final Release [online]. URL [cit. 22.6.2008] [14] Sun Microsystems. Sun Java Wireless Toolkit for CLDC User's Guide [online]. URL [cit. 22.6.2008]
40
[15] TOPLEY, Kim. J2ME v kostce: Pohotová referenční příručka. 1. vyd., 2004. ISBN 80-247-0426-9 [cit. 22.6.2008] [16] TURNER Simon. SourceForge.net: JMicroPolygon [online]. URL [cit. 22.6.2008] [17] TYLER Tim. ATOMS - Fast integer square root [online]. URL [cit. 22.6.2008] [18] Wikipedie. Applet [online]. URL [cit. 22.6.2008] [19] Wikipedie. Java Community Process [online]. URL [cit. 22.6.2008]
41
Seznam ilustrací Ilustrace 3.1: Hierarchie rozhraní a souvisejících tříd GCF, zdroj [3].................................................8 Ilustrace 3.2: Stavy midletu a události volané při jejich změně, zdroj [10].......................................12 Ilustrace 3.3: Kreslení a vyplňování tvarů v MIDP, zdroj [15]..........................................................21 Ilustrace 3.4: Ukázka umístění textu pomocí kotvícího bodu............................................................22 Ilustrace 4.1: UML diagram knihovny Tvary.....................................................................................29 Ilustrace 4.2: Dialogové okno pro vytvoření nového projektu programu WTK................................35
Seznam tabulek Tabulka 1: Tabulka vlastností sady midletů........................................................................................14 Tabulka 2: Vlastnosti obsažené v manifestu a deskriptoru sady........................................................15 Tabulka 3: Konstanty k omezení zadávaných znaků textového pole.................................................18 Tabulka 4: Konstanty k určení chování celoobrazovkového seznamu...............................................19 Tabulka 5: Konstanty k určení typu čáry............................................................................................22 Tabulka 6: Konstanty k určení kotvícího bodu...................................................................................22 Tabulka 7: Konstanty k určení fontu písma........................................................................................23 Tabulka 8: Konstanty k určení pořadí záznamů enumerace datového úložiště..................................28 Tabulka 9: Význam podadresářů složky projektu programu WTK....................................................37
42
Terminologický slovník Termín
Zkratka
Význam [zdroj]
Abstract Window
AWT
Knihovna pro tvorbu grafického uživatelského rozhraní, je
Toolkit
součástí Java SE a některých profilů Java ME. [autor]
applet
Softwarová komponenta, která běží v kontextu jiného programu, typicky webového prohlížeče. Bývá většinou orientována na plnění konkrétní funkce v daném kontextu a nepředpokládá se, že bude používána jako samostatná aplikace. [18]
deskriptor
Textový soubor metadat o Java aplikace na platformě Java ME. [autor]
hostitelský systém
Operační systém zařízení zajišťující běh virtuálního stroje. [autor]
Java Archive
JAR
Archiv s definovanou strukturou určený k distribuci Java programů. [autor]
Java Platform,
Java EE
Enterprise Edition Java Platform,
servery. [autor] Java ME
Micro Edition Java Platform,
Request
Platforma Java k vývoji a běhu programů určených pro mobilní zařízení. [autor]
Java SE
Standard Edition Java Specification
Platforma Java k vývoji a běhu programů určených pro
Platforma Java k vývoji a běhu programů určených pro osobní počítače. [autor]
JSR
Požadavek na změnu nebo doplnění platformy Java. Po schválení je jeho výstupem dokument se specifikací, případně Java kód definující příslušná API. [19]
JavaBean
Znovupoužitelná softwarová komponenta, se kterou je možno manipulovat ve vizuálních nástrojích. [2]
klávesnice ITU-T
Typ klávesnice pro mobilní telefony standardizovaný Mezinárodní Telekomunikační Unií. [autor]
klávesnice QWERTY
Standardizovaný typ počítačové klávesnice označený podle začátku horní řady písmen.[autor]
konfigurace
Specifikace definující softwarové prostředí pro nějakou škálu zařízení, která je určena sadou charakteristik, na něž specifikace spoléhá. [15] 43
Termín
Zkratka
Význam [zdroj]
manifest
Textový soubor metadat o Java aplikaci [autor]
midlet
Speciální třída k řízení běhu (spuštění, ukončení, atd.) aplikace na platformě Java ME, nebo také program určený pro platformu Java ME. [autor]
platforma Java
Souhrn technologií umožňující vývoj a běh programů v jazyce Java. [autor]
profil
Doplňuje konfiguraci prostřednictvím přidání dalších tříd, které poskytují funkce vhodné pro určitý druh zařízení nebo pro specifický segment trhu. [15]
socket
Koncový bod obousměrné síťové komunikace protokolem IP. [autor]
virtuální stroj
JVM
Software zajišťující běh Java aplikací na různých platformách. [autor]
44
