Android alapú szoftverfejlesztés haladóknak oktatási segédanyag, mely a

Átírás

1 oktatási segédanyag, mely a Társadalmi Megújulás Operatív Program Határon átnyúló együttműködés a szakképzés és a felnőttképzés területén c. pályázati felhívás keretében megvalósított Mobil alkalmazásfejlesztés az informatikai tudás innovatív alkalmazásával című, TÁMOP / kódszámú projekt keretében valósult meg

2 1 Tartalomjegyzék 1. Bevezetés Telefon kezelése Emuláció Szolgáltatási információk Feliratkozás mobilhálózati eseményekre Üzenetek (SMS, MMS) Telefonhívások kezelése a háttérben Strukturált adatok kezelése SQLite jellemzők Programozott SQLite Segédosztályok Hálózati kommunikáció Mobil hálózatok elérése Wifi hálózatok elérése Wifi-Direct A HTTP és HTTPS kapcsolat XML adatok feldolgozása Külön szálon futó hálózati műveletek WebView osztály TCP/IP alapú kommunikáció Adatforgalom figyelése Helymeghatározás Helymeghatározást támogató eszközök Beállítások az Android operációs rendszerben Helymeghatározás Wifi AP-k segítségével Mobil cellainformációk a helymeghatározás szolgálatában Az Android platform geolokációs szolgáltatásai Multimédiás eszközök A kamera használata A rögzítéshez használható megoldások, jogosultságok Saját kamera alkalmazás készítése Hangok lejátszása Hangfelvételek készítése Szolgáltatások Service-ek létrehozása a Manifest állományban Started Service IntentService Bound Service Foreground szolgáltatások Szolgáltatások automatikus elindítása...68

3 1. Bevezetés 2 Jelen jegyzetben, amely az Android alapú szoftverfejlesztés kezdőknek közvetlen folytatása, már ismertnek tekintjük a platform alapjait. Feltételezzük, hogy a fejlesztőeszköz használatát, az alkalmazások felépítését, közzétételi módját sikeresen elsajátította a kedves olvasó. Ily módon a folytatásban már mélyebb vizekre evezhetünk: megtanulhatjuk a segítségével a telefonhívások kezelését, indítását, vagy értesítést kaphatunk arról, hogy ha ilyen esemény következik be a készülékünkön. Hasonló érdekességeket tartogat az SMS-ek kezeléséről, saját rövid szöveges üzenetek írásáról szóló rész is. A strukturált adatkezelést megvalósító, SQLite technikákat bemutató rész az előző anyagból megismert adattárolási technikákat bővíti ki adatbázis-képességekkel. Hogyan tudjuk kommunikációra bírni programjainkat a hálózaton keresztül? Milyen módon vegyük figyelembe alkalmazásainkban a lokalizációs információkat? Van-e esélyünk erre GPS nélkül is? Hogyan kell le- vagy feltölteni állományokat a hálózaton keresztül, s milyen adatforgalommal jár ez? A tananyag a multimédiás eszközök kihasználásáról is szót ejt: vonjuk be programjainkba a beépített kamerát, vagy épp játsszunk le zenét alkalmazásunk segítségével. Hogyan lehet háttérben futó szolgáltatásokat létrehozni, több szálon futtatni? Ezekre a kérdésekre is igyekszünk pontos válaszokat adni a jegyzet befejező részében. Célunk, hogy a jegyzet és a hozzá tartozó gyakorlati példák felhasználásával a kedves érdeklődő végül önmaga is képes legyen összetett alkalmazások fejlesztésére melyek kihasználják az Android operációs rendszer által nyújtott lehetőségeket. Ezekre a kérdésekre is igyekeznek választ adni a haladóknak szóló fejezetek. A jegyzetben szereplő példaprogramok tesztelése (hasonlóan a kezdő tananyaghoz) Android 4.1 alatt, Samsung Galaxy SIII mobilokon, illetve Samsung Galaxy Tab2 tableteken történt.

4 2. Telefon kezelése 3 Annak ellenére, hogy az Android eredetileg egy mobil operációs rendszernek készült, a kezdő jegyzetben még keveset foglalkoztunk azzal, hogy az eszközünk jó eséllyel egy mobiltelefon is egyúttal. Igaz, ez a helyzet a tabletek elterjedésével némileg megváltozott. Számos olyan Android készülék került általuk forgalomba, ami nem tartalmaz telefonhívásra alkalmas modult (Európában GSM, az Egyesült Államokban CDMA is). Természetes törekvés tehát, hogy megismerjük a rendszer telefóniával kapcsolatos részeit, de vegyük ugyanakkor figyelembe alkalmazásaink fejlesztésekor, hogy nem minden készülék tartalmaz ehhez megfelelő hardvert! A fejezet megértése igényli néhány mobiltelefonálással kapcsolatos fogalom (SIM, PIN kód, PUK kód, stb.) ismeretét. 2.1 Emuláció Kezdjük az ismerkedést azzal, hogy a saját készülékünkön, vagy az emulátoron hívást, vagy üzenetküldést szimulálunk! Ehhez a legkézenfekvőbb módszer a fejlesztőeszköz használata. A DDMS-ről (Dalvik Debug Monitor Server), azaz a hibakeresést, naplózást, portátirányítást végző eszközről már esett szó a kezdő tananyagban. A DDMS segítségével lehetőségünk van a bejövő hívások, érkező SMS üzenetek emulálására is, így megfigyelhetjük programjaink működését ilyen esetekben is. Ehhez első lépésként kattintsunk az Eclipse DDMS gombján, vagy válasszuk ki a Window/Open Perspective/DDMS menüpontot! A DDMS perspektíván belül az Emulator ablakot kell kiválasztanunk (Window/Show View/Emulator Control). Itt a Telephony Actions szakaszon a bejövő szám megadását követően a Voice-ot választva hívást (Call), az SMS-t választva bejövő üzenetet adhatunk meg (Send). 1. ábra Az Emulator Control ablak

5 4 Másik lehetőség a telnet kliens segítségével kapcsolódás akár távolról is a csatlakoztatott telefonhoz, vagy virtuális eszközhöz. Ehhez Windows XP, vagy Linux operációs rendszerek esetében a gyári telnet kliens programra, újabb Windowsok esetében pedig valamilyen külső programra van szükség. Ilyen ingyenes eszköz lehet például a putty 1 terminál program. A belépéshez meg kell adni az eszköz nevét, vagy IP címét, továbbá azt a hálózati portot, amelyen keresztül a kapcsolat felépülhet. A telnet kliens segítségével a belépés történhet például így: telnet localhost ábra Távoli belépés konzolról A telefonhívásokhoz használhatjuk a gsm call <telefonszám>, üzenetküldéshez pedig az sms send <telefonszám> <üzenet> formátumot! Segítséget a használható parancsokról, vagy az egyes parancsok paraméterezéséről a help segítségével kérhetünk. A módszerek kombinálásával akár konferenciahívást is készíthetünk! A hívásokkal és üzenetekkel párhuzamosan ellenőrizhetjük a naplót is fejlesztőeszközből, a LogCat segítségével. 1 PuTTY Download Page -

6 5 3. ábra LogCat hívás közben A könnyebb követhetőség érdekében szűrjük a listát! A hívások esetében a com.android.phone, üzenetkezeléshez a com.android.mms az alapértelmezett alkalmazás. Tekintsük át az ehhez használt szolgáltatásokat! 2.2 Szolgáltatási információk A programozott hívásokhoz, a telefonos hálózat adatainak lekérdezéséhez vezető úton elsőnek ismerkedjünk meg a TelephonyManager osztály (rendszerszolgáltatás) használatával! Az osztály az android.telephony csomag része. A feladata az eszközön elérhető telefonos szolgáltatásokkal kapcsolatos információk biztosítása. Ilyenek lehetnek például a SIM kártya telefonszáma, a hálózati operátor kódja, vagy roamingadatok is. Az alkalmazások ezen kívül fel is iratkozhatnak olyan eseményekre, amelyek a telefon állapotváltozásaival valamilyen módon összefüggenek. A szolgáltatás használatához ne példányosítsuk az osztályt közvetlenül, hanem kérjünk rá referenciát a Context.getSystemService(Context.TELEPHONY_SERVICE) segítségével, vagy a (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE) kasztoláson keresztül. Egy ilyen kódrészletre példa: TelephonyManager tm = (TelephonyManager) getsystemservice(android.content.context.telephony_service); Az információk lekérdezéséhez használható fontosabb metódusok listája: getline1number(): stringként visszaadja a készülékben lévő első SIM kártya számát.

7 6 getnetworkoperator(): megadja az aktuális beregisztrált szolgáltató (MNC, mobile network code) és ország (MCC, mobile country code) kódját, szintén string formátumban. getnetworkoperatorname(): a hálózati szolgáltató neve szöveges formában. getsimstate(): a SIM kártya jelenlegi állapota. Lehetséges értékei: o SIM_STATE_READY: a kártya hívásindításra és fogadásra kész. o SIM_STATE_NETWORK_LOCKED: a kártya zárolt, hálózati PIN szükséges a feloldásához. o SIM_STATE_ABSENT: nincs elérhető kártya a készülékben. o SIM_STATE_PIN_REQUIRED: PIN kód megadására várunk, addig csak segélyhívások érhetők el. o SIM_STATE_PUK_REQUIRED: ugyanaz, mint a PIN_REQUIRED, de PUK kódra vonatkozóan. o SIM_STATE_UNKNOWN: a kártya állapota ismeretlen. Ilyen előfordulhat például állapotváltások között. getphonetype(): Az eszköz milyen típusú mobil hanghívások átvitelére alkalmas. Lehetséges értékei: o PHONE_TYPE_GSM: jellemzően Európában használt átviteli mód. o PHONE_TYPE_CDMA: tipikusan az Egyesült Államokban, vagy Kanadában használt átvitel. o PHONE_TYPE_SIP: hangátvitel jellemzően internetes hálózaton o PHONE_TYPE_NONE: hiányzó modul. Táblagépeken előfordulhat. isnetworkroaming(): logikai igaz értékkel tér vissza, ha jelenleg roamingol a kártya. Érdemes tekintettel lenni rá adatforgalmazás esetében is, akár az alkalmazásunkban is. A fenti metódusokon túl még számos másik elérhető, a platform fejlődésével újabbak is. A mindenkori teljes listát elérhetjük az Android fejlesztői oldaláról 3. Bizonyos függvények a működésükhöz igényelhetik az android.permission.read_phone_state jogosultságot, aminek a segítségével a telefon állapotát olvasni tudjuk. API level 3, vagy ennél kisebb verziószám esetében ezt a jogot implicit is megkaphatjuk. 3 Android Developer - TelephonyManager - Manager.html

8 2.3 Feliratkozás mobilhálózati eseményekre 7 Ahhoz, hogy értesüljünk a hívásállapot változásairól, új hangposta üzenetről, vagy a GSM modul kikapcsolásáról, érdemes feliratkoznunk a minket érdeklő történésekre programunkból. Ehhez a Telephony Manager szolgáltatásunk listen() metódusával meg kell hívnunk egy saját PhoneStateListener implementációt, megadva, hogy mely események érdekelnek minket. //Saját PhoneStateListener készítése private PhoneStateListener sajatphonelistener = new PhoneStateListener() { public void oncallstatechanged(int state, String incomingnumber) { try { if (state == TelephonyManager.CALL_STATE_RINGING ) //TODO: Bejövő hívás történik catch (Exception e) { Log.i("Kivétel", "PhoneStateListener() e = " + e); //Telephony Manager szolgáltatás igénybe vétele TelephonyManager tm = (TelephonyManager) getsystemservice(telephony_service); //Feliratkozás változás-figyelésre tm.listen(sajatphonelistener, PhoneStateListener.LISTEN_CALL_STATE); A fenti példában a vizsgálni kívánt állapot a bejövő hívás esete (CALL_STATE_RINGING). Az incomingnumber értéke a bejövő hívás hívószáma. Ezen kívül még más állapotokra is kíváncsiak lehetünk: CALL_STATE_OFFHOOK: legalább egy hívás folyamatban, vagy tartásban van. CALL_STATE_IDLE: nincs hívási aktivitás Nem csupán a hanghívás, de a mobilnet állapota is érdekelhet minket. Ebben az esetben a LISTEN_CALL_STATE helyett a LISTEN_DATA_CONNECTION_STATE-et kell megadni a listen() függvénynek. Az oncallstatechanged() függvény helyett a megfelelő callback függvény neve: ondataconnectionstatechanged(int state).

9 A lehetséges TelephonyManager állapotok pedig: 8 DATA_CONNECTING: mobilnet kapcsolat felépítése folyamatban van. DATA_CONNECTED: a mobilnet felépült. DATA_SUSPENDED: a mobilnet kapcsolat felfüggesztésre került, például egy bejövő hanghívás miatt. DATA_DISCONNECTED: a mobilnet nem érhető el. 2.4 Telefonhívás kezdeményezése programból Amennyiben saját alkalmazásunk tartalmaz, vagy listáz telefonszámokat is, felmerülhet az igény, hogy egy szám kiválasztása után közvetlen is hívható legyen programunkból, ne kelljen ehhez a felhasználónak számot másolni és belépni a tárcsázó programba. Ennek megvalósításához új engedélyre, vagy engedélyekre lehet szükségünk a programunk részére. Tárcsázáshoz az android.permission.call_phone jogosultságot kell igényelnünk a manifeszt állományunkban. Amennyiben android.permission.call_privileged jogot igénylünk a futtatáshoz, akkor az alkalmazásunk képes bármilyen szám, akár segélyhívó közvetlen hívására is anélkül, hogy a felhasználónak a hívást a tárcsázó alkalmazáson keresztül előzetesen még jóvá kellene hagynia. A programozott hívás indítása legegyszerűbben egy intent küldésével lehetséges, ami megkapja a hívandó telefonszámot is. Hívás megvalósítása az ACTION_CALL intent segítségével: Intent hivointent = new Intent(Intent.ACTION_CALL); hivointent.setdata(uri.parse("tel: ")); try { startactivity(hivointent); catch (ActivityNotFoundException e) { //TODO: nem találtunk tárcsázóprogramot A tárcsázandó számot az URI tartalmazza. Üres bemenet esetében csak a tárcsázó program indul el. Amennyiben a telefon kapcsolatlistájában található személy ID-jét ismerjük, használható a következő formula is a tárcsázáshoz: Uri.parse("content://contacts/people/" + SZEMÉLY_ID)

10 9 Vészhívások indítására az intent nem alkalmas, ehhez az ACTION_DIAL-t kell használnunk. Utóbbi intent abban is különbözik az ACTION_CALL-tól, hogy bár behozza a tárcsázó programot a kívánt telefonszámmal együtt, de magát a hívást a felhasználónak kell kezdeményeznie. Egy további lehetőség az ACTION_CALL_BUTTON intent használata, ami a nevének megfelelően a tárcsázó gomb megnyomásával egyenértékű. Ez az intent tehát úgy hívja be a tárcsázót, hogy nem ad át neki hívandó számot. 2.5 Üzenetek (SMS, MMS) A hanghívásokon túl az operációs rendszer lehetővé teszi rövid szöveges, vagy multimédiás üzenetek küldését, kezelését is. SMS küldése Az ACTION_SENDTO intent segítségével lehetséges rövid üzenet küldése. A tényleges küldés az alapértelmezett SMS küldő alkalmazáson keresztül valósul meg. Az intent paraméterei: Uri.parse("sms: ") adatként. "sms_body" kulccsal az üzenet törzse extraként. A küldéshez az alkalmazásnak szüksége van az android.permission.send_sms jogosultságra. Intent smskuldintent = new Intent(); smskuldintent.setaction(intent.action_sendto); //A címzett telefonszáma smskuldintent.setdata(uri.parse("tel: ")); //Az üzenet szövege smskuldintent.putextra("sms_body", "Szia! Ez egy tesztüzenet"); try{ startactivity(smskuldintent); catch (ActivityNotFoundException e) { //TODO: Nincs alapértelmezett SMS küldő alkalmazás SMS fogadása Ahhoz, hogy rövid üzenetek fogadni tudjunk, röviden meg kell ismerkednünk az SmsManager osztállyal. Az osztály az API level 4 óta az android.telephony csomagban található, ezt megelőzően a helye az android.telephony.gsm-ben volt. A változtatás oka többek között az,

11 10 hogy az új osztály már nem csak GSM, hanem CDMA üzeneteket is kezel. A használatához először referenciát kell, hogy kapjunk az SmsManager.getDefault() segítségével. Amikor egy Androidos készülék SMS-t kap, broadcast üzenet generálódik. Ezt kell az alkalmazásunk által regisztrált saját BroadcastReceiver osztállyal elkapnunk. Az SMS üzenetek, a metaadataikkal (telefonszám, idő) együtt az intent extrái között található, pdus kulcs alatt. Az android.telephony.smsmessage.createfrompdu() metódusnak a fenti bájt tömböt odaadva tudjuk az eredeti üzeneteket és a metaadatokat könnyen lekérdezni. Az SmsMessage osztály (hasonlóan az SmsManager osztályhoz) API level 4 óta érhető el a fenti helyen, korábban az android.telephony.gsm csomagban volt. A fogadáshoz a programnak android.permission.receive_sms jogosultság bejegyzésére is szüksége van. SMS fogadása tehát: public class IncomingSMSReceiver extends BroadcastReceiver { private static final String SMS_RECEIVED "android.provider.telephony.sms_received"; public void onreceive(context context, Intent intent) { if (intent.getaction().equals(sms_received)) //SMS érkezett { SmsManager sms = SmsManager.getDefault(); Bundle csomag = intent.getextras(); if (csomag!= null) { Object[] pdus = (Object[])csomag.get("pdus"); SmsMessage uzenet = null; for (int i = 0; i < pdus.length;i++) { uzenet=smsmessage.createfrompdu((byte[])pdus[i]); //Az üzenet törzse String torzs = uzenet.getmessagebody(); //Az üzenet feladója String felado = uzenet.getoriginatingaddress(); //for vége //if vége //SMS érkezett vége //onreceive vége //class vége

12 MMS küldése 11 Az ACTION_SEND intent segítségével nem pusztán üzenet, de adat továbbítása is lehetséges. Ezt kihasználva fájlt, például képet csatolhatunk a szöveges üzenet mellé. Ugyanazon android.permission.send_sms jogosultság szükségeltetik itt is, mint az SMS küldés esetében. A küldéshez szükséges teendők: A címzett telefonszáma extra, amit az address kulcs határoz meg. Az üzenet szintén extra, sms_body kulcs rejti. Az intent adat a csatolt fájl útvonala lesz, Uri.parse-ban megadva. settype() határozza meg a csatolás típusát. Az intent adatfolyamát az EXTRA_STREAM-ben is meg kell határozni (csatolt fájl útvonala). Példaprogram MMS küldésére: File csatoltfajl = new File("útvonal\képfájl_neve.jpg"); Uri csatolasutvonala = Uri.parse(csatoltFajl.toString()); Intent mmskuldintent = new Intent(); mmskuldintent.setaction(intent.action_send); mmskuldintent.putextra("address", " "); mmskuldintent.putextra("sms_body", "Szia! Csatoltam egy jó képet!"); mmskuldintent.setdata(csatolasutvonala); mmskuldintent.settype("image/jpg"); mmskuldintent.putextra(intent.extra_stream, csatolasutvonala); try{ startactivity(mmskuldintent); catch (ActivityNotFoundException e) { //TODO: Nincs alapértelmezett MMS küldő program 2.6 Telefonhívások kezelése a háttérben A 2.3 fejezetben láttunk már példát bejövő hívás kezelésére. A módszer azonban csak akkor működőképes, ha az alkalmazásunk futó állapotban van. Ahhoz, hogy a háttérben is megbízhatóan teljesítő alkalmazást készítsünk, érdemes saját BroadcastReceiver osztályt készíteni az üzenet elfogásához. Röviden a szükséges teendők és információk:

13 12 Természetesen az android.permission.phone_state engedélyre szüksége van az alkalmazásnak. A szükséges intent-filter az android.intent.action.phone_state. Az intent extrái között kapjuk meg a hívással kapcsolatos információkat: o A TelephonyManager.EXTRA_STATE jelzi az új állapotot. o A TelephonyManager.EXTRA_STATE_RINGING jelzi a csörgést. o A hívó száma a TelephonyManager.EXTRA_INCOMING_NUMBER-ben található. o Az EXTRA_STATE_OFFHOOK állapot jelzi, hogy a hívás felépült a két fél között. o Az EXTRA_STATE_IDLE pedig az az állapot, amikor a hívás elutasításra kerül. Szükséges tehát egy osztály, ami BroadcastReceiver lesz, ebben valósítjuk meg az onreceive metódust, ami a következőképpen nézhet ki: public void onreceive(context context, Intent intent) { String state = intent.getstringextra(telephonymanager.extra_state); if(state.equals(telephonymanager.extra_state_ringing)){ // Csörög a telefon, a bejövő szám a // TelephonyManager.EXTRA_INCOMING_NUMBER-ben van else if(state.equals(telephonymanager.extra_state_offhook)){ // A hívás fogadva else if (state.equals(telephonymanager.extra_state_idle)){ // A hívás eldobva, vagy elutasítva Nyilván a saját BroadcastReceiver osztályt is be kell jegyezni a manifeszt állományban statikusan (vagy dinamikusan a Context.registerReceiver() segítségével): <receiver android:name= SajátBroadcastReceiverOsztályNeve > <intent-filter> <action android:name= android.intent.action.phone_state /> </intent-filter> </receiver>

14 13 Hasonlóan bánhatunk a kimenő hívások kezelésével is. Annyi eltéréssel kell számolnunk a bejövő hívásokhoz képest, hogy ezúttal nem beérkező, hanem hívott számról beszélhetünk. Ennek a helye a TelephonyManager.EXTRA_PHONE_NUMBER lesz, ezúttal is az intent extra részében. További eltérés, hogy a megcélzott esemény nem az android.intent.action.phone_state lesz, hanem az android.intent.action.new_outgoing_call. Az ehhez szükséges jogosultság is meg fog változni, ezúttal az android.permission.process_outgoing_calls lesz az, amire szüksége van az alkalmazásunknak. public void onreceive(context context, Intent intent) { String state = intent.getstringextra(telephonymanager.extra_state); if(state.equals(telephonymanager.extra_state_ringing)){ // Kicsöng a telefon, a hívott szám a // TelephonyManager.EXTRA_PHONE_NUMBER-ben van A hozzátartozó BroadcastReceiver bejegyzés pedig: <receiver android:name= SajátBroadcastReceiverOsztályNeve > <intent-filter> <action android:name= android.intent.action.new_outgoing_calls /> </intent-filter> </receiver>

15 3. Strukturált adatok kezelése 14 A kezdő jegyzetben már tanulhattunk arról, hogyan kell alkalmazásunk adatait perzisztens módon tárolni. Az a fajta, fájl szintű, vagy egyszerű kulcs-érték párokon alapuló technika a hozzáférés módját is korlátok közé szorítja. A mobil eszközök teljesítményének a növekedésével természetes igénnyé vált, hogy hordozható készülékeinken is megvalósuljon olyan minőségű keresés és szelektálás adataink között, ami már adatbázis-kezelő program használatát is igényelheti. Szerencsénkre az Androidra gyárilag implementált SQLite adatbázismotor lehetővé teszi, hogy ne csupán online, de a kézi eszközeinken tárolt offline adataink kezelését is fejlettebb adattárolási módszerekkel biztosíthassuk. Ebben a fejezetben elsőként a közvetlen hozzáférés megtárgyalására koncentrálunk, ezt bővítjük a későbbiekben segédosztályokkal, amik a verziókezelést is támogatják. A fejezetben feltételezzük az SQL adatbázisokkal kapcsolatos alapfogalmak (kulcsok, tulajdonságok, SQL utasítások) ismeretének meglétét. 3.1 SQLite jellemzők Az SQLite teljes értékű relációs adatbázis-kezelő, ami viszont nem támogat objektum-relációs réteget az adatbázis fölött (ORM, Object Relational Mapping) noha kiegészítésként írtak már rá ilyet, lásd ORMLite, greendao -, ezért az adatokhoz tartozó sémát és lekérdezéseket nekünk kell megírni a programban. Maga az SQLite nem külön folyamatként, hanem a saját alkalmazásunk részeként fog futni. Ily módon az adatbázist tartalmazó fájl is alapesetben csak a mi programunk számára lesz elérhető. Az Android rendszerben jelenleg elérhető SQLite3 által közvetlenül támogatott adattípusok a következők 4 : INTEGER: előjeles egész 1,2,3,4,6 vagy 8 byte hosszon, a tárolni kívánt érték nagyságának függvényében REAL: lebegőpontos értékekhez, 8 byte-on TEXT: UTF-8, vagy UTF-16-ban tárolt szöveg BLOB: adatsorozatok, fájlok tárolásához használt típus NULL: üres érték tárolására Sajnos a logikai, az idő és a dátum adatok tárolására csak a fenti típusokkal közvetve van lehetőség. 4 Datatypes in SQLite Version 3 -

16 15 Támogatott az autoincrement tulajdonság, amivel például kulcsok automatikus értékadása válik kényelmessé. Az SQLite-hoz közvetlenül hozzáférhetünk konzolról, például debuggolás céljából. Erre a célra az Android SDK tools könyvtárában található programot használhatjuk. Ehhez a következő lépésekben juthatunk el: Nyissuk meg a parancssort, amennyiben a keresési útvonalban nem szerepelne, úgy keressük meg az adb parancsot az SDKban! Az adb devices futtatásával ellenőrizzük le, hogy fut legalább egy virtuális eszköz, vagy van csatlakoztatva Android készülék a számítógéphez. Kérjünk egy parancshéjat az adb shell elindításával! Az sqlite3 futtatásával csatlakozhatunk az adatbázis-kezelőhöz. A használható parancsokat a.help segítségével listázhatjuk. 4. ábra Sqlite konzol Egy konkrét alkalmazás adatbázisának megtekintéséhez érdemes a program saját könyvtárában az adott adatbázist tartalmazó fájlt, mint paramétert megadva indítani az sqlite3 alkalmazást. Az Androidos címjegyzékbe (Személyek) például a következő úton léphetünk be (feltételezve, hogy a shell-be már beléptünk): cd /data/data/com.android.providers.contacts/databases sqlite3 contacts2.db (adatbázis neve) A táblákat, nézeteket a.tables parancs listázza. Standard SQL parancsok használhatók.

17 Kilépés a.exit-tel lehetséges ábra A contacts adatbázis táblái és nézetei A konzol segítségével importálni, exportálni, dump-olni is tudunk adatbázist. 3.2 Programozott SQLite Az SQLite képességeit közvetlenül kihasználni az android.database.sqlite csomag segítségével tudjuk, mivel ez tartalmazza a privát adatbázisok menedzselésével kapcsolatos osztályokat. Az itt bemutatásra kerülő módszer alkalmazások között megosztott adatok kezelésére nem alkalmas. A következő példaprogram egy egyszerű, egyetlen táblából álló adatbázist kíván kezelni, amelybe az ismerőseink nevét kívánjuk csupán tenni. Először is hozzuk létre az adatbázisunkat, benne egy táblával! Amennyiben már létezik a fenti adatbázis, akkor csak nyissuk meg azt! Ugyanez vonatkozik a táblára is: csak akkor hozzuk létre, ha első alkalommal futtatjuk a programunkat. A könnyebb behelyettesíthetőség érdekében az adatbázist tartalmazó fájl és a tábla nevét tároljuk változókban! Az adatbázisfájl nevénél nem kötelező konvenció a.db kiterjesztés használata. Az adatbázist tartalmazó fájlt az openorcreatedatabase() metódussal készíthetünk, SQL utasítást pedig az execsql()-el tudunk futtatni. //Az adatbázist tartalmazó fájl és tábla neve

18 final static String ADATBAZIS_NEVE = "adatbazis.db"; final static String TABLA_NEVE = "ismerosok"; 17 //Az adatbazis neve a programunkban SQLiteDatabase adatbazis; //Hozzuk létre az adatbázisfájlt, vagy ha már létezik, nyissuk meg! adatbazis = openorcreatedatabase(adatbazis_neve, SQLiteDatabase.CREATE_IF_NECESSARY, null); //Az execsql segítségével tetszőleges SQL parancsot //futtathatunk, itt arra használjuk, hogy a táblát létrehozzuk. adatbazis.execsql("create TABLE IF NOT EXISTS " + TABLA_NEVE + "(id INTEGER PRIMARY KEY AUTOINCREMENT, nev TEXT )"); Adat beszúrása a táblába Az SQLiteDatabase osztály insert() metódusával tudunk új adatot felvinni frissen létrejött táblánkba. Három paramétert igényel a működése: A tábla neve, ahová beszúrunk. Null érték: az úgynevezett nullcolumnhack helye, mivel teljesen üres (NULL) sort nem enged beszúrni úgy, hogy legalább egy attribútum (oszlop) nevét nem adtuk meg. Érték: a kulcs az oszlop neve, az érték pedig a hozzátartozó beszúrandó elem lesz. A beszúrás eredményeként visszaadott érték a sorazonosító (row ID) lesz, vagy -1, ha a beszúrás valamiért nem sikerült. Az értékpár tárolásához használhatunk például ContentValues példányt. ContentValues ertekpar = new ContentValues(); ertekpar.put("nev", "Janos"); long uj_id = adatbazis.insert(tabla_neve, null, ertekpar); Adat törlése a táblából Ugyanezen osztály delete() metódusa szolgálhat hagyományosan egy, vagy több sor törlésére a táblánkból. A futtatásához szükséges paraméterek: A tábla neve, ahonnan törlünk.

19 18 whereclause: opcionális feltétel, ami az SQL WHERE utasításrészének felel meg. Elhagyható, ilyenkor null-t adjunk át. Amennyiben adtunk meg feltételt, annak paramétereit szöveges tömbben adhatjuk át. Feltétel hiánya esetén itt is null adható meg. A metódus visszaadott értéke azon sorok száma, amelyekre vonatkozik a feltétel, más esetben 0-t kapunk vissza. Amennyiben adunk meg feltételt, abban a paraméterek helyét a? segítségével tudjuk megadni. A következő programrészlet azokat a sorokat fogja törölni a táblából, amelyeknek az ID mezője 2 és 4 közötti. String[] parameter = new String[2]; parameter[0] = "2"; parameter[1] = "4"; adatbazis.delete(tabla_neve, "ID BETWEEN? AND?", parameter); Adatok módosítása a táblában A törléshez kicsit hasonló módon kell meghívni a módosításhoz szükséges update() metódust is. A különbség abban van, hogy itt az új értékeket is meg kell adni, amire a feltételnek eleget tevő sorok módosulni fognak. Az update() paraméterei tehát: A módosítandó tábla neve. Az értékek, amire módosítunk. Feltétel, amely a módosítandó sorokat kijelöli. Null megadása esetén valamennyi sor módosulni fog. Feltétel esetében szöveges paramétertömb. A visszatérési érték a módosított sorok száma lesz. ContentValues ujertekpar = new ContentValues(); ujertekpar.put("nev", "Géza"); adatbazis.update(tabla_neve, ujertekpar, "nev LIKE?", new String[]{"János" ); Ez a kis kódrészlet a János nevű ismerőseinket kereszteli át Gézára. A paramétertömb ezúttal nincs külön deklarálva és csak egyetlen elemű.

20 Adatok lekérdezése az adatbázisból 19 A lekérdezésekhez a névtúlterhelt query()használható, amely szabványos kurzort ad vissza a lekérdezés eredményeként. A query() tipikus paraméterlistája: A lekérdezéshez használt tábla neve. A lekérdezésben részt vevő oszlopok szöveges tömbként ábrázolva. Ha null-t adunk meg, valamennyi benne lesz az eredményben. Feltétel, hasonlóan az előzőekhez. Ha paramétereket is kívánunk benne megadni, azok helyét itt is a? jelöli. Null megadásakor valamennyi sor részt vesz a lekérdezésben. Feltétel megadása esetében szöveges paramétertömb, annak hiányában null. Csoportosító szűrő: az SQL GROUP BY utáni része, szövegesen. HAVING szűrő szövegesen formában. Sorba rendező szűrő (ORDER BY). LIMIT szűrő: a lekérdezés sorainak számát korlátozó beállítás. Az utolsó négy paraméter is opcionális, hiányukat null jelöli. Összetett, nem egyetlen táblát használó lekérdezésekhez használhatjuk a rawquery() metódust is. Az eredményül szolgáló kurzor az android.database.cursor osztályból származik. Néhány hasznos metódusát nem árt megismerni: getcount(): a kurzorban lévő sorok száma. getposition(): a kurzor jelenlegi sorpozíciója. getcolumncount(): a kurzorban lévő oszlopok száma. getcolumnnames(): szöveges tömbbe kerül az összes oszlop neve. islast(): visszaadja, hogy a kurzor az utolsó soron áll-e. isafterlast(): a kurzor az utolsó sort is feldolgozta? movetofirst(): az első sorra viszi a kurzort. movetonext(): a következő sorra lépteti a kurzort. gettype(): a paraméterként megadott sorszámú oszlop típusát szövegesen visszaadja. getint(), getfloat(), getstring(), stb: a paraméterükben megadott számú oszlopban lévő aktuális értéket adja vissza a metódus nevében megadott típusként. A kurzor által használt terület felszabadítását a close() metódus biztosítja.

21 20 A következő kis programrészlet kiíratja a LogCat naplójára azoknak az ismerősöknek az ID-jét és nevét, akiknek az azonosítója 1-nél nagyobb. // A lekérdezéshez szükséges feltétel eredménye Cursor kurzor = adatbazis.query(tabla_neve, null, "id>?", new String[]{"1", null, null, null); //A kurzort az első sorra állítjuk a biztonság kedvéért. kurzor.movetofirst(); //Ciklussal a kurzor valamennyi sorát feldolgozzuk. do { //Kitesszük a LogCat naplójába a lekérdezés eredményét. //Feltételezzük az adott számú és típusú adatokat //tartalmazó oszlopokat. Log.d("ismerosok", "ID: " + kurzor.getint(0) + ", nev: " + kurzor.getstring(1)); //Ha kész, a kurzor menjen tovább. kurzor.movetonext(); //Túl vagyunk már az utolsó soron? while(!kurzor.isafterlast()); //Ne felejtsük el bezárni. kurzor.close(); Egyéb adatbázis műveletek futtatásához (ALTER, DROP) használhatjuk a már korábban megismert execsql() metódust! Adatbázis-műveleteink eredményét a fejezet elején tárgyalt sqlite3 segédprogrammal is leellenőrizhetjük. 3.3 Segédosztályok Az adatbázisok verziókezelt menedzseléséhez, létrehozásához, frissítéséhez használhatjuk a Google által is ajánlott SQLiteOpenHelper osztályt. Ebből származtatva olyan saját osztályt hozhatunk létre, ami referenciaként szolgálhat a későbbiekben a teljes adatbázisnak. Konstruálása: SQLiteOpenHelper(Context kontextus, String név, SQLiteDatabase.CursorFactory kurzortípus, int verzió); A konstruktor paraméterei: Kontextus: az alkalmazás környezete. Név: az adatbázisfájl neve, null esetén memória-adatbázist épít.

22 21 Kurzortípus: saját kurzorimplementáció megadása, alapesetben pedig null. Verzió: folyamatosan növekvő verziószámmal kell az adatbázis újabb változatatait ellátni. A helper osztályunk létrehozásakor kötelezően felülírandó (absztrakt) osztályok az oncreate() és az onupgrade(). Mindkét metódus void típusú. Az oncreate() az adatbázis első létrehozásának alkalmával használandó. Itt érdemes megcsinálni azt az utasítássorozatot, ami a kívánt adatbázis-sémát létrehozza. Az onupdate() metódus mondja meg, mi történjen az adatbázissal egy adott korábbi verzióról egy adott új verzióra történő átállás esetén. Amennyiben semmiképp nem tudjuk a régi verzió adatbázis-sémáját az újjal összeegyeztetni, ezen a ponton akár a régi adatbázis-séma el is dobható, az új létrehozása előtt. Ebben az esetben természetesen a frissítés gyakorlatilag a régi adatok elvesztését is jelenti egyúttal. További hasznos metódusok még: getwritabledatabase(): Létrehoz és/vagy megnyit egy adatbázist írásra és olvasásra. A megnyitást követően az adatbázis gyorsítótárazva lesz. Hiányzó jogosultságok, vagy telítődött tároló a hívás meghiúsulását okozhatják. A használatot követően a close() metódussal kell lezárni az adatbázist. getreadabledatabase(): Hasonlít az előzőhöz, az előbbiekben említett problémák esetében az adatbázis általában még olvasásra megnyitható. A sémával kapcsolatos megjegyzés: noha egy táblának nem szükségszerűen kell egyedi azonosítót tartalmazni, de ilyen létrehozása nemcsak ajánlott, de célszerű azt _id néven hivatkozni. Ennek a magyarázata az, hogy a későbbiekben amennyiben ListViewval kívánjuk összekötni az adatokat, az oszlop között kell ilyen nevűnek lennie 5. Azokat a változókat, amelyek az adatbázis metainformációit tárolják, úgymint verziószám, adatbázis neve és mások, célszerű statikus tagváltozókba helyezni. 5 Android Developers - Content Provider Basics -

23 4. Hálózati kommunikáció 22 Napjaink mobil eszközei széles körű támogatást nyújtanak az internet eléréséhez mobil hálózatok, illetve a beépített Wifi interfészek segítségével is. Ezekhez az Android operációs rendszer is nagyon gazdag API támogatást nyújt Mobil hálózatok elérése A mobil hálózatokon keresztül történő adatforgalom kezdeti nehézségeit a 3G és 4G technológia mára már kiküszöbölni látszik, és egyre több eszköz használja az internet elérésére a szolgáltatók mobil hálózatait. A mobil hálózati kommunikáció elérésének egyik alapvető eszköze az Android rendszerben a ConnectivityManager 6 osztály. Ennek segítségével információkat kérdezhetünk le a hálózati kapcsolatokról, vagy azok változásairól, és reagálhatunk a hálózati kapcsolatokban bekövetkező eseményekre. Használata az ACCESS_NETWORK_STATE engedélyezésével lehetséges. Legelőször is érdemes leellenőrizni a hálózati kapcsolatok állapotait, hogy eszközünk milyen aktív kapcsolatokkal rendelkezik. Ehhez a ConnectivityManager osztály getnetworkinfo() függvényét célszerű használni, aminek bemenő paraméterében meg kell adnunk, hogy a wifi, vagy a mobil kapcsolatot szeretnénk lekérdezni. A kapcsolat aktív voltáról az isconnected() függvénnyel bizonyosodhatunk meg, melynek visszatérési értéke igaz, ha a kapcsolat létezik. ConnectivityManager man=(connectivitymanager) this.getsystemservice(context.connectivity_service); //Mobil hálózat elérésének vizsgálata NetworkInfo mobilinfo = man.getnetworkinfo(connectivitymanager.type_mobile); if(mobilinfo!= null && mobilinfo.isconnected()){ csatlakozva.settext(r.string.igen); else{ csatlakozva.settext(r.string.nem); 6 Android Developers - Managing Network Usage -

24 23 A kapcsolatban beálló változások esetén egy CONNECTIVITY_ACTION intent keletkezik, melyet a BroadcastReceiver osztály segítségével tudunk kezelni Wifi hálózatok elérése A Wifi hálózatok elérését a WifiManager osztályon keresztül tudjuk megvalósítani. Segítségével megtekinthetőek a már konfigurált hálózatok valamint az aktív hálózatok, de információkat szerezhetünk az elérési pontokról, fel- vagy lecsatlakozhatunk ezen pontokra, illetve lekérdezhetjük az egyes elérési pontok jelerősségét is. Használatához szükségünk van az ACCESS_WIFI_STATE és a CHANGE_WIFI_STATE engedélyezésére. Az aktuálisan aktív Wifi kapcsolatunk állapotáról a getconnectioninfo() függvény segítségével kaphatunk információkat, míg a már beállított Wifi hálózatok listáját getconfigurednetworks() függvénnyel kérdezhetjük le. ConnectivityManager man = (ConnectivityManager) getsystemservice(connectivity_service); NetworkInfo mwifi = man.getnetworkinfo(connectivitymanager.type_wifi); //Wifi hálózat elérésének vizsgálata if (mwifi!=null && mwifi.isconnected()) { WifiManager wman=(wifimanager) this.getsystemservice(context.wifi_service); WifiInfo winfo=wman.getconnectioninfo(); StringBuffer s=new StringBuffer(); //A már konfigurált Wifi hálózatok lekérése, SSID-jük kiiratása List<WifiConfiguration> conf=wman.getconfigurednetworks(); for(wificonfiguration c: conf){ s.append(c.ssid+" "); mentett.settext(s.tostring()); 4.3. Wifi-Direct A Wifi-direct az Android 4.0-ás (API 14) verziójától érhető el, és lehetővé teszi, hogy két eszköz Wifi hálózaton közvetlenül kommunikáljon Wifi elérési pont közbeiktatása nélkül. Így a Bluetooth hatótávolságánál jóval nagyobb távolságból is képes lehet két arra alkalmas eszköz kommunikálni egymással.

25 24 Használatához alkalmazásunkat el kell látni a CHANGE_WIFI_STATE, ACCESS_WIFI_STATE, és INTERNET engedélyekkel a manifest állományban. A Wifi-directet a WifiP2pManager osztály egy példányán keresztül érhetjük el. Ennek az osztálynak az initialize() metódusával hozhatjuk létre a WifiP2pManager.Channel osztályba tartozó csatornát, melyen keresztül majd a kommunikáció folyik a két eszköz között. Az elérhető Wifi-direct eszközöket, a discoverpeers() metódus meghívásával térképezhetjük fel. A megtalált eszközhöz való csatlakozáshoz, létre kell hoznunk egy WifiP2pConfig osztálybeli elemet, melybe elhelyezzük az eszköz paramétereit. A kapcsolódást a WifiP2pManager.connect() metódusával tudjuk létrehozni, amely bemenő paramétereinél kell megadnunk a korábban létrehozott csatornát és a WifiP2pConfig osztálybeli elemet. A Wifi-direct kapcsolatok kialakítása közben többféle broadcast intent keletkezhet, mint például: WIFI_P2P_STATE_CHANGED_ACTION Jelzi, hogy a Wi-Fi Peer-To-Peer kapcsolat aktív-e. WIFI_P2P_PEERS_CHANGED_ACTION Jelzi, ha az aktuális elérhető elemek listája megváltozott. WIFI_P2P_CONNECTION_CHANGED_ACTION Jelzi, ha a Wi-Fi P2P kapcsolat állapota megváltozott WIFI_P2P_THIS_DEVICE_CHANGED_ACTION Jelzi, ha az eszköz konfigurációja megváltozik. Ezeket az intent-eket a BroadcastReceiver osztály segítségével tudjunk kezelni. List<WifiP2pDevice> eszkozok = new ArrayList(); TextView wd_eszkozok = (TextView) this.findviewbyid(r.id.textview_eszkozok_data); WifiP2pManager man = (WifiP2pManager) getsystemservice(context.wifi_p2p_service); Channel csatorna = man.initialize(this, getmainlooper(), null); Button gomb_keres= (Button) this.findviewbyid(r.id.button_keres); //WifiDirect eszközök keresése gombnyomásra gomb_keres.setonclicklistener(new View.OnClickListener() public void onclick(view v) { //A discoverpeers() metódus hatására a PeerListener eseménykezelő fog végrehajtódni

26 man.discoverpeers(csatorna, new WifiP2pManager.ActionListener() public void onsuccess() { public void onfailure(int reason) { wd_eszkozok.settext(r.string.felderites_hiba); ); ); PeerListListener PLlistener = new public void onpeersavailable(wifip2pdevicelist peers) { eszkozok.clear(); eszkozok.addall(peers.getdevicelist()); A HTTP és HTTPS kapcsolat A legtöbb hálózati kapcsolattal rendelkező Androidos alkalmazás a HTTP protokollt használja adatok küldésére és fogadására, ezért érdemes ezzel egy kicsit jobban megismerkedni. Az Android tartalmazza mind a Java HTTP API-jait, mind pedig az Apache fejlesztésében megalkotott API-t is. Ezáltal a HTTP kapcsolatok széles körben támogatott elemei az Androidos rendszereknek, mely az alapvető HTTP GET és POST üzenettípusoktól kiindulva a streaming-es le- és feltöltésen keresztül egészen a HTTPS titkosított kapcsolatokig terjed. A fejlesztők a Gingerbread, azaz a 2.3-as Android verziójától a HttpURLConnection osztály használatát javasolják szemben az Apache HttpClient osztályával 7. A HTTP kapcsolat alapfeltétele, hogy alkalmazásunknak rendelkeznie kell az INTERNET engedéllyel. Ennek hiányában az operációs rendszer nem fogja engedélyezni az adatforgalmat. Célszerű az ilyen jellegű hálózati kommunikációt mindig külön szálban futtatni, hogy a lassú le vagy feltöltés ne blokkolja a felhasználói felületünket. Szintén érdemes minden esetben fokozott figyelmet 7 Android Developers Connecting to the Network -

27 26 fordítani a beérkezett válaszok HTTP státuszkódjára, amely segítségével mindig ellenőrizni tudjuk a tranzakció sikerességét. A 200-as státuszkód jelzi a sikeres műveletet. A hálózati kommunikációt megkezdése előtt pedig minden esetben ellenőrizzük, hogy egyáltalán elérhető-e a hálózat, amit a getactivenetworkinfo() és isconnected() függvényekkel tehetünk meg. A kapcsolat létrehozásához a HttpURLConnection osztály egy elemét kell létrehoznunk, majd beállítanunk a kapcsolatra vonatkozó jellemzőket, mint például az üzenet típusát a setrequestmethod() metódussal. A kapcsolatot a connect() metódussal hozhatjuk létre, aminek létrejöttét a státuszkód lekérő getresponsecode() metódussal ellenőrizhetünk. Ezután már csak egy csatornát kell nyitnunk a getinputstream() metódussal és kezdhetjük is a letöltést a távoli gépről. try{ URL url = new URL("URL címe"); HttpURLConnection httpcon =(HttpURLConnection) url.openconnection(); InputStream be=null; HttpURLConnection httpcon=null; httpcon.setconnecttimeout(1000); httpcon.setreadtimeout(1500); httpcon.setrequestmethod("get"); httpcon.connect(); be=httpcon.getinputstream(); catch(exception ex){ Az InputStream csatorna egy olvasható bájt folyamot ad át nekünk. Az olvasott adatokat a felhasználásuk célja szerint érdemes konvertálni vagy dekódolni a megfelelő formátumra. Ha például egy képet szeretnénk letölteni, akkor azt a BitmapFactory osztály decodestream() metódusával alakíthatjuk Bitmap osztálybeli képformátumra. httpcon.connect(); be=httpcon.getinputstream(); Bitmap letoltottkep=bitmapfactory.decodestream(be); Ha pedig szöveges állományt szeretnénk letölteni, akkor azt a következő módon tehetjük meg:

28 httpcon.connect(); int meret=httpcon.getcontentlength(); be=httpcon.getinputstream(); byte[] buffer = new byte[meret]; be.read(buffer); 27 Előfordulhat, hogy az URL-ben paramétert is szeretnénk átadni. Hogy elkerüljük a hibás paraméterek átadását, célszerű az URLEncoder osztály encode() metódusát használni az átadandó szövegre, amely az URL paraméterátadásnál megszokott MIME formátumra alakítja az eredeti szöveget. A HTTPS protokoll lehetővé teszi számunkra, hogy biztonságos kapcsolatot alakíthassunk ki két számítógép között. Ennek a protokollnak a használatával a kommunikációnk titkosított lesz, így az ilyen kapcsolatoknak nagy hasznát vehetjük, ha olyan alkalmazásokat szeretnénk írni - például banki alkalmazások -, ahol nem szeretnénk, ha a kommunikációnkat lehallgatnák és visszafejtenék. Használatához először generálnunk kell egy titkosított aláírást, amivel el kell látnunk alkalmazásunkat, majd ezt be kell állítanunk a szerver oldalon is. A HTTPS kapcsolat létrehozása nagyon hasonlít a HTTP kapcsolat létrehozásához, csak itt a HttpsURLConnection osztályt kell használnunk XML adatok feldolgozása A hálózati kommunikáció során az alkalmazások valamilyen szabvány formát használnak arra, hogy adataikat eljuttassák a másik félhez. Ezek közül is a leggyakrabban használt formátum az XML. Ennek segítségével a jól olvasható adatokat strukturált rendszerben tudjuk kezelni. Az Android kétféle feldolgozási módot is rendelkezésünkre bocsát az XML állományok feldolgozásához. Az első a SAX (Simple API for XML), melynek már a SAX2 verziója a használatos. Segítségével az XML állományunkat folyamatosan, a betöltés folyamán dolgozhatjuk fel az alkalmazással, és a megadott részekhez érve eseményeket válthatunk ki. A másik feldolgozási módszer már a DOM-ra (Document Object Model) alapul. Ebben az esetben a teljes XML állomány betöltésre kerül, majd a DOM által meghatározott struktúrából kérdezhetőek le a szükséges elemek. Ennek megvalósítása a DocumentBuilder és a DocumentBuilderFactory osztályokon keresztül van lehetőségünk. Ezek felhasználásával létrehozhatunk egy Document osztályba tartozó példányt, mely az XML állományunkat reprezentálja. Ennek az osztálynak a getelementsbytagname() metódusával tudjuk kikeresni az állományból a megadott nevű elemet.

29 28 //A koponyeg.hu RSS szolgáltatása által nyújtott XML állomány feldolgozása DocumentBuilderFactory fact=documentbuilderfactory.newinstance(); DocumentBuilder db=fact.newdocumentbuilder(); Document doc=db.parse(new InputSource(url.openStream())); doc.getdocumentelement().normalize(); StringBuffer seged=new StringBuffer(); //Az XML elem elérése NodeList hely=doc.getelementsbytagname("koponyeg:elhelyezkedes"); Element v=(element)hely.item(0); seged.append("régió: "+v.getattribute("regio")+"\n"); 4.5. Külön szálon futó hálózati műveletek Ha alkalmazásunk állandóan megszakítja az interaktivitását a felhasználóval a hálózati kommunikációk kényszerszünetei miatt, melyek blokkolhatják a felhasználói felületet, az komoly felhasználói élményvesztést jelent. Ennek elkerülésére, mint azt már az előbbiekben említettük, a hálózati kommunikációval járó műveleteket célszerű külön szálakon futtatni. Itt azonban felmerül az a probléma, hogy amikor a másik végrehajtási szálon a hálózati kommunikáció eredményeként beérkezett adatokat szeretnénk megjeleníteni a felhasználói felületen, azt nem engedi meg számunkra a rendszer. A probléma megoldására többféle megoldás is létezik: Activity.runOnUiThread(Runnable): Ennek használatakor a függvény Runnable objektuma által végrehajtandó folyamat hozzá tud férni a felhasználói felülethez. View.post(Runnable): Aszinkron módon frissíthetjük az adott nézet elem tartalmát. View.postDelayed(Runnable, long): ugyanaz,mint az előző, csak itt megadhatjuk a frissítés késleltetési idejét is a második paraméterben. Message-Handler mechanizmus: Itt üzenetek formájában tud információkat átadni a háttérben futó szál a főszálnak. AsyncTask: A legegyszerűbb módja, hogy újmunkafolyamatot indítsunk a felhasználó felületről. Ezt fogjuk mi is megvizsgálni közelebbről. Az AsyncTask használatakor első lépésben létre kell hoznunk egy saját osztályt, mely az AsyncTask absztrakt osztályból fog öröklődni. Ebben felül kell definiálnunk a doinbackground() metódust, megadva itt, hogy mit szeretnénk a háttérben futó szálon végrehajtatni.

30 29 Amikor egy aszinkron szál végrehajtódik, akkor négy lépésen megy keresztül: Először a felhasználói felület meghívja az onpreexecute() metódus, amellyel inicializálhatjuk a folyamatunkat, és amely a főszálban fut le. Ezt követi a doinbackground() metódus végrehajtása, amiben a tényleges feladat zajlódik, amelyet végre kell hajtani a háttérben. A doinbackground() futása alatt a publishprogress() metódus meghívásával a fő szálban futó onprogressupdate() metódussal tudunk információt küldeni a felhasználói felület felé. Végső lépésként az onpostexecute() metódus fut le a főszálban, amely segítségével a háttérszál futási eredményét tudjuk átadni, mint paraméter. Az AsyncTask osztály azon kívül, hogy absztrakt, generikus osztály is egyben. Ez azt jelenti, hogy az öröklődéskor meg lehet adni neki a hívási paraméter, a végrehajtás közben visszaadott érték és az eredmény típusát. Ha valamelyiket nem akarjuk megadni, ott a Void értéket kell átadni. Gyakran felmerülő problémát jelenthet az AsyncTask használatakor az, hogy ha a hívó Activity valamilyen oknál fogva háttérbe kerül, mielőtt még a háttérben futó szál befejeződne, akkor az Activity felhasználói felülete már nem lesz elérhető. Ilyen gyakori eset a képernyő elfordítása. Ennek kezeléséről a programozónak kell gondoskodnia. private class Adatletolto extends AsyncTask<String, Void, protected String doinbackground(string... arg0) { protected void onpostexecute(string res){ protected void onprogressupdate(void... a){

31 4.6. WebView osztály 30 Hasznos eszköz lehet a weboldalak megjelenítésére - a View osztály leszármazottja - a WebView 8 osztály, amely kizárólag egy weboldal tartamát képes megjeleníteni. Megjelenését tekintve hasonlóan működik, mint egy webböngésző, de nem található rajta sem navigációs vezérlők, sem címsor, viszont mind a CSS, mind a JavaScript kezelésére alkalmas. Használatához szükséges alkalmazásunknak az INTERNET engedéllyel rendelkeznie. Ha ilyen elemet szeretnénk alkalmazni, akkor nincs más teendőnk, mint megadni azt az Activity layout-jában, pl. a következő módon: <WebView android:id="@+id/webview_bongeszo" android:layout_width="match_parent" android:layout_height="fill_parent" android:layout_alignleft="@+id/edittext_cim" android:layout_below="@+id/progressbar_letoltes" android:layout_margintop="16dp" /> A forráskódban a loadurl() függvény segítségével adhatjuk meg, hogy milyen URL-ről töltse be a weboldalt az WebView elembe az alkalmazásunk. A WebSettings objektum segítségével szabályozhatjuk a WebView elemünk megjelenését, melyet a WebView getsettings() metódusával kérhetjük le. Ennek segítségével szabályozhatjuk az oldal megjelenését, megadhatjuk a betűtípusokat, az oldal nagyítását, a JavaScript engedélyezését és még sok minden mást is. WebView bongeszo=(webview) this.findviewbyid(r.id.webview_bongeszo); bongeszo.setinitialscale(50); WebSettings ws=bongeszo.getsettings(); ws.setjavascriptenabled(true); ws.setbuiltinzoomcontrols(true); Fontos ismételten megjegyeznünk, hogy csak és kizárólag egy weboldal megjelenítésére szolgál a WebView elem, és nem úgy működik, mint egy böngésző program. Ezt akkor érzékeljük csak igazán, ha például a megjelenített weboldal egy linkjére klikkelünk. Ennek hatására ugyanis nem a WebView elemben jelenik meg a 8 Android Developers - Building Web Apps in WebView -

32 31 linkhez tartozó oldal, hanem meghívásra kerül a rendszer alapértelmezett webböngésző programja, és abban jelenik meg a kérdéses oldal. Bár a WebView nem úgy működik, mint egy böngésző, de számos eszköz áll rendelkezésünkre, hogy hasonló működésre bírjuk. Az előbbi példa esetében egy esemény váltódik ki, ami az új URL megnyitását eredményezi, és ez az alapértelmezett webböngészőt hívja segítségül. Ezt, és még sok más eseményt is, lehetőségünk van kezelni a WebView objektumhoz tartozó WebViewClient objektum segítségével, melyben felülírhatjuk az alapértelmezett viselkedést. Például az új URL megnyitásánál a shouldoverrideurlloading() metódust kell átírnunk, ha a WebView elemen belül szeretnénk megnyitni az új oldalt is. Ezen felül a WebView támogatja az előre hátra navigálást is, melyeket a WebView goforward() és goback() függvényeivel valósíthatunk meg. További lehetőség, hogy a WebChromeClient objektum segítségével a JavaScript események egy részét is kezelni tudjuk. Felüldefiniálhatjuk többek közt az onjsalert() függvényt, amely JavaScript figyelmeztető ablakot jelenít meg, vagy az onprogresschanged() függvényt, amely az oldal letöltöttségi állapotát adja meg százalékban. ProgressBar letoltes=(progressbar) this.findviewbyid(r.id.progressbar_letoltes); //A letöltöttségnek megfelelően állítjuk be a progressbar-t bongeszo.setwebchromeclient(new WebChromeClient() { public void onprogresschanged(webview view, int progress){ letoltes.setprogress(progress); ); 4.7. TCP/IP alapú kommunikáció A hálózaton található számítógépeken futó szolgáltatásokat nem csak a HTTP protokollon keresztül érhetjük el, hanem direkten a TCP/IP protokollon keresztül is. Ebben az esetben ismernünk kell a célszámítógép IP címét és a szolgáltatásához tartozó port azonosítóját. Ezek ismeretében már kialakíthatunk úgynevezett Socket-alapú kommunikációt is. Ebben az esetben először is létre kell hoznunk a Socket osztály egy példányát, amelynél meg kell adnunk a cél számítógép IP címét és a szolgáltatás port számát. Innentől kezdve a Socket osztály