Szakdolgozat
Miskolci Egyetem
Pénznem és mértékegység konvertáló Android alkalmazás
Készítette: Felfalusi - Ilyés Csongor 2013. Programtervező Informatikus Témavezető: Dr. Házy Attila
Miskolc, 2013
Miskolci Egyetem Gépészmérnöki és Informatikai Kar Alkalmazott Matematikai Tanszék
Szám:
Szakdolgozat Feladat Felfalusi - Ilyés Csongor (R1QVSN) programtervező informatikus jelölt részére. A szakdolgozat tárgyköre: Programozás A szakdolgozat címe: Pénznem és mértékegység konvertáló Android alkalmazás A feladat részletezése: Az Android mobil operációs rendszer ismertetése, jellemzése. Android alkalmazások fejlesztésének bemutatása. Android alkalmazás fejlesztése, mely képes a különböző nemzetek pénznemének átváltására naprakész információk felhasználásával. A program ezen kívül képes különböző mértékegységek közötti átváltásra is, mindezt egy átlátható, és könnyen kezelhető felületen keresztül.
Témavezető(k): Dr. Házy Attila, egyetemi docens Konzulens(ek): A feladat kiadásának ideje: 2012. szeptember 27.
................................. szakfelelős 2
1. szükséges (módosítás külön lapon) A szakdolgozat feladat módosítása nem szükséges ......................
...........................
dátum
témavezető(k)
2. A feladat kidolgozását ellenőriztem: témavezető (dátum, aláírás):
konzulens (dátum, aláírás):
..............
.............
..............
.............
..............
.............
3. A szakdolgozat beadható: ......................
...........................
dátum
témavezető(k)
4. A szakdolgozat . . . . . . . . . . . . . . . . . . . szövegoldalt . . . . . . . . . . . . . . . . . . . program protokollt (listát, felhasználói leírást) . . . . . . . . . . . . . . . . . . . elektronikus adathordozót (részletezve) ................... . . . . . . . . . . . . . . . . . . . egyéb mellékletet (részletezve) ................... tartalmaz. ......................
...........................
dátum
témavezető(k)
5. bocsátható A szakdolgozat bírálatra nem bocsátható A bíráló neve: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ......................
...........................
dátum
szakfelelős
6. A szakdolgozat osztályzata a témavezető javaslata:
................
a bíráló javaslata:
................
a szakdolgozat végleges eredménye: . . . . . . . . . . . . . . . . Miskolc, . . . . . . . . . . . . . . . . . . . . . . . .
................................. a Záróvizsga Bizottság Elnöke 3
Tartalomjegyzék 1. Bevezetés 2. Android rendszer bemutatása 2.1. Az android rendszer története . . . . . . . . 2.2. A rendszer szerkezete . . . . . . . . . . . . . 2.3. Android-verziók . . . . . . . . . . . . . . . . 2.3.1. Android 1.0 (Apple pie) . . . . . . . 2.3.2. Android 1.1 (Banana bread) . . . . . 2.3.3. Android 1.5 (Cupcake) . . . . . . . . 2.3.4. Android 1.6 (Donut) . . . . . . . . . 2.3.5. Android 2.0/2.1 (Eclair) . . . . . . . 2.3.6. Android 2.2 (Froyo) . . . . . . . . . . 2.3.7. Android 2.3 (Gingerbread) . . . . . . 2.3.8. Android 3.0 (Honeycomb) . . . . . . 2.3.9. Android 4.0 (Ice Cream Sandwich) . 2.3.10. Android 4.1 (Jelly Bean) . . . . . . . 2.3.11. Android 4.2 (Jelly Bean) . . . . . . . 2.3.12. Android 5.0 (Key Lime Pie) . . . . . 2.4. Google Play . . . . . . . . . . . . . . . . . . 2.5. Az alkalmazások komponensei . . . . . . . . 2.5.1. Activity . . . . . . . . . . . . . . . . 2.5.2. Az Activityk életciklusa . . . . . . . 2.5.3. Service . . . . . . . . . . . . . . . . . 2.5.4. ContentProvider . . . . . . . . . . . 2.5.5. BroadcastReciever . . . . . . . . . . 2.5.6. Fragmentek . . . . . . . . . . . . . . 2.6. Az alkalmazások felépítése . . . . . . . . . . 2.6.1. A manifest állomány . . . . . . . . . 2.6.2. Erőforrás-állományok . . . . . . . . . 2.6.3. A forráskód . . . . . . . . . . . . . . 2.7. Felhasználói felület . . . . . . . . . . . . . . 2.7.1. Android-layoutok . . . . . . . . . . . 2.7.2. Widgetek . . . . . . . . . . . . . . . 2.7.3. Menük . . . . . . . . . . . . . . . . . 2.8. A fejlesztőkörnyezet . . . . . . . . . . . . . . 2.8.1. Az Android-emulátor . . . . . . . . . 2.9. Android-alkalmazás létrehozása Eclpise-ben 2.9.1. Projekt létrehozása . . . . . . . . . .
6
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7 7 8 9 9 9 9 10 10 11 12 13 13 14 15 15 15 16 16 17 17 17 18 18 19 19 19 19 20 20 20 20 21 21 21 22
4
2.9.2. Fontosabb fájlok és mappák . . . . . . . . . . . . . . . . . . . . 3. Fejlesztői dokumentáció 3.1. Pénznem és Mértékegység konvertáló Android - alkalmazás leírás 3.2. Spinnerek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.1. Statikus feltöltés XML fájlban . . . . . . . . . . . . . . . 3.2.2. Spinnerek dinamikus feltöltése . . . . . . . . . . . . . . . 3.2.3. Statikus adatok betöltése Java kódban . . . . . . . . . . 3.3. Mertek.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.4. Friss árfolyam adatok megszerzése . . . . . . . . . . . . . . . . . 3.4.1. Yahoo Finance Exchange Rates . . . . . . . . . . . . . . 3.5. Valuta.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
24 25 25 27 28 29 30 30 32 32 33
4. Összefoglalás
35
Irodalomjegyzék
36
Adathordozó használati útmutató
37
5
1. fejezet Bevezetés Mióta elkezdtem a Miskolci Egyetemen a Programtervező Informatikus szakot, érdekelődni kezdtem a mobil platformokra való programozás iránt, hiszen tisztán látható, hogy nagy jövő van bennük. Megállíthatatlanul terjednek el a világon, és egyre nagyobb szükség lesz olyan programozókra, akik valamilyen mobil rendszerre képesek minőségi és innovatív alkalmazásokat készíteni. Az Android platform napjaink egyik legsikeresebb mobil-operációs rendszere, a statisztikák szerint több mint 750 millió Androidos készülék működik a világon, nagyjából 1.5 millió új aktiválással naponta. Ezt figyelembe véve nem volt kérdéses, hogy melyik platformra szeretném a programomat megvalósítani, és az sem volt elhanyagolható tény a választás során, hogy nekem is ilyen készülékem van, mely nagyban megkönnyíti a tesztelés folyamatát. A programom témáját a konzulensemnek, Dr. Házy Attilának köszönhetem, ő ajánlotta, hogy egy Pénznem váltó alkalmazást írjak, mely akár egy külföldi nyaralás során is hasznos lehet. Ezt még kiegészítettem egy egyszerűbb mértékegység váltó résszel is, mert úgy éreztem így lenne teljes az alkalmazás.
6
2. fejezet Android rendszer bemutatása
2.1.
Az android rendszer története
Az Android abból a célból született, hogy egységes nyílt forrású operációs rendszere legyen a mobil eszközöknek (elsősorban az okostelefonoknak, majd később a táblagépeknek). Az elképzelés alapja egy Linux alapú operációs rendszer volt, amelyet úgy alakítottak át, hogy képes legyen problémák nélkül kezelni a mobil eszközök integrált hardvereit (érintőképernyő, WiFi, HSDPA, Bluetooth, stb.) A Google 2005-ben felvásárolta az Android Incorporated nevű vállalatot, majd saját maga kezdett az operációs rendszer fejlesztésébe, és új irányt szabott meg: a Linux kernel fölé egy virtuális gép került, amely a felhasználói felület kezeléséért és az alkalmazások futtatásáért felelős. 2007. november 5-én az Open Handset Alliance bejelentette az Android platformot. Az Android így egy nyílt forrású operációs rendszer, amit hivatalosan a fentebb említett konzorcium fejleszt. A konzorciumhoz jelenleg több mint 50 cég tartozik, köztük 11 készülékgyártó (HTC, LG, Motorola, Samsung, Asus, Garmin, Huawei, Sony Ericsson, Ericsson, Toshiba, valamint a 2009. június elsején csatlakozott Acer), 13 félvezetőgyártó (többek között az Intel, a Marvell, az nVidia, a Broadcom, a SiRF, az ARM és az Atheros), 10 operátor (köztük a T-Mobile és a Vodafone), 12 szoftveres cég (maga a Google, az eBay és pár kevésbé ismert név), valamint 7 egyéb vállalat, vezetője pedig a Google. Az Android megjelenésekor mind a nagy és kisebb gyártók számára ideális alternatíva volt. A nagyobb cégek nem igen rendelkeztek a saját rendszer fejlesztéséhez szükséges erőforrásokkal, így nagyon fontos volt számukra, hogy támogassák az új operációs 7
2.2. A rendszer szerkezete rendszert. A kisebb vállalatok ezzel szemben kitörési lehetőséget láttak az Androidban, mivel ingyenessége miatt könnyen piacra tudták dobni a jó ár/érték arányú készülékeiket.
2.2.
A rendszer szerkezete
Az Android egy Linux-kernel alapú mobil-operációs rendszer, összességében a felépítése logikus és áttekinthető. A legalsó szinten található a kernel, melynek feladata a memóriakezelés, a folyamatok ütemzése és a teljesítménykezelés. Ez utóbbi nagyon fontos, hiszen mobil eszközökről lévén szó az alacsony fogyasztás létfontosságú. Ugyancsak ezen a szinten találhatók az eszközmeghajtó programok is a hardver számára. A kernel fölött találhatók a különböző programkönyvtárak és szolgáltatások (például: OpenGL/ES, SQLite, SSl, stb). Ezekre a könyvtárakra épül részben az Android-futtatókörnyezete, melynek fő eleme a Dalvik virtuális gép. A Dalvik a Java Virtual Machine jelentősen átdolgozott és optimalizált verziója, melynek feladata a Java-alkalmazások futtatása. A Dalvik virtuális gépen a Javában készített felügyelt kód fut, ez a megoldás az alkalmazások futtatását rendkívül biztonságossá teszi, hiszen így egy alkalmazás csak nagyon ritkán képes megbénítani a rendszert. A memóriakezelés "garbage collectorral" történik. A legfelső réteg adja az Android lényegét, a látható és használható operációs rendszert, valamint a futó programokat.
8
2.3. Android-verziók
2.3.
Android-verziók
Az Android platform egyik legnagyobb hátrányaként a különböző verziók közötti különbségeket szokták kiemelni, pedig az Android-verziók visszafelé teljesen kompatibilisek, a korábban írt programok szinte biztosan lefutnak az új verziókon is. Minden egyes új verzióval fejlődik a rendszer növelve a felhasználói élményt, valamint könnyítve a fejlesztők munkáját.
A platform megjelenése óta számos újításon ment keresztül. Fontosabb verziók, és az általuk hozott újítások:
2.3.1.
Android 1.0 (Apple pie)
A platform 2008. október 21-én került kiadásra Apache licenc alatt, amely - egy szűk fanatikusokból álló rétegen kívül - nem nyerte el igazán az átlag felhasználók tetszését. A platform stabilitása megfelelő volt ugyan, inkább a használhatósága volt nehézkes, sok esetben pedig a kinézete nem volt megfelelő. A HTC által gyártott G1 is inkább csak koncepció-telefon volt - elősegítendő a fejlesztők munkáját, illetve felkeltendő a cégek érdeklődését, mint használható mobil eszköz.
2.3.2.
Android 1.1 (Banana bread)
Ez a jelentéktelen mértékben elterjedő kiadás 2009. februárjában jelent meg, felkerült a G1 telefonokra, sok apró hibát javított, amely az eltelt pár hónap alatt napvilágra került, de az igazán égető problémákra nem adott gyógyírt.
2.3.3.
Android 1.5 (Cupcake)
Majd fél évvel az első verzió után jelent meg a 2.6.27 verziójú Linux kernelen alapuló Android platform, az első hazánkban is hivatalosan kapható Vodafone-exkluzív HTC Magic ezt a verziót futtatta, amely tucatnyi újítást tartalmazott: • Szoftveres billentyűzet automatikus kiegészítés funkcióval • A2DP Bluetooth támogatás, illetve automatikus headset csatlakozás • Új UI komponensek • Animációk a képernyőváltások között • Feljavított Copy-Paste funkció 9
2.3. Android-verziók • Videók és képek közvetlen feltöltése a YouTube és a Picasa portálokra
2.3.4.
Android 1.6 (Donut)
A 2009 szeptemberében megjelenő 1.6 verzió az előző kiadás ráncfelvarrásaként érkezett: • Android Market javítások • Feljavított galéria funkcionalitások (több kép kijelölése közös művelethez) • Hangfelismerésen alapuló funkciók • A teljes platformban keresni képes kereső • A használt technológiák frissítése, WVGA felbontás támogatása, egyéb optimalizálások
2.3.5.
Android 2.0/2.1 (Eclair)
A 2009 októberében kiadásra kerülő 2.0 verzión a Google régebb óta dolgozott, és ez indította el igazán a rendszer elterjedését. A változások is mélyebbre hatottak, ami a verziószámból is látszik: • 2.6.29 Linux kernel • Hardverre optimalizálás • Változatos képernyőméretek és felbontások támogatása • Újraértelmezett grafikus felület • HTML5 támogatás • Multi touch támogatás • Bluetooth 2.1 támogatás • Élő háttér A 2.0 kiadása után nem sokkal érkezett a 2.0.1 verzió, amely több apró - de bosszantó - hibát javított, illetve 2010. januárban a 2.1 verzió, amely további javításokat hozott az Android világába. Az Eclair legsikeresebb verziója a 2.1 lett. 10
2.3. Android-verziók
2.3.6.
Android 2.2 (Froyo)
2010 májusában mutatta be a Google az I/O fejlesztői konferencián. Számos komoly változás került a rendszerbe, egy picit megváltozott a kinézete is, azonban talán a legfontosabb a jelentős gyorsulás és a teljesértékű Flash támogatás megléte. Utóbbi sokat dobhat az internetezés élményén, hiszen végre nem probléma egy beágyazott videó vagy egy flash elemekből felépülő honlap megtekintése. A rendszerkód is alaposabb átíráson, optimalizáláson esett át, ez jót tett a működési sebességnek. Nagyon hasznos lehet az USB-n és WiFi-n keresztüli internet megosztás, és az üzleti felhasználóknak is kedveztek a jobb Exchange támogatással.: • Feljavított böngésző: Flash 10.1 és akár háromszor gyorsabb JavaScript • JIT támogatás, amely a CPU igényes feladatokat 400-500 százalékkal gyorsíthatja • Stream és push támogatás • Menürendszer jobbra forgatás lehetősége • Adhoc WiFi megosztás • Teljesítménybeli és felületi javítások • Az alkalmazások nagy részét a MicroSD kártyára lehet másolni és ugyanígy vissza is lehet. • Hang alapú tárcsázás • Névjegymegosztás Bluetoothon keresztül
11
2.3. Android-verziók
2.3.7.
Android 2.3 (Gingerbread)
2010. december 6-án jelentette meg a Google az Android 2.3 Gingerbreadet és vele együtt a Samsunggal közös Nexus S telefont. A rendszer forradalmi újdonságok helyett inkább erőteljes optimalizáláson, ráncfelvarráson esett át, ugyanakkor a VoIP vagy az NFC megjelenése egyértelműen fejlődés.: • Új felhasználói interface • Nagyobb felbontású kijelzők támogatása • 2.6.35.7 Linux kernel • WebM videólejátszás támogatás • Near Field Communication támogatás • Továbbfejlesztett másolás-beillesztés funkció • Átalakított gyári virtuális billentyűzet, multitouch támogatás • Javított energiagazdálkodás, hosszabb üzemidő • Optimalizáció (gyorsabb, hatékonyabb működés) • Internethívás (VoIP) támogatása • Letöltéskezelő a hosszú ideig tartó HTTP letöltésekhez • Új szenzorok (pl. giroszkóp) támogatása és kezelése • YAFFS helyett ext4 fájlrendszer használata, jól kezelhető
12
2.3. Android-verziók
2.3.8.
Android 3.0 (Honeycomb)
2011. január 26-án mutatták be az Android 3.0 Honeycomb változatot. Ez valóban forradalmi változást hozott, hiszen nem a korábbi verziók csiszolásával készült, hanem majdnem a nulláról újraírták az egészet, mellyel a Google két, párhuzamosan fejlesztett vonalra oszotta a rendszert. A mobiltelefonok kapják a 2.x verziókat, a tablet készülékek pedig a 3.x számúakat: • Tablet PC támogatás • Újragondolt felület • Tablet PChez optimalizált kezelés (pl. átalakított, megnövelt méretű virtuális billentyűzet) • Többmagos processzorok támogatása • Teljes kompatibilitás a korábbi verziókra készült programokkal • Fejlettebb szövegkijelölés, copy-paste • USB és Bluetooth külső billentyűzet kezelése • Javított WiFi hálózatkeresés és Bluetooth tethering • Felújított, kibővített gyári alkalmazások (böngésző, kamera, galéria, névjegyzék, e-mail)
2.3.9.
Android 4.0 (Ice Cream Sandwich)
Az Ice Cream Sandwich kódnevű verziót 2011. október 19.-én mutatták be, a Google és a Samsung közös eseményén, melyen a hozzá tartozó referenciamobilt, a Galaxy Nexust is leleplezték. Az Ice Cream Sandwich újra egységesíti a táblagépeket és telefonokat, 13
2.3. Android-verziók véget vetve a Gingerbread és Honeycomb párhuzamos létezésének és a rendszerben emiatt kialakult töredezettségének. Az Android 4.0 rengeteg újítást hozott a platformra: • Tablet PC és Mobiltelefon támogatás • Újragondolt felület • Feljavított Copy-Paste funkció • Face Unlock funkció • Átméretezhető widgetek • Nagyobb felbontású kijelzők támogatása • Új böngésző, amely maximum 16 egyszerre megnyitott fület támogat • Beépített adatátviteli naplózási funkció
2.3.10.
Android 4.1 (Jelly Bean)
• Nagy felbontású névjegy képek • Továbbfejlesztett kamera kezelőfelület • Továbbfejlesztett hang alapú keresés • Google Now • Offline diktálás • Project Butter - gyorsabb, optimalizáltabb kezelőfelület
14
2.5. Az alkalmazások komponensei
2.3.11.
Android 4.2 (Jelly Bean)
A verzió számos újítást tartalmaz, ennek ellenére a kódneve még mindig Jelly Bean maradt.: • Zárképernyőre helyezhető widgetek • Felhasználói fiókok (csak Tabletekre) • Gyors gépelés (javaslatot ad a szóra) • Gesztus alapú gépelés (Swype jellegű) • A Google Maps Street View-jának újdonsága a Photo Sphere, ennek segítségével 360 fokban készíthető panorámakép, nem csak horizontális, hanem vertikális irányban is.
2.3.12.
Android 5.0 (Key Lime Pie)
A rendszer legújabb változatát 2013 májusára várták a felhasználók, de a Google ezt elhalasztotta. Hivatalos lista nincs az újításokról, de szinte biztosra vehető, hogy tartalmazni fogja a beépített video chat lehetőségét, amit a konkurensek már rég óta támogatnak és a multitasking terén is előrelépésekre lehet számítani.
2.4.
Google Play
A Google Play (régebben Android Market) 2008. októberétől érhető el a felhasználók számára. Ez a Google által fejlesztett és karbantartott rendszer az alkalmazások publikálásának elsődleges felülete az Androidos készülékek számára. A legtöbb Androidos készüléken előre telepített alkalmazás, mely a Google-azonosító megadásával használható. A Google Play-re bárki tölthet fel alkalmazásokat, ehhez csak regisztrálni kell magát a Google-nél. A Google Play-re feltöltött alkalmazások két nagy kategóriába sorolhatók: ingyenesek és fizetősök. A fizetős alkalmazások bevételéből 70% a fejlesztőé, 30% pedig a szolgáltatóé és a fizetést biztosító cégé. A fejlesztő beállíthatja, hogy az adott alkalmazás milyen készülékeken futtatható, így a felhasználók csak a saját készülékükön működő programokat láthatják. A Google Play webes felületen keresztül is elérhető, még egyszerűbbé téve a temérdek alkalmazás közötti navigációt. 15
2.5. Az alkalmazások komponensei
2.5.
Az alkalmazások komponensei
Az Android alkalmazások nagyon összetettek, tartalmazhatnak háttérben futó folyamatokat és különféle események által indított komponenseket is. Minden általános alkalmazás egy saját biztonságos környezetben fut, minden processznek saját virtuális gépe van, így elkülönülten fut a többitől. A biztonságos környezet azt jelenti, hogy az alkalmazások, csak azokhoz a komponensekhez férhetnek hozzá, amelyek a futásukhoz szükségesek és nem használhatnak olyan rendszerszolgáltatásokat, amelyekhez nincs jogosultságuk. Ezeket a jogosultságokat az alkalmazás fejlesztőjének kell megjelölnie, és a felhasználók a telepítés előtt ezt jóvá kell hagyják, így elkerülhetők a visszaélések. (pl.:háttérben a telefon funciót használó programok) A memóriakezelés rendkívül fontos az Android rendszer esetében is. Alapértelmezetten a rendszer engedi futni a háttérben az alkalmazásokat, hogy a felhasználó számára gyorsan elérhetőek legyenek. Azonban, ha a rendelkezésre álló memória csökken, egy prioritás sornak megfelelően leállítja a kevésbé fontos processzeket, hogy az éppen előtérben lévő alkalmazás zökkenőmentesen futhasson. Az Android alkalmazások több különböző komponensből épülhetnek fel, ezek közül egy is elég a működéshez. A különböző komponenstípusok különböző célt szolgálnak, legfőbb céljuk, hogy egyedi felületet biztosítanak, melyen keresztül a rendszer el tudja indítani őket. Az Android négy fő komponens típust támogat, minden típusból több is lehet egy alkalmazásban. Minden komponens különböző feladatokat lát el és önállóan aktiválódhatnak.
2.5.1.
Activity
Az Activity a legtöbbször használt alkalmazáskomponens, nem más mint egy képernyőn megjelenített oldal, mely a felhasználói interakciókat fogadja. Saját önálló felülettel rendelkezik, de általában egy alkalmazás több Activityt is tartalmazhat, melyek különböző feladatokat látnak el, és együtt adják az alkalmazás teljes funkcióját, de alapvetően függetlenek egymástól. Például egy e-mail alkalmazás egyik Activityje a levelek lekérésére, egy azok elolvasására szolgál, egy harmadik pedig a levélírás funkciót valósíthatja meg. Általában létezik egy fő Activity ami az alkalmazás indításakor jelenik meg és ebből érhetjük el a többi specifikus feladatot ellátó komponenst, de bármely Activity is indíthat újabbakat, ha egy újat indítunk az előző leáll, de a rendszer megőrzi az úgynevezett Back Stacken. Mikor egy új Activity elindul az is rákerül a Back Stackre, és megkapja a vezérlést. A Back Stack egy veremként fogható fel, mely az Activityket tartalmazza, de mindig csak egy aktív, ha a készülék vissza gombját használjuk a legfelül lévő kikerül a stackből és az alatta lévő lesz az aktív. Az android lehetőséget biztosít arra, hogy egy alkalmazás egy másikban található Activityt elindítson, így kellő átjárhatóságot lehetővé téve köztük. Ez a fejlesztés során is
16
2.5. Az alkalmazások komponensei fontos lehetőség, hisz felhasználhatunk más, már meglévő alkalmazásokban lévő Activityket is.
2.5.2.
Az Activityk életciklusa
Az Activityk életciklusának kezelése létfontosságú, egy stabil és rugalmas alkalmazás elkészítéséhez. Az életciklus kezelése callback metódusok segítségével valósítható meg. Egy Activity alapvetően három állapot egyikében lehet: • Futó Activity: Az éppen előtérben lévő és a fókuszt birtokló Activity. • Felfüggesztett Acitivty: Egy másik Activity aktív, de ez is részben vagy a háttérben látható. Ez a Activity teljes mértékben élő, a memóriában marad és megtartja az összes információját, valamint csatlakoztatva marad az ablakkezelőhöz. Kritikus memóriaszint esetén a rendszer megszüntetheti. • Leállított Activity: Ezt az Activityt egy másik teljes mértékben fedi, így a háttérben van. Ez is élő és a memóriában marad, megtartja az összes információját, de nem csatlakozik az ablakkezelőhöz. A felhasználó számára ez az Activity nem látható, és a rendszer bármikor megszüntetheti, ha szüksége van a memóriára. Mikor egy Activity felfüggesztett vagy leállított, az Android rendszer eltávolíthatja a memóriából úgy, hogy megkéri, fejezze be a tevékenységét, vagy egyszerűen leállítja a folyamatát.
2.5.3.
Service
A Service komponens egy hosszabb ideig háttérben futó feladatot jelképez, nincs különálló felhasználói felülete, de indíthat Activityket, vagy más felületi elemeket. Például egy torrent kliens képes a háttérben működve letölteni az adatokat, miközben a felhasználó bármi mást csinálhat a telefonjával. Az Android rendszer alapértelmezetten is több különböző szolgáltatást futtat a háttérben, ez biztosítja a megfelelő működését. Az alkalmazásokban található Servicek szerepe rendkívül fontos és nagy körültekintést igényel a fejlesztésük, mert könnyen okozhatnak problémákat a háttérben futva, mint például túl gyors akkumulátor lemerítés vagy felesleges adatforgalom.
2.5.4.
ContentProvider
A ContentProvider komponens, mint ahogy azt neve is mutatja, tartalomszolgáltató komponensként működik, adatok egy halmazát kezeli. Feladata ezen adatforráshoz érkező kérések kiszolgálása. Adatot tárolhatunk a fájlrendszerben, egy SQLite adatbázisban, a weben, vagy bármely más tárhelyen amit az alkalmazásunk elér, így a ContentProvider feladata, hogy
17
2.5. Az alkalmazások komponensei a kérést intézők elől elfedje azok összetettségét és elhelyezkedését, illetve, hogy az adatokat visszaadja a kérők számára megfelelő sebességgel. A ContentProviderek hasznosak az alkalmazások számára nem megosztott adatok olvasására és írására is. Az Android rendszer beépítve is tartalmaz ContentProvidereket, például a névjegyzék.
2.5.5.
BroadcastReciever
A BroadcastReciever komponensek feladata, hogy különféle események hatására aktiválódva, valamilyen feladatot hajtsanak végre. Jellemzőjük, hogy nem rendelkeznek felhasználói felülettel, de megjeleníthetnek figyelmeztetéseket és indíthatnak más komponenseket. A legtöbb broadcast a rendszer felől érkezik (például az alacsony akkumulátor szint, a kijelző kikapcsolása, stb). Alkalmazások is indíthatnak broadcastokat, így jelezve más alkalmazások számára. Amikor egy broadcast esemény bekövetkezik az Android rendszer megvizsgálja, hogy mely alkalmazások tartalmaznak olyan BroadcastReciever komponenst, amelyet az esemény érinthet, és elindítja ezeket a komponenseket.
2.5.6.
Fragmentek
Az Android rendszer 3.0-ás (API 11) verziójában mutatták be a Fragmenteket. A Fragmentek kifejlesztésének fő célja az volt, hogy a rendszer sokkal dinamikusabb és rugalmasabb felhasználói felületek tudjon támogatni, melynek főleg a nagyobb kijelzőjű készülékeken van jelentősége. Mivel a tabletek kijelzője sokkal nagyobb, mint az okostelefonoké, több hely jut rajta a tartalomnak. A Fragmentek segítségével, olyan megoldások születhetnek, melyek jobban kihasználják a tabletek kijelzőit anélkül, hogy a programozónak bonyolult megjelenítési rangsort kéne felállítani. A Fragmentek saját felhasználói interakciókkal, hívási metódusokkal és élettartammal rendelkeznek, de mindezt egyazon Activityn belül, így sokkal dinamikusabb alkalmazásokat kapunk. Lehetőség van például, olyan alkalmazás készítésére, mely a kijelzőt két részre osztva egyiken megjeleníthet egy listát, a másikon pedig az éppen kiválasztott lista elemet anélkül, hogy az egész oldalt újra kéne tölteni. Mivel minden Fragmentnek külön elrendezése, élettartama és viselkedése van, a Fragmentek megjelenítése különböző kijelzőméretekhez igazítható, így ugyanazon alkalmazás más és más képet fog mutatni okostelefonon és tableten, de mindkettővel kompatibilis maradt, így nem kell két külön programot fejleszteni.
18
2.7. Felhasználói felület
2.6.
Az alkalmazások felépítése
Egy Android alkalmazás forrása a következő csoportokra osztható: • Metainformációk: főként az alkalmazás projektleíró manifest állománya • Erőforrások: XML-alapú felhasználói felületi elemek, XML-alapú nyelvi állományok, és különféle multimédia-elemek • Forráskód: Java-alapú forrás • Külső osztálykönyvtárak: lefordított könyvtárak, amelyeket az alkalmazás forrása felhasznál
2.6.1.
A manifest állomány
A manifest állomány legfőbb szerepe az alkalmazás komponenseinek definiálása, azaz egy olyan XML állomány, mely alapján a rendszer tudja, hogy egy adott alkalmazás milyen komponenseket tartalmaz, és milyen külső események lehetnek számára fontosak. Ezen kívül a manifest állományban találhatók az alkalmazás futtatásához szükséges minimális követelmények, valamint azok a jogosultságok amelyekre az alkalmazásnak szüksége van és deklarálja a kellő API szintet is.
2.6.2.
Erőforrás-állományok
Az Android platform egyik nagy előnye, hogy fejlesztői szinten lehetővé teszi a forráskód és a felhasználói felület kettéválasztását. Minden Android-projekt tartalmaz egy res elnevezésű erőforráskönyvtárat, amelyben XML-ben leírt erőforrások és egyéb médiaelemek (képek, hangok, UI-elrendezések, animációk, menük, témák, és szöveges erőforrások) helyezhetők el. Az erőforrások használatakor a fejlesztőkörnyezet automatikusan frissít egy R.java állományt. Ezen keresztül a Java-kódból elérhető minden azonosítóval ellátott erőforráselem. Az R.java állományban tulajdonképpen statikus int típusú változók vannak, melyek minden erőforráshoz egyedi értéket rendelnek. Az R.java állományt mindig rendszer kezeli, nem módosíthatja a programozó. Azon Activityk, Servicek és ContentProviderek, amelyekre hivatkozunk forráskódban, de nem deklaráltuk a manifest állományban nem láthatók a rendszer számára, így soha nem is futhatnak le.
2.6.3.
A forráskód
Az Android alkalmazásokat, amelyek felkerülnek a Google Play-re a készítőjükön kívül senki nem ellenőrzi, így sajnos sok a lassú vagy hibásan futó közöttük, ez pedig rontja a platform megítélését. Androidra való fejlesztéskor ezért mindenképpen fontos, hogy ismerjük a Java-konvenciókat és hatékonysági módszereket és ezeket betartva egységes, hatékony és átlátható kódot készítsünk. 19
2.7. Felhasználói felület
2.7.
Felhasználói felület
Az Android alkalmazások esetén a felhasználói felület View és ViewGroup elemekből épül fel, ezekből sokféle létezik, melyek mindegyike a View osztály leszármazottja. A View objektumok leszármazottai a widgetek, melyek teljesen implementált UI objektumok. A ViewGroup objektumok leszármazottai pedig a layoutok, melyek különféle elrendezéseket kínálnak az elemek számára. A View objektum egy olyan elem, melynek mezői az elrendezési paramétereket és a kijelző egy megadott részének tartalmát foglalja magába. Kezeli saját elrendezését, méretezését, fókusz kezelését, görgetését és képernyő érintés kezelését a kijelző megadott részén. A View a felhasználó és a az eszköz közötti interakciós pont.
2.7.1.
Android-layoutok
Az Android alkalmazások esetében a felhasználói felület kialakítása a layoutok segítségével történik. A layout szerepe, hogy megadja, hogy az elemek hogyan rendeződjenek el. Minden layout tulajdonképpen egy ViewGroup, amely a benne lévő View osztályból leszármazott felületi elemek elrendezéséért felelős. Egy ViewGroupban lehetnek további ViewGroup objektumok is, így komplex struktúrák alakíthatók ki. Egy Activityhez tipikusan egy layout tartozik, mely meghatározza az adott Activity felhasználói felületét. Mikor egy Activity fókuszt kap, a rendszer utasítja, a View hierarchia gyökér elemét, hogy végezze el a szükséges mérési és rajzolási feladatait. A legegyszerűbb layout a LinearLayout, amely egymás mellé vagy egymás alá tudja elhelyezni az elemeket. A másik gyakori layout a RelativeLayout, melyben az elemek egymáshoz viszonyított helyzetét határozzuk meg.
2.7.2.
Widgetek
A Widget egy View objektum, amely lehetőséget biztosít a rendszer és a felhasználó közti interakcióra. Az Android rendszer több elkészítet Wigetet kínál, például gombok, szövegbeviteli mezők, legnyíló menük, stb., melyekkel gyorsan felépíthető egy felhasználói felület. Használhatunk egyedi elemeket is, melyeket saját View objektum készítésével, vagy egy már létező átalakításával készíthetünk el.
2.7.3.
Menük
A menük fontos részei a felhasználói felületnek, segítségükkel elérhetjük az alkalmazás beállításait és funkcióit. A legtöbb készüléken még létezik hardveres menü gomb, melyen a legáltalánosabb alkalmazás menü érhető el, de a Google arra törekszik, hogy idővel minden fizikai gombtól megszabadítsa a készülékeket. Lehetőség van környezetfüggő menük létrehozására is, melyekel például az számítógépes egér jobb gombjához hasonló funkciókat érhetünk el.
20
2.9. Android-alkalmazás létrehozása Eclpise-ben A menük kezelik a saját eseményeiket, így nincs szükség arra, hogy mi magunk készítsünk hozzájuk eseményfigyelőt.
2.8.
A fejlesztőkörnyezet
Az Android alkalmazások fejlesztéséhez nélkülözhetetlen az Android SDK (software development kit) feltelepítése. Az SDK tartalmazza a fordításhoz szükséges eszközöket, valamint emulátorokat, dokumentációt és számos eszközt, mint például az adb-t, amivel konzolon keresztül lehet kommunikálni az Android rendszerrel. Az Android SDK telepítéséhez szükséges a JDK 6 (java development kit) megléte, hisz az Android programozási nyelv a javan alapszik, és sok megoldást importál is onnan. A fenti két csomagon kívül szükség van még valamilyen fejlesztőkörnyezetre is, érdemes az Eclipse és a Netbeans közül választani, hiszen tökéletesen alkalmasak az Android alkalmazások elkészítésére és mindkettő ingyenesen elérhető bárki számára. Mindkét esetben szükség lesz még egy plugin telepítésére is, mely összeköttetést képez az sdk és a fejlesztőkörnyezet között és így az képes lesz használni az Android-emulátort, mely nagymértékben segíti és könnyíti az elkészült alkalmazások tesztelését.
2.8.1.
Az Android-emulátor
Az Android SDK része az Android-emulátor, mely egy nagyon hasznos segítség az alkalmazás fejlesztés során. Használatával elkerülhetjük, hogy minden kisebb változtatás után feltöltsük a programot az Androidot futtató eszközünkre, ráadásul bármely Android verziót képes futtatni, így az esetleges kompatibilitási problémákat is sokkal jobban ki tudjuk szűrni. Az Android-emulátor a teljes Android rendszert emulálja, tartalmazza az Android beépített alkalmazásait, így a rendszer teljes viselkedését is megismerhetjük általa, egyetlen hátránya, hogy nem minden esetben olyan gyors, mint egy megszokott készüléken futó alkalmazás.
2.9.
Android-alkalmazás létrehozása Eclpise-ben
Miután az előző fejezet említett programokat és csomagokat feltelepítettük a számítógépre készen állunk, hogy létrehozzuk az Android programunkat. Ebben a fejezetben nagyon röviden bemutatom, hogyan kell létrehozni egy új Android projektet Eclipse alatt, és röviden írok a generált fájlokról.
21
2.9. Android-alkalmazás létrehozása Eclpise-ben
2.9.1.
Projekt létrehozása
Miután elindult az Eclipse, a Fájl menü -> New -> Java Android Project lehetőséget választva hozhatjuk létre az alkalmazásunk projektjét. Ezután az első dolgunk, hogy elnevezzük az alkalmazásunk, a projektünk, és megadjuk a package nevet. Ezek tetszőleges dolgok, de nem lehet ugyan azzal a névvel már projekt az Eclipse-ben. Még ugyan itt nagyon fontos, hogy beállítsuk, hogy milyen Android verzióra szeretnénk elkészíteni a programunkat. A minimum azt jelenti, hogy mi az a minimális Android verzió amivel még kompatibilis az alkalmazás, a target az amire főként fejleszteni szeretnénk, a compile pedig amivel az Eclipse fordítani fogja nekünk. Mivel az én alkalmazásom Fragementeket használ a megjelenítéshez, így szükséges volt, hogy az Android 4.0-át jelöltem meg minimumnak, és azt tapasztaltam, hogy ha az összes többit is ugyan arra állítom, akkor elkerülhetem a későbbi problémákat.
A nextre kattintva további beállításokat kapunk amelyeken nem érdemes átállítani semmit. Ezután jön az alkalmazásunk ikonjának a kiválasztása. Használhatjuk azokat amiket az Eclipse felkínál, de sajátot is betallózhatunk a Browse-ra kattintva. Újabb olyan menü jön, ahol érdemes a felkínáltat használni (Blank Acitvity).
22
2.9. Android-alkalmazás létrehozása Eclpise-ben Az utolsó menüben választhatjuk ki, hogy milyen elrendezést szeretnénk a Blank Activitynknek. Mint említettem, Fragmenteket használok az alkalmazásban, és tetszik, hogy a menüpontok között képernyő húzással válthatok, így a Scrollable tabs + Swipe opciót választottam, ez a lehetőség csak akkor van itt, ha előzőleg legalább 4.0-ás verziót állítottunk be.
Ezután a Finish gombra kattintva az Eclipse elkészíti a projektünket, és pár fájlt előre elkészít.
23
2.9. Android-alkalmazás létrehozása Eclpise-ben
2.9.2.
Fontosabb fájlok és mappák
Itt látható az általam készített projekt faszerkezete, ezek közül az Eclipse előre legenerálta a MainActivity.java-t, az activity main.xml-t és a strings.xml-t is. A MainActivity.java a programunk fő Activityje, ebben kellene megírni a programunk funkcióit, de mivel én Fragmenteket használok, így külön java fájlokat is létrehoztam a két Fragmentem számára. Az activity main.xml lenne felelős az alkalmazásunk kinézetéért, de mivel külön fájlokat használunk, így külön XML fájlok is kellenek hozzá. Ezekben az XML-ekben állíthatjuk be a különféle elemek elhelyezkedését layout-ok használatával. Fontos még a strings.xml fájl is, ebben átnevezhetjük a Fragmenteinket, a programunkat, és ide tölthetünk be minden szöveges információt amit aztán hivatkozással könnyen elérhetünk. A mappák közül fontos a res-ben található layout és values, valamint az src. A layout mappába kell elhelyezni azokat az XML fájlokat, amelyek az alkalmazásunk kinézetét határozzák meg A values mappában található a strings.xml, melyben szövegesen adatokat tárolhatunk. Az src mappában, azon belül is az általunk létrehozott packageben találhatóak a program működését leíró java fájlok, ha újat hozunk létre azokat is ide kell menteni.
24
3. fejezet Fejlesztői dokumentáció 3.1.
Pénznem és Mértékegység konvertáló Android alkalmazás leírás
Az általam elkészített program két Fragmentből áll össze. Ezek a Valuta és a Mértékegység nevet viselik, és közöttük a képernyő jobbra vagy balra elhúzásával lehet váltani. Elindítás után először a pénznem váltására szolgáló felület töltődik be.
A képen látható a felhasználói felület. Legfelül a program neve olvasható, az alatta lévő kékes színű sáv pedig a program két Fragmentjét mutatja. Miután megadtuk a váltani kívánt összeget, két lenyíló menü segítségével beállíthatjuk, hogy milyen pénznemek között szeretnénk elvégezni a konvertálást. Ezután a Váltás gombra kattintva az alkalmazás elvégzi a számításokat, majd az Eredmény mezőbe jeleníti meg a végeredményt. 25
3.1. Pénznem és Mértékegység konvertáló Android - alkalmazás leírás
A képernyő balra húzsával válthatunk a következő Fragmentre, mely a mértékegységek közötti váltás funkciót valósítja meg.
Mint látható a felhasználói felület nagyon hasonló, hiszen célom volt, hogy egyszerű és egységes kinézetet tervezzek a programnak. A különbség, hogy itt egy extra legördülő menü is jelen van, mellyel kiválasztható, hogy milyen mértékegységtípusok (hossz, terület, tömeg, stb) között szeretnénk a konvertálást elvégezni. Ezután beállíthatjuk, hogy melyik mértékegységről szeretnék átváltani, és, hogy mire, majd meg kell adni, a váltani kívánt összeget. Végül a váltás gombra kattintva a program ismét elvégzi a számításokat, és az Eredmény mezőben közli a végeredményt. A program jelenleg tíz különféle pénznem között képes váltani, ezek: • a Magyar Forint, • az Euro, • az Amerika Dollár, • az Angol Font, • a Horvát Kuna, • a Japán Yen, • a Kanadai Dollár, 26
3.2. Spinnerek • a Román Lej, • a Svájci Frank, és • a Szlovák Korona. Mértékegység típusokból ötöt ismer a programom, ezek: • a Hosszmértékek, • a Területmértékek, • a Térfogatmértékek, • a Sebességmértékek, és • a Tömegmértékek. Az egyes mértékegységeket külön nem részletezem a leírásban, hiszen túl sok lenne belőlük, és a használatuk egyszerű és magától értetődő.
3.2.
Spinnerek
Az Android programozási nyelvben a Spinnerekkel valósítható meg a legördülő menük létrehozása. Mivel az általam készített alkalmazásban több ilyen is található, így szeretném őket kicsit részletesebben bemutatni. Alapállapotban a Spinner az éppen kiválasztott elemet mutatja, megérintve a kijelzőt pedig megjeleníti a legördülő menüt, ahonnan kiválaszthatunk egy másik elemet.
27
3.2. Spinnerek A Spinnerek hozzáadása a layoutunkhoz a Spinner Objecttel történik, ezt legegyszerűbben az XML fájlban tehetjük meg egy Spinner elemmel: <Spinner android:id="@+id/spinMertek" android:layout_width="wrap_content" android:layout_height="wrap_content"/> Mint látható meg kell adnunk egy azonosítót (id), hisz később ezzel tudunk hivatkozni a Spinnerre. Minden XML-ben megadott eleme esetén fontos megadni az elem szélességét és magasságát is, jelen esetben mindkettő úgy van beállítva, hogy a spinner tartalmához igazodjon. Miután létrehoztuk a Spinnerünket be kell jegyeznünk abban a java fájlban, amiben használni szeretnénk, ezt az esetünkben a következő módon tehetjük meg: final Spinner spinMertek = (Spinner)rootView.findViewById(R.id.spinMertek); Ezzel a sorral egy változóhoz rendeljük hozzá a Spinnerünket. Ez egy azonosítási metódousnak tekinthető, mely megkeresi a megadott elemet az id alapján, amit még az XML fájlban adhattunk meg. A Spinnerek feltöltése többféle módon is megtörténhet: • Statikus adatok hozzárendelés XML fájlban • Spinnerek dinamikus feltöltése • Statikus adatok hozzárendelése Java fájlban Ezek közül én az első kettőt alkalmaztam a programomban, így azokat fogom bemutatni saját példán keresztül.
3.2.1.
Statikus feltöltés XML fájlban
Ez a módszer talán a legegyszerűbb és leggyorsabb módja egy spinner feltöltésének, és tökéletesen alkalmazható, ha a Spinnerünkön megjelenő adatok nem változnak a program futása közben. Nem kell mást tennünk, mint az adatokból létrehozni egy string-array elemet a Strings.xml fájlban: <string-array name="mertekegysegek">
- Hossz
- Terület
- Térfogat
- Sebesség
- Tömeg
28
3.2. Spinnerek Ezután az XML fájlunkban létrehozzuk a Spinner elemet, de a fent bemutatott példához még egy plusz sort kell írnunk: <Spinner android:id="@+id/spinMertek" android:layout_width="wrap_content" android:layout_height="wrap_content" android:entries="@array/mertekegysegek"/> Az utolsó sor segítségével, a Strings.xml fájlban létrehozott egyszerű string tömböt hozzárendeljük a Spinnerünkhöz és a rendszer elvégzi a feltöltést. Végül, ha a használni kívánjuk a Spinnert már csak a bemutatott módon be kell jegyezni a java fájlba és létre is hoztuk a saját adatokkal feltöltött legördülő menünket.
3.2.2.
Spinnerek dinamikus feltöltése
Ez a megoldás nagyon hasonló az előbbihez. Itt is létehozzuk a különféle string tömböket a Strings.xml fájlban, de ezuttal nem az XML-ben rendeljük hozzá a Spinnerhez, hiszem most az a cél, hogy a Spinnerek tartalma aszerint változzon, hogy a felhasználó mit választott ki az előbb bemutatott Mertek nevű Spinneren. Miután létrehoztuk a tömböket és az XML fájlban a Spinnereket, a java fájlban be kell őket jegyezni, valamint az én esetemben egy figyelőt kell hozzáadni a Mertek nevű Spinnerhez: spinMertek.setOnItemSelectedListener(new OnItemSelectedListener() Ennek a figyelőnek írjuk felül az OnItemSelected metódusát a következő módon: if(spinMertek.getSelectedItem().toString().equals("Hossz")){ ArrayAdapter
adapterRol = ArrayAdapter.createFromResource(getActivity() .getApplicationContext(), R.array.hosszmertek, android.R.layout.simple_spinner_item); adapterRol.setDropDownViewResource(android.R.layout .simple_spinner_dropdown_item); spinMertekrol.setAdapter(adapterRol); A kódrészlet egy feltételvizsgálattal kezdődik, a kiragadott részben azt az esetet nézzük meg, ha a felhasználó hosszmértékeket szeretni átváltani. Először létre kell hozni, egy ArrayAdapter adaptert, mely egy tömböt tesz a rendszer számára láthatóvá. A CreatFromResource metódusban adjuk meg, hogy ebben az esetben a tömböt a hosszmertek nevű string tömbből szeretnénk feltölteni. Ezután megadjuk, hogy az adapterünk egy egyszerű lenyíló menü megjelenésű legyen. Végül hozzárendeljük az adapterünket a Mertekrol nevű Spinnerhez. Ugyan ezt a metódust használtam az összes többi eset kezelésére is az alkalmazásomban. 29
3.3. Mertek.java
3.2.3.
Statikus adatok betöltése Java kódban
Ez a harmadik esete a Spinnerek feltöltésének, akkor érdemes használni, ha nagyon kevés adatot szeretnénk betölteni a Spinnerbe. Én ezt nem alkalmaztam, így csak egy általános példát írok le: spinner = (Spinner) findViewById(R.id.spinner); List<String> list = new ArrayList<String>(); list.add("első elem"); list.add("második elem"); list.add("harmadik elem"); ArrayAdapter<String> dataAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item, list); dataAdapter.setDropDownViewResource(android.R.layout .simple_spinner_dropdown_item); spinner.setAdapter(dataAdapter); Ahogy a kódrészletben látható, ebben az esetben is első lépésként be kell jegyeznünk a már létrehozott Spinnerünket a java fájlba. Ezután létrehozunk egy listát azokkal az elemekkel, amiket a Spinnerünkre fel szeretnénk tölteni. Végül ugyan úgy létrehozunk egy ArrayAdapter adaptert, mint az előbbi példában, de most a list nevű listát rendeljük hozzá.
3.3.
Mertek.java
A Mertek.java fájlom valósítja meg a mértékegységek közötti konvertálás funkcióját az alkalmazásomban. Az előbbiekben már bemutattam a Spinnereket, és azok feltöltésének módját. Azokon kívül az állomány tartalmaz még egy gombot és két szövegdobozt. Ebben a fejezetben azt fogom bemutatni lépésről lépésre, hogy hogyan is működik az átváltás folyamata. Legelső lépés az, hogy létrehozzuk a gombot, és a két szöveges mezőt az XML fájlban. <Button android:id="@+id/buttonMertek" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="@string/valt" android:layout_gravity="center"/> Gombot a Button elem segítségével hozhatunk létre. A kód nagyon hasonló az előbbiekhez, annyi különbséggel, hogy kötelezzük a rendszert arra, hogy a képernyő közepére helyezze el a gombunkat, ezt a layout gravity attribútumon állíthatjuk be.
30
3.3. Mertek.java <EditText android:id="@+id/textMertek" android:inputType="numberDecimal" android:layout_width="fill_parent" android:layout_height="wrap_content"/> A szöveges mezőt az EditText elemmel készíthetjük el. Itt a szélességet olyanra állítottam, hogy kitöltse a szülőjét ami maga a LinearLayout, és így a kijelző teljes szélességét eléri. Az inputType attribútumot azért állítottam be numberDecimal-ra, hogy bevitel során csak számokat fogadjon el a rendszer, de azokat akár tizedes formátumban is. Ezeket az elemeket valamint egy második szöveges mezőt, mely az eredmény kiírására szolgál, mind be kell jegyezni a java fájlba, hogy használni tudjuk. Button buttonMertek= (Button) rootView.findViewById(R.id.buttonMertek); buttonMertek.setOnClickListener(new OnClickListener() Mint ahogyan már a Spinnereknél láthattuk, ezzel a kódrészletel bejegyeztem a gombot a java fájlba, valamint hozzáadtam egy érintés figyelőt is. Ennek az érintésfigyelőnek írtam felül az OnClick metódusát, hogy elvégezze a kívánt számításokat. if(spinMertekrol.getSelectedItem().toString().equals("miliméter")){ if(spinMertekre.getSelectedItem().toString().equals("centiméter")){ double szam = Double.parseDouble(textMertek.getText().toString()); double eredmeny = szam / 10; Ez a kis kiragadott kódrészlet azt az esetet mutatja be, mikor a felhasználó milliméterről szeretne átváltani centiméterre. Első lépésben ellenőrzi a két Spinner kiválasztott elemét, a spinMertekrol adja meg a kiindulási mértékegységet a spinMertekre pedig azt, amire váltani szeretnénk. Ezután létrehozunk két double típusú változót. A szam változó értékét beállítjuk arra a számra, amit a felhasználó a beviteli mezőbe megadott, ezt a getText() metódussal tehetjük meg. Azért van szükség az érték double típusúra alakítására, mert alapból csak stringet tudunk kinyerni és a számításokhoz fontos a double. Az eredmeny változó értelemszerűen a számítás eredményének letárolására szolgál, jelen esetben ezt egy egyszerű tízzel való osztással oldottam meg. DecimalFormat df = new DecimalFormat("#.####"); eredmenyMertek.setText(df.format(eredmeny)); Ez a két sor arra szolgál, hogy a kapott eredményt, kiirassuk az eredmény kijelzésére szolgáló szöveges mezőben, amit a setText() metódussal tehetünk meg, valamint elvégzi az eredmény négy tizedes jegyűre kerekítését. 31
3.4. Friss árfolyam adatok megszerzése
3.4.
Friss árfolyam adatok megszerzése
A szakdolgozatom fő témája egy olyan alkalmazás elkészítése volt, ami képes pénznemek között váltani, úgy, hogy mindig friss adatokat kér le az internetről. Ez az egyszerűnek tűnő feladat végül a legnehezebben megvalósítható része lett az alkalmazásomnak. Mikor elkezdtem az interneten kutatni felhasználható adatok után meglepődve tapasztaltam, hogy nem is lesz olyan könnyű dolgom mint szerettem volna. Célom volt, egy olyan API-t(alkalmazásprogramozási interfész) használjak, ami működik Android rendszerben és nem mellékesen ingyenesen elérhető. Ahogy egyre jobban beleástam magam a témába rájöttem, hogy ezeket a célokat nem lesz egyszerű elérni. A legtöbb fellelhető ingyenes kód PHP alapú, ami nagyon hasznos weboldalak készítése során, de sajnos még nem ismertem annyira az Android rendszert, hogy képes lettem volna ezeket felhasználni. A nagy keresőóriás, a Google is rendelkezett ilyen APIval, azonban ezek sem nyújtott megoldást számomra, mivel időközben a cég letiltotta a külső forrásból jövő kérések kiszolgálását. Hosszas keresgélés és egy kedves ismerősöm tanácsára próbáltam ki az Oanda cég APIját, ami jelenleg még béta állapotú. Sajnos ezt sem tudtam felhasználni az alkalmazásomban, mivel a béta verzió miatt még igen korlátozott számú pénznemet ismer, Magyar Forint-ról egyáltalán nem képes más valutákra váltani. Végül aztán sikerült rátalálnom egy másik nagy internetes keresőcég - a Yahoo - pénzügyekkel foglalkozó Yahoo Finance nevű moduljára, és ennek segítségével végre meg tudtam oldani a friss árfolyam adatok lekérését.
3.4.1.
Yahoo Finance Exchange Rates
Az Yahoo egy hatalmas internetes cég, mely kezdetben a Googlehoz hasonlóan a keresőmotorjával vált híressé, de azóta számos funkcióval bővült a weboldaluk, mint például az internetes levelezésre használható Yahoo Mail, és ami számomra fontos volt, a pénzügyekkel és árfolyamokkal foglalkozó Yahoo Finance. A Yahoo Finance többek között: • friss, naprakész árfolyam adatokat biztosít különféle pénznemekre és nemesfémekre, • több évre visszamenő adatokat tárol és tesz elérhetővé, 32
3.5. Valuta.java • valamint követi a nemzetközi tőzsdepiacot Nekem ezek közül csak az első funkció volt igazán lényeges, így csak a Yahoo Finance Exchange Rates adatait használtam fel az alkalmazásomban. Sajnos a cég nem biztosít erre külön API-t, de az árfolyamok lekérésére egy egyszerű GET metódussal történik, így könnyen implementálható volt az alkalmazásba: http://download.finance.yahoo.com/d/quotes.csv?s=EURUSD=X&f=l1&e=.cs Ez a kis kérés visszaadja az Euróról Amerikai Dollárra váltás árfolyamát. A felhasználásáról röviden a Valuta.java című fejezetben fogok beszélni.
3.5.
Valuta.java
A Valuta.java fájlom felelős a különféle pénznemek közötti konvertálásra az Android programomban. Ezt a Yahoo Finance által szolgáltatott adatok segítségével teszi meg, a folyamatot ebben a fejezetben fogom röviden bemutatni. A kezelőfelületet már bemutattam a leírásban, a gomb, a szöveges mezők, és a Spinnerek felvétele ugyan úgy történik, mint ahogy azt a Mertek.java fejezetben már leírtam, így erre most nem térek ki. A következő kis metódus felelős a a váltószám lekérés folyamatának az elkezdéséért: private void startLekeres() { dialog = ProgressDialog.show(getActivity(), "", "Adatok lekérése. Kérem várjon...", true); rate = new GetExchangeRate(valutak[spinValutarol. getSelectedItemPosition()], valutak[spinValutara.getSelectedItemPosition()]); rate.execute((Void) null); } Mint látható első lépésben létrehoz egy kis információs ablakot, mely várakozásra kéri a felhasználót, hiszen az adatok lekérése az internetről egy kis időbe telhet. Ugyan ez a metódus adja át a két Spinner kiválasztott elemét is a GetExchangeRate osztály számára, ehhez először az elem pozícióját keresi ki és ehhez a pozícióhoz aztán a valutak nevű tömbből társít egy elemet. Ez azért fontos, mert a Spinnereken a pénznemek magyar nevei találhatók, a lekéréshez viszont három betűből álló kódra van szükség (például: HUF, USD, EUR) A GetExchangeRate osztály a végzi a lekérés és átváltás folyamatát, és ez adja vissza a végeredmény is: public class GetExchangeRate extends AsyncTask { String urlString = baseURLString; .... }
33
3.5. Valuta.java A kódrészletből látható, hogy az osztály egy AsyncTask osztály leszármazottja, erre azért van szükség, hogy az alkalmazás várjon az internetes adatok megérkezésére a számítási feladatok előtt. Az osztály a következő metódusokat tartalmazza: public GetExchangeRate(String a, String b) { urlString += a + b + "=X"; } Ez a kis kódrészlet felelős az adatok lekéréshez szükséges URL összeállításáért. Veszi az alap URL-t és hozzáfűzi a két pénznem kódját. protected Float doInBackground(Void... arg0) { return httpGetCall(urlString); } Ez a rész felülírja az AsyncTask doInBackgroud nevű metódusát, egyetlen feladata, hogy átadja az elkészített URL-t a httpGetCall-nak, mely ténylegesen felelős az internetes adatlekérésért és mindezt a háttérben futva teszi. protected void onPostExecute(Float result) { DecimalFormat df = new DecimalFormat("#.###"); eredmenyValuta.setText(df.format( Double.parseDouble(textValuta.getText().toString())*result)); dialog.dismiss(); } Az utolsó metódus felelős a végeredmény kiszámításáért, és kiíratásáért. A felhasználó által megadott összeget összeszorozza a httpGetCall által lekért váltószámmal, három tizedes jegyűre kerekíti a végeredményt, majd azt írja be az Eredmény mezőbe. Legvégül, ha elkészült a számítás megszünteti a várakozásra felkérő ablakot.
34
4. fejezet Összefoglalás A szakdolgozatom elméleti része rövid betekintést ad az Android rendszer sajátosságaiba, mind felhasználói, mind programozói szemszögből. Az Android történetét és a különböző verziókat azért tartottam fontosnak bemutatni, hogy mindenki láthassa milyen fiatal és mégis milyen nagy sebességgel fejlődő rendszerről van szó. Ezután röviden bemutatom a rendszer szerkezetét, az alkalmazások fontosabb építőelemeit és a felasználó felületet. A fejlesztői dokumentációban ismertettem az Android-alkalmazásom elkészítése során felmerült problémákat, és az azokra talált megoldásokat. A Pénznem és Mértékegység konvertáló Android-alkalmazásomat sikeresen megvalósítottam. A kitűzött feladatokat a program képes ellátni, mind a mértékegység, mind a pénzem váltó funkció működik. A program a mostanában divatos Fragmenteket használja a megjelenítés során, így bár könnyen használható, de sajnos csak Android 4.0 (Ice Cream Sandwich) vagy annál frissebb verziót futtató készüléken fut. A szakdolgozatom célját úgy érzem sikerült elérnem, hiszen megismerkedhettem az Android programok készítésével és sikeresen meg is valósítottam egyet, de most, hogy jobban átlátom a rendszert tudom, hogy még nagyon sokat kell tanulni ahhoz, hogy a Google Play-re megfelelő minőségű esetlegesen fizetős alkalmazásokat készíthessek.
35
Irodalomjegyzék [1] Ekler Péter, Fehér Marcell, Forstner Bertalan, Kelényi Imer: Android - alapú szoftverfejlesztés, SZAK Kiadó Kft., 2012 [2] Wikipédia: Android (operációs rendszer) szócikk, http://hu.wikipedia.org [3] Wikipedia: Android (operating system) szócikk, http://en.wikipedia.org [4] Android fejlesztőknek számára http://developer.android.com
készített
hivatalos
referenciaoldal,
36
Adathordozó használati útmutató A szakdolgozatom mellékletét alkotó CDn megtalálható: • a szakdolgozatom digitális (PDF) formátumban, Szakdolgozat.pdf néven, • a szakdolgozatom során elkészített Android-alkalmazás telepítéséért felelős ExchangeIt.apk, • egy szakdolgozat nevű mappa, melyben a TeX fájlok formájában megtalálható a teljes szakdolgozat külön almappákba rendezve, • valamint egy project nevű mappa, melyben az Android-alkalmazás forrásfájljai találhatóak. Az apk kiterjesztésű fájlt, bármely mínium Android 4.0-ás rendszert futtató okostelefonra felmásolva feltelepíthető, csak engedélyezni kell a külső forrásból érkező tartalmak telepítését. A TeX fájlok megnyithatók egyszerű szövegszerkesztőkkel is, de a WinEdit nevű szerkesztő sokkal jobb erre a célra. A fordításukhoz szükség van a MikTeX programcsomagra is. Az Android-alkalmazás forrása a project mappában lévő szakdolgozat mappában van. Mivel az alkalmazás az Eclpise programmal készült, célszerű importálni az egész projektet abba programba, így átláthatóbban lehet szerkeszteni és olvasni a fájlokat.
37
