Upload
others
View
1
Download
0
Embed Size (px)
Citation preview
FAKULTETA ZA INFORMACIJSKE ŠTUDIJE
V NOVEM MESTU
D I P L O M S K A N A L O G A
UNIVERZITETNEGA ŠTUDIJSKEGA PROGRAMA PRVE STOPNJE
KLEMEN DEMŠAR
FAKULTETA ZA INFORMACIJSKE ŠTUDIJE
V NOVEM MESTU
DIPLOMSKA NALOGA
RAZVOJ MOBILNE APLIKACIJE
»OGLASNA DESKA«
ZA OPERACIJSKI SISTEM ANDROID
Mentor: izr. prof. dr. Blaž Rodič
Novo mesto, januar 2016 Klemen Demšar
IZJAVA O AVTORSTVU
Podpisani Klemen Demšar, študent FIŠ Novo mesto, izjavljam:
da sem diplomsko nalogo pripravljal samostojno na podlagi virov, ki so navedeni v
diplomski nalogi,
da dovoljujem objavo diplomske naloge v polnem tekstu, v prostem dostopu, na
spletni strani FIŠ oz. v elektronski knjižnici FIŠ,
da je diplomska naloga, ki sem jo oddal v elektronski obliki identična tiskani verziji,
da je diplomska naloga lektorirana.
V Novem mestu, dne _________________ Podpis avtorja ______________________
POVZETEK
V diplomski nalogi bo predstavljena izdelava mobilne aplikacije za operacijski sistem
Android, ki opravlja nalogo oglasne deske. Na strežniku je shranjena podatkovna zbirka, do
katere ima mobilna aplikacija dostop preko povezave JDBC. Predvideni uporabniki mobilne
aplikacije so študentje, profesorji in referat na visokih šolah. Omenjeni uporabniki lahko
koristijo mobilno aplikacijo za objavo in pregled obvestil. Mobilna aplikacija uporabnikom
pomaga pri shranjevanju podatkov, prebiranju podatkov iz podatkovne zbirke ter njihovem
urejanju. Mobilna aplikacija rešuje problem obveščanja s strani referata in profesorjev o
izvedbi predavanj ali izpitov in drugih dogodkov. V diplomski nalogi bodo predstavljeni
programski jezik Java, operacijski sistem Android, postopek izdelave mobilne aplikacije in
njeno testiranje. Testiranje izdelane mobilne aplikacije je potekalo na emulatorju pametnega
mobilnega telefona.
KLJUČNE BESEDE: mobilna aplikacija, operacijski sistem Android, podatkovna zbirka,
Java, MySQL
ABSTRACT
Diploma paper presents development of a mobile application for Android operating system,
which performs the task of bulletin board. Database is stored on server which mobile
application accesses through a JDBC connection. Intended users of mobile application are
students, professors and student office at a faculty. Users of mobile application can use it for
reading and publishing notifications. Mobile application helps user with storing data, reading
data from database and changing data in data base with help of mobile application. Mobile
application solves the problem of informing students about lectures, exams and other events.
Diploma paper presents programming language Java, Android, development process of
mobile application and tests performed on it. Testing of mobile application took place in an
smartphone emulator.
KEY WORDS: mobile application, operating system Android, database, Java, MySQL
KAZALO
1. UVOD ..................................................................................................................................... 1
2. TEORETIČNA IZHODIŠČA................................................................................................. 3
2.1 Kritični pregled literature ................................................................................................. 3
2.2 Programski jezik Java ....................................................................................................... 5
2.3 Predstavitev operacijskega sistema Android .................................................................... 8
2.4 Programiranje aplikacij za operacijski sistem Android .................................................. 10
2.5 Baze podatkov ................................................................................................................ 11
2.6 Raziskovalno vprašanje .................................................................................................. 12
2.7 Cilji raziskave ................................................................................................................. 13
3. EMPIRIČNI DEL ................................................................................................................. 15
3.1 Zasnova celotne rešitve .................................................................................................. 15
3.2 Zasnova in razvoj mobilne aplikacije ............................................................................. 16
3.3 Zasnova in razvoj centralne baze podatkov .................................................................... 18
3.4 Uporabniška dokumentacija ........................................................................................... 19
3.5 Uporabniški vmesnik ...................................................................................................... 30
3.6 Vrednotenje razvite programske rešitve ......................................................................... 59
4. ZAKLJUČEK ....................................................................................................................... 61
5. LITERATURA IN VIRI ....................................................................................................... 63
PRILOGI
KAZALO SLIK
Slika 3.1: Prijavni zaslon mobilne aplikacije brez podatkov za prijavo ................................... 20
Slika 3.2: Prijavni zaslon s podatki za prijavo v mobilno aplikacijo ....................................... 21
Slika 3.3: Zaslon z izpisi iz podatkovne zbirke ........................................................................ 22
Slika 3.4: Zaslon z gumbom »shrani obvestilo« in »odjava« ................................................... 23
Slika 3.5: Zaslon za dodajanje objave brez dodanega besedila ................................................ 24
Slika 3.6: Zaslon za dodajanje novih objav z dodanim besedilom ........................................... 25
Slika 3.7: Zaslon z dopolnjenimi izpisi iz podatkovne zbirke .................................................. 26
Slika 3.8: Zaslon s katerim se vsak nov uporabnik prijavi ali registrira v mobilno aplikacijo 27
Slika 3.9: Zaslon s podatki, ki služi kot primer za študenta ..................................................... 28
Slika 3.10: Zaslon z objavami, ki jih vidi vsak študent ............................................................ 29
Slika 3.11: Prvi zaslon mobilne aplikacije, ki prikazuje prijavni zaslon za prijavo
uporabnika in registracijski zaslon, ki prikazuje registracijo uporabnika .............. 31
Slika 3.12: Drugi zaslon mobilne aplikacije prikazuje podatke pridobljene iz podatkovne
zbirke izrisane na zaslonu ...................................................................................... 33
Slika 3.13: Tretji in obenem zadnji zaslon aplikacije prikazuje zaslon za objavo novega
obvestila ................................................................................................................. 34
1
1. UVOD
V času, v katerem živimo, imajo mobilne naprave velik vpliv na naše življenje. Zmogljivost
pametnih mobilnih telefonov je dandanes že skoraj primerljiva z zmogljivostjo osebnih
računalnikov. Poznamo veliko storitev in aplikacij za pametne telefone, katerih največja
prednost je, da jih ima uporabnik skoraj vedno pri sebi in so mu njegove storitve vedno na
voljo. Večina pametnih telefonov ima vgrajen tako sprejemnik GPS (Global Positioning
System), torej vmesnik za povezavo z brezžičnim omrežjem, kot tudi druge podobne
tehnologije, ki omogočajo posamezniku, da mobilno napravo uporablja za različne namene.
Najbolj razširjen operacijski sistem za pametne mobilne telefone je trenutno operacijski
sistem Android. Aplikacije za ta operacijski sistem so večinoma razvite z uporabo
programskega jezika Java. Pri izdelavi mobilne aplikacije je potrebno namestiti razvojno
okolje Eclipse in programsko opremo Android SDK, ki nam pomaga pri ustvarjanju datotek
in nastavitev za programiranje v operacijskem sistemu Android s pomočjo programskega
jezika Java. Osnovni del operacijskega sistema Android (oz. jedro, angl. Kernel) temelji na
jedru operacijskega sistema Linux. Ta del skrbi za izvajanje uporabniških programov,
komunikacijo z vhodno-izhodnimi napravami, upravljanje s pomnilnikom in podobno.
Aplikacije za sistem Android so napisane v posebni različici Jave, ki lahko upošteva posebne
zahteve pametnih telefonov, kot npr. delovanje z manj delovnega pomnilnika in ob omejeni
oskrbi z električno energijo. Mobilna aplikacija oziroma oglasna deska je izdelana z uporabo
razvojnega okolja Eclipse, pri katerem moramo najprej namestiti programsko opremo
Android, ki jo prenesemo s spleta v paketu SDK. Android SDK je paket, v katerem se nahaja
programska oprema za operacijski sistem Android, s katerim si pomagamo pri programiranju
mobilne aplikacije.
Programska rešitev, ki je nastala v času izvedbe raziskave, je namenjena zapisovanju obvestil
(podatkov) v podatkovno zbirko, ki je shranjena na podatkovnem strežniku. V diplomski
nalogi je predstavljen problem shranjevanja podatkov v podatkovno zbirko. Podatki, shranjeni
vanjo, predstavljajo obvestila, namenjena trem različnim skupinam uporabnikov (študentom,
profesorjem in referatu). Za programiranje oziroma razvoj rešitve so uporabljene tehnologije
Java, operacijski sistem Android, protokol JDBC in sistem za upravljanje baz podatkov
MySQL.
2
Mobilna aplikacija je namenjena obveščanju uporabnikov o spremembah študijskih
dejavnosti. V predvidenem načinu uporabe profesor ali referat objavi obvestilo na elektronsko
oglasno desko, kjer ga študent lahko vidi in prebere. Podatki oziroma obvestila, ki so vnesena
v podatkovno zbirko, lahko pooblaščeni uporabniki tudi spreminjajo. Spreminjanje objave
pomeni, da določen uporabnik, ki je v primeru aplikacije profesor ali referat, popravi ali na
novo shrani obvestilo v podatkovno zbirko. Problem, ki ga rešujem pri raziskavi, je
obveščanje študentov preko mobilnih naprav. Podatki, ki jih zapišemo v podatkovno zbirko so
tudi skupine uporabnikov. Podatki o uporabnikih, kot so uporabniško ime in geslo, ime
skupin, del katerih so, in id skupin ter objav (obvestil) se hranijo z razlogom, da vidimo,
katera skupina je objavila obvestilo ter kje je vidno.
Za delo pri raziskavi je bila uporabljena relacijska podatkovna zbirka oziroma podatkovna
zbirka, ki je nastala pri izvedbi raziskave in temelji na sistemu MySQL. Zbirka podatkov,
nastala med izvedbo raziskave, vsebuje štiri različne tabele: data (podatki), users (uporabniki),
user_groups (skupine uporabnikov) in post_in_groups (objave, ki so vidne določenim
skupinam). Relacijska podatkovna zbirka je predstavljena s sistemom MySQL. Relacijska
podatkovna zbirka je nameščena na strežniku, ki se nahaja na poljubni lokaciji, in je povezana
z internetom. Mobilna aplikacija je v primeru pričujoče raziskave nameščena na emulatorju
pametnega mobilnega telefona, preko katerega tudi dostopamo do podatkovne zbirke z JDBC
povezavo. JDBC tehnologijo, ki sem jo uporabil pri izdelavi mobilne aplikacije, je razvilo
podjetje Sun Microsystems, ki je uporabilo sistem ODBC kot podlago za odprti standard
JDBC. Kratica ODBC pomeni Open Data Base Connectivity. JDBC je alternativna
tehnologija, prilagojena za uporabo v programskem jeziku Java, medtem ko tehnologija
ODBC ni vezana na posamezen programski jezik. Programi, zapisani v programskemu jeziku
Java, imajo preko JDBC to ODBC mostov dostop do podatkovnih virov, ki nimajo vgrajenega
JDBC gonilnika. Ti sistemi so sedaj relativno redki. Mostovi, ki imajo obrnjeno strukturo
imenovano ODBC to JDBC, dovoljujejo programom, zapisanim denimo v programskemu
jeziku C, dostop do podatkovnih virov preko JDBC gonilnikov na platformah ali do
podatkovnih zbirk, ki nimajo vgrajenega gonilnika ODBC. ODBC tehnologija je široko
razširjena, na voljo pa so nam gonilniki, ki jih najdemo na večini platform in podatkovnih
zbirkah. Občasno še vedno najdemo gonilnike ODBC, ki so vgrajeni v določeno platformo,
kot je na primer SQLite, t. i. pot, ki dovoljuje obstoječim orodjem, da se obnašajo kot
preizkuševalci naprav pri preizkusih in iskanju hroščev oziroma napak v programski kodi.
Eden izmed glavnih razlogov, zaradi katerega sem se odločil za izdelavo mobilne aplikacije,
je bil, zanimanje za programiranje v programskem jeziku Java in za razvoj mobilnih aplikacij
3
za Android. Izdelavo oglasne deske sem vključil v svojo diplomsko nalogo, ker sem želel
usvojiti, kako mobilne aplikacije komunicirajo s centralno podatkovno zbirko in prebirajo
podatke iz nje ter jih zapisujejo vanjo s pomočjo uporabnikov.
Preden sem se lotil programiranja mobilne aplikacije, sem predelal vso potrebno strokovno
literaturo in se temeljito seznanil z razvojem programske opreme potrebne za programiranje.
Slednje sem do začetka programiranja poznal le s teoretičnega vidika. Po preučitvi vse
literature o razvoju oziroma programiranju mobilnih aplikacij, JDBC povezave in sistema za
podatkovne zbirke MySQL, sem se lotil programiranja aplikacije. Program oziroma mobilna
aplikacija, ki je nastala kot del raziskave, vsebuje vsa potrebna navodila in pomaga
uporabniku pri zapisu podatkov v podatkovno zbirko, prebiranju podatkov iz podatkovne
zbirke ter mu prav tako omogoča spreminjanje podatkov zapisanih v podatkovni zbirki na
zaslonu pametnega mobilnega telefona. Uporabniki mobilne aplikacije so lahko tako študentje
ali dijaki kot tudi profesorji ali referat. Programska koda mobilne aplikacije, povezave JDBC
in podatkovne zbirke se nahajajo v prilogi.
Diplomska naloga vsebuje teoretična izhodišča, empirični del in sklepne misli. Vsako od
omenjenih poglavij je razdeljeno na več podpoglavij. V uvodu je predstavljena tematika, s
katero se raziskava ukvarja, v teoretičnih izhodiščih pa je predstavljena literatura, ki je bila
uporabljena za izvedbo raziskave. Sledijo glavne zahteve, ki jim mora ustrezati aplikacija,
nastala med izvedbo raziskave. Pri tem je bila pregledana in uporabljena tehnologija
podatkovne zbirke, temelječa na sistemu MySQL in tehnologija JDBC, ki je bila ključnega
pomena za povezavo med podatkovno zbirko in mobilno aplikacijo, izdelano na operacijskem
sistemu Android.
2. TEORETIČNA IZHODIŠČA
2.1 Kritični pregled literature
Tematika, s katero se ukvarjam v diplomskem delu, je povezana s programiranjem v
programskem jeziku Java, programiranjem v operacijskem sistemu Android, s podatkovnimi
bazami in dostopanjem do podatkovnih baz preko interneta s pametnim mobilnim telefonom.
V nadaljevanju je predstavljena uporabljena literatura po zgoraj navedenih tematskih sklopih.
4
Večina literature, uporabljene za izdelavo diplomskega dela, je dostopna na spletu, nekaj pa je
je mogoče dobiti tudi v knjižni obliki.
O programskemu jeziku Java obstaja nepregledna množica literature. Najbolj obsežno knjižno
delo v slovenščini je knjiga »Java 2, temelji programiranja« avtorjev Uroša Mesojedca in
Boruta Fabjana (Mesojedec in Fabjan, 2004), ki žal ne zajema novejših različic programskega
jezika Java. V angleškem jeziku je na voljo veliko knjig in učbenikov. Pri izdelavi
diplomskega dela sem uporabljal učbenik »Thinking in Java« avtorja Brucea Eckela. Med
elektronskimi viri sem pogosto uporabljal uradno dokumentacijo programskega jezika Java
(http://docs.oracle.com/javase/7/docs/api) kot tudi ostale uradne vire na spletni strani
www.java.com. V veliko pomoč so mi bili prav tako različni spletni programski forumi.
Podobno kot pri programskem jeziku Java je tudi za programiranje v operacijskem sistemu
Android dostopno veliko literature. Članek z naslovom »A developer's first look at Android«
(Overview Developers, 2008) predstavlja notranjo zgradbo operacijskega sistema Android na
enostaven in razumljiv način. Notranja zgradba Androida je predstavljena z vidika
razvijalcev, avtor pa v uvodu članka prav tako zapiše, da predstavlja našo edino omejitev le
domišljija. V osrednjem delu članka njegov avtor opisuje arhitekturo, aplikacije, okvir
aplikacij, knjižnice, Android SDK, razvoj aplikacij za operacijski sistem Android, razvoj
Androida z razvojnim okoljem Eclipse in razvoj Androida z drugimi orodji, ki jih uporablja
del razvojnega okolja Eclipse. Prav tako prikaže poganjanje aplikacij v Androidu jedro
operacijskega sistema Linux, na katerem temelji sistem Android, opiše uporabo Android
emulatorja in v zaključku kratko opiše tudi tekmovanje za del dobička, ki ga dobi le uspešen
programer aplikacije za sistem Android. Predstavitev operacijskega sistema Android nam
poda knjiga z naslovom »Unlocking Android« (Ableson in drugi 2009), ki opisuje njegovo
zgradbo ter prikaže primer aplikacije s pomočjo zaslonskih slik. Primer mobilne aplikacije, ki
je prav tako prikazan v tej knjigi, je podan na podlagi lastno izdelane aplikacije avtorja.
Mobilni aplikaciji je dodan tudi seznam aktivnosti, ki je obenem del te aplikacije in nekaj slik,
s katerimi je ponazorjen potek mobilne aplikacije ter njena podrobna razlaga.
MySQL je odprto-kodna implementacija relacijske podatkovne zbirke, ki za delo s podatki
uporablja jezik SQL. Podatkovne zbirke so zbirke podatkov, ki skrbijo, da se podatki ohranijo
za dolgo časa. Omogočajo zapis podatkov v tabele in se uporabljajo za shranjevanje večjih
količin podatkov, ki jih ne moremo pisati v datoteke. Prednost podatkovnih zbirk je v tem, da
jih ne shranjujemo neposredno na računalnik ali mobilni telefon in s tem varčujemo pri
prostoru, saj so praviloma shranjene na oddaljenem strežniku. Relacijske podatkovne zbirke
so zbirke, ki modelirajo podatke kot skupek tabel oziroma relacij in povezav med njimi.
5
Povezave med dvema tabelama so izvedene preko skupnih podatkovnih polj ali atributov. Pri
tem se v dve različni tabeli zapisujejo vrednosti, ki so enake v obeh tabelah. Elektronska
knjiga z naslovom »MySQL Cookbook« (DuBois, 2002) vsebuje vsa podrobna navodila za
delo s podatkovnimi zbirkami. Pri delu z njimi avtor knjige piše o urejanju podatkov,
ustvarjanju novih tabel in dostopanju do podatkovne zbirke za ostale uporabnike. Jezik SQL
predstavlja strukturiran povpraševalni jezik, kar pomeni, da je različen od navadnih
programskih jezikov, kot je Java, v tem, da se izvaja s pomočjo SQL ukazov, s katerimi
povemo, katere podatke potrebujemo iz podatkovne zbirke oziroma kaj želimo narediti z
njimi, prevajalnik SQL pa to prevede v ustrezno proceduro. V praktični uporabi so vsi SQL
jeziki blizu standardu SQL/PSM. SQL/PSM (SQL/Persistent Stored Modules) je standard, ki
se večinoma uporablja za razširitve SQL s proceduralnim jezikom za uporabo v procesih
shranjevanja podatkov. Različica jezika SQL v sistemu MySQL ima posebnosti, ki delujejo
samo v sistemu MySQL in se v omenjenem sistemu uporabljajo za urejanje podatkov,
podatkovnih zbirk tabel in zapisov poizvedb potrebnih za pridobivanje podatkov zapisanih v
podatkovnih zbirkah.
Tehnologija JDBC predstavlja most med različnimi operacijskimi sistemi ali podatkovnimi
zbirkami in različnimi aplikacijami, ki imajo dostop do podatkovnih zbirk. V primeru svoje
raziskave sem jo uporabil, ker sem želel vzpostaviti povezavo med mobilno aplikacijo in
podatkovno zbirko nameščeno na oddaljenem strežniku. Oddaljen strežnik je bil v okviru
raziskave prenosnik s podatkovno zbirko, medtem ko je mobilna aplikacija delovala na
emulatorju pametnega mobilnega telefona. Literatura uporabljena pri vzpostavljanju JDBC
povezave se nahaja na naslednji spletni strani:www.oracle.com/technetwork/java/overview-
141217.html.
2.2 Programski jezik Java
Programski jezik Java je danes zelo razširjen in se uporablja na različnih platformah, na
osebnih računalnikih, velikih strežniških sistemih, super računalnikih, mobilnih telefonih,
pametnih televizijah, itd. V programskem jeziku Java so napisane tudi aplikacije na mobilnih
telefonih z operacijskim sistemom Android.
Splošne lastnosti Jave so objektna usmerjenost, neodvisnost od platforme, primernost za
razvoj spletnih aplikacij, varnost in relativna enostavnost v primerjavi s starejšim
programskim jezikom imenovanim C++. Neodvisnost od platforme oziroma operacijskega
sistema je dosežena tako, da se javanska koda izvaja na posebnem programu, javanskem
6
virtualnem stroju (JVM, Java Virtual Machine). Javanski virtualni stroj skrbi, da se koda v
Javi prevede v strojni jezik sistema, na katerem teče. Izvedenka programskega jezika Java za
uporabo pri razvoju spletnih aplikacij je JavaScript, ki ima podobno skladnjo kot Java, le da je
JavaScript bolj omejena, ker teče v brskalniku. Varnost programskega jezika Java je povezana
z njegovim izvajalnim sistemom. V javanski izvajalni sistem je varnost vgrajena in preprečuje
slabo programiranje oziroma zlorabo javanske kode za vdore v določen sistem. Relativna
enostavnost programskega jezika Java pomeni, da je koda, ki se jo uporablja za
programiranje, bolj enostavna kot pri starejših objektno orientiranih programskih jezikih, kot
je C++.
Pomemben mehanizem v objektno orientiranih programskih jezikih je dedovanje, ki nam
omogoča, da iz splošnih razredov izpeljemo bolj specifične. Razredi so v primeru Jave skupen
opis množice objektov, ki služi kot vzorec za oblikovanje več objektov z enakim obnašanjem.
Objekti v primeru Jave so konkretni primerki razredov, ki so ustvarjeni med izvajanjem
programske kode in se uničijo po končani izvedbi programske kode. V primerjavi s starejšimi
programskimi jeziki je Java razmeroma preprosta, njena programska koda je manj obsežna.
Programi so v Javi bolj obsežni kot v C++, ker se v primeru programskega jezika Java koda
prevede le v vmesno kodo in ne potrebuje prevoda na nivoju strojnega jezika kot na primer
jezik C++. Pri programskem jeziku C++ se prevede najprej v strojno kodo in potem v
izvršilno. Izvršilna datoteka se potem tudi izvede na sistemu, v katerem je bila prevedena.
Primer starejših programskih jezikov je programski jezik C, iz katerega sta se razvila
programski jezik C++ in Java.
Programski jezik Java ima mnogo različnih grafičnih vmesnikov. Izbira grafičnih vmesnikov
je praviloma določena z izbiro enega od razvojnih okolij za programiranje v Javi, kot so na
primer Eclipse, NetBeans, IntelliJIdea in ostala razvojna okolja. Za poganjanje aplikacij
izdelanih v programskemu jeziku Java lahko uporabimo tudi njegov prvotni uporabniški
vmesnik oziroma ukazno vrstico. Uporabniški vmesnik programskega jezika Java nam v
zadnjem času omogoča tudi uporabo kode jezikov C in C++.
V primerjavi z jezikom C++ je Java dokaj robusten programski jezik, saj uporablja inovativen
mehanizem izjem, ki od programerja zahteva, da vse predvidljive napake ustrezno obravnava.
Program, zapisan v programskem jeziku Java, je zaradi robustnosti, ki jo ima vgrajeno,
izvedljiv tudi na manj varnem sistemu. Slabo varen sistem je sistem, ki ima pomanjkljivosti
glede varnosti pred škodljivimi datotekami. Te se izvajajo neposredno na sistemu in skrbijo,
da se izvajanje ustavi ali se izvaja zelo počasi. Robustnost programskega jezika Java pomeni,
da se program ne zaustavi takoj, ko naredimo napačen vnos vanj. Povezava varnosti in
7
robustnosti programskega jezika Java je pomembna zaradi izvajalnega okolja. Java je obenem
tudi neodvisna od sistema, kar pomeni, da lahko programe zapisane v tem programskem
jeziku izvajamo na katerem koli sistemu. Pri tem potrebujemo JVM, ki prevaja in izvaja bitno
kodo (angleško bytecode). Omenjeno kodo lahko poganjamo na vseh sistemih, ki imajo
implementiran JVM (Mesojedec in Fabjan, 2004).
Programski jezik Java je relativno varen programski jezik in je primeren za uporabo tudi v
večuporabniških, porazdeljenih in omrežno povezanih sistemih, kjer je varnost ključnega
pomena. V operacijski sistem, nameščen na osebnem ali prenosnem računalniku, na katerem
poganjamo javanski izvajalni sistem, moramo imeti varnost predhodno vgrajeno, ker nimamo
možnosti, da bi varnost naknadno vgradili v operacijski sistem. Zaupanje pomeni, da je sistem
varen pred katero koli zlorabo. V primeru, da ni varen pred zlorabami oziroma škodljivimi
datotekami, ga ne moremo uporabiti kot podporo javanskemu izvajalnemu sistemu. Pri
varnosti ključno vlogo predstavlja javanski izvajalni sistem, ker ne dovoljuje izvedbe kode,
katera bi bila škodljiva za operacijski sistem oziroma predstavlja zlorabo varnosti. Javanski
izvajalni sistem jih preverja že ob nalaganju kode, ob njenem razvrščanju v pomnilnik in preži
tudi na morebitne napake pri izvajanju programskih ukazov. Kateri koli izvajalni sistem
vzamemo za primer, lahko ugotovimo, da ni nihče izmed njih popoln. Razvijalci programske
opreme oziroma razvojnih okolij za programski jezik Java so z vpogledom v kodo izvajalnega
sistema odpravili nekatere pomanjkljivosti. Javanski izvajalni sistem ima nalogo, da nam
omogoči ali onemogoči dostop do datotek ali omrežja. Pri dostopu do datotek in omrežja je
govora o vidnosti vsebine datotek, ki potujejo preko omrežja. Vpogled vanje imajo samo
razvijalci programske opreme. Izvajalno okolje vsa omenjena pravila vsiljuje vsaki vrstici
kode, ki se izvaja v njem. Varnost Jave je s tem potrjena tudi v praktični uporabi. Pri tem so
razvijalci razvojnih okolij odpravili tudi pomanjkljivosti ter zlorabe izvajalnega sistema in
varnosti v njem. Zlorabe so slabo programirani objekti, ki v praktični uporabi onemogočijo
delo s sistemom in posledično tudi s programom (Mesojedec in Fabjan, 2004).
Programski jezik Java je dokaj zmogljiv programski jezik, čeprav je bila zmogljivost njegovih
zgodnejših različic pogosto tarča kritik. Z napredkom tehnike pravočasnega prevajanja je
učinkovitost programskega jezika Java dosegla in v nekaterih primerih tudi presegla
učinkovitost kode razvite v programskem jeziku C++.
Vmesna koda pri programskem jeziku Java se imenuje bitna koda (angleško bytecode) in
omogoča strnjen zapis programov, ki se lahko učinkovito izvajajo na sodobnih procesorjih.
Programski jezik Java je tudi večniten jezik, kar pomeni, da se znotraj enega programa izvede
več različnih dejavnosti, s čimer je omogočena večopravilnost. Programerjeva koda se
8
prevede in izvaja v obliki zapisa, v katerem se podatki prenašajo v velikosti bajtov (Balažic,
2011).
Poznamo tudi nekaj slabih strani programskega jezika Java. Ena izmed slabih strani je, da
potrebuje veliko delovnega spomina in daljši čas, da izvede določene računske operacije ali
zahtevnejše probleme v primerjavi s C++. Težava povezana s počasnejšo izvedbo
programskega jezika Java je tudi v tem, da se njena koda pred izvedbo prevede v bitno kodo
in izvaja kot prilagojena za procesor, medtem ko se koda pri ostalih programskih jezikih
prevaja neposredno v strojno kodo. Za delovanje je potrebno tudi veliko delovnega spomina.
Pri dedovanju so si različni razredi objektov do določene mere podobni. Da se izognemo
večkratnemu programiranju oziroma gradnji podobnih razredov, lahko v objektno
orientiranem programiranju uporabimo dedovanje. Programski jezik Java ima dedovanje
urejeno tako, da ima vsak razred samo en bolj splošen nadrazred, iz katerega lahko izpeljemo
več različnih razredov, ki so prilagojeni delu v novem okolju. Podrazredi so lahko bolje
prilagojeni uporabi v okolju, kjer bi prvotni razred bil neuporaben (Eckel, 2006).
Programiranje v operacijskemu sistemu Android uporablja veliko različnih razvojnih okolij.
Najbolj znani razvojni okolji za programiranje v temu operacijskem sistemu sta Eclipse in
NetBeans. Poleg razvojnega okolja moramo namestiti tudi Android SDK (»Software
Development Kit«) ter JDK JRE (»Java Development Kit in Java Run time Environment«),
da lahko sploh programiramo aplikacije za Android. Pri prevajanju kode nam razvojno okolje
Eclipse označi vse sintaktične napake in ne dovoli, da bi zagnali aplikacijo, dokler jih ne
odpravimo in zapišemo kodo aplikacije tako, kot je potrebno (Finžgar, 2010).
2.3 Predstavitev operacijskega sistema Android
Operacijski sistem Android je najbolj razširjen operacijski sistem uporabljen na pametnih
mobilnih telefonih. Jedro za ta operacijski sistem izhaja iz operacijskega sistema
imenovanega Linux, ki ga najdemo večinoma na strežnikih, ter ga redko uporabljamo na
osebnih ali prenosnih računalnikih. Android je razvilo podjetje Google v sodelovanju s
podjetji združenimi v združenje imenovano Open Handset Alliance (OHA) (Wikipedia, 12.
december 2015b). Operacijski sistem Android je namenjen mobilnim telefonom, vendar ga
lahko najdemo tudi na drugih napravah, kot so tablični računalniki, ročne ure in podobno. Ime
operacijskega sistema za pametne mobilne telefone izhaja iz angleške besede »Android«, kar
pomeni robot, ki se obnaša in je videti kot človek. Operacijski sistem Android je deloma
odprtokoden in prosto dostopen (DiMarzio, 2008).
9
Pri razvoju Android aplikacij se uporablja Java. Specializiran virtualni stroj Dalvik opravlja
funkcijo Java Virtual Machine na sistemu Android. Dalvik je optimiziran za vse mobilne
naprave z baterijo ter omejenim spominom potrebnim za delo z njimi. Operacijski sistem
Android je zgrajen iz petih elementov. Elementi operacijskega sistema Android so aplikacije,
njihovo ogrodje, knjižnice, prevajalnik in Linux jedro. Aplikacije za operacijski sistem
Android so sestavljene iz kode v Javi in podatkov v formatu XML (Wikipedia, 12. december
2015a). Aplikacije so shranjene v datoteko Android paket, s končnico apk. Vsaka Android
aplikacija se požene v svojem Linux procesu takrat, ko mu pošljemo zahtevo za izvajanje
aplikacije. Ob zaključku izvajanja aplikacije se njen proces zapre. S tem omogočamo uporabo
pomnilnika tudi drugim aplikacijam. Vsak proces se prevede posebej, kar nam omogoča
izoliranje aplikacij, da delujejo neodvisno ena od druge. Vsaki izmed aplikacij se ob zagonu
ustvari lastna identifikacijska koda, ki se ji dodajo pravice za uporabo strojne opreme. V
ogrodju aplikacij se nahajajo vse sistemske aplikacije, ki jih potrebujemo za njihovo
koordiniranje (Wikipedia, 12. december 2015). Te aplikacije so upravljavec aktivnosti,
upravljavec pomnilnika, upravljavec lokacij in obvestil. Knjižnice so temeljni del sistema
Android. To pomeni, da navaden uporabnik operacijskega sistema ne more dostopati do njih.
Uporabljajo jih razvijalci za dostop do strojnega dela naprave. Operacijski sistem Android za
prevajanje kod aplikacij do različice 4.4 uporablja prevajalnik tipa JIT (Just In Time
compiler). V različici 4.4 je bila uvedena možnost vklopa prevajalnika imenovanega ART
(Android Run Time), ki vse aplikacije prevede ob zagonu AOT (Ahead Of Time) (Krašovec,
2014).
Podjetje Google ima največ zaslug, da operacijski sistem Android obstaja, saj je ustanovilo
združenje podjetij imenovano Open Handset Alliance ter kupilo hitro rastoče podjetje
imenovano Android Inc. Združenje je bilo ustanovljeno z namenom oziroma prizadevanjem
skupnega razvoja odprtih standardov na področju telefonije ter ostalih naprav 5. novembra
2007. To združenje želi približati pametne telefone uporabnikom z vedno cenejšimi in
boljšimi telefoni ter ostalimi prenosnimi napravami (DiMarzio, 2008).
Ena izmed dobrih strani operacijskega sistema Android je ta, da nam omogoča cenejše in lažje
razvijanje aplikacij zanj kot na primer sistem IOS, ki je izdelan pri podjetju Apple. Pri tem
prednost občutijo uporabniki, saj so aplikacije za operacijski sistem Android večinoma
brezplačne. Razlog za to je v izbranem poslovnem modelu ali odločitvi programerja.
Operacijski sistem Android je enostaven, odziven in omogoča večopravilnost. Sinhronizira se
z Googlovimi storitvami, kot so Google Mail, Google Calendar itd. (Krivec, 2013).
10
Operacijski sistem Android ima tudi nekaj slabih strani, saj ima težave s počasnim
delovanjem oziroma občasnim ustavljanjem med delovanjem. Zaradi tega lahko pametni
mobilni telefon postane tudi neuporaben, kar pomeni, da se določena aplikacija na njem
neprestano zaustavlja ter ne deluje, kot je potrebno (Potežica, 2009).
2.4 Programiranje aplikacij za operacijski sistem Android
Programiranje v operacijskem sistemu Android zahteva razvojno okolje za programski jezik
Java, denimo Eclipse in programsko opremo Android SDK. Android ADT (Android
Development Tools) nam naredi vse datoteke in nastavitve za programiranje Android
aplikacij. Te aplikacije so izvedljive samo na operacijskem sistemu Android, saj ta uporablja
svoje, nestandardne knjižnice (Simčič, 2012). Emulator mobilnega telefona z operacijskim
sistemom Android omogoča razvoj in testiranje programske opreme za Android na osebnem
računalniku.
Programiranje v operacijskem sistemu Android zahteva dobro poznavanje programskega
jezika Java. Za programiranje uporabniškega vmesnika Android aplikacije potrebujemo tudi
znanje jezika XML (Zimic, 2012).
Pri tem lahko uporabljamo tudi urejevalnike besedil, kot sta Beležnica in Notepad++. Android
aplikacije lahko preizkušamo na emulatorju ali dejanskem pametnem telefonu z operacijskim
sistemom Android. Emulator mobilnega telefona Android je videti kot pravi telefon in
omogoča razvoj ter testiranje programske opreme na osebnem računalniku. Emulator nam ne
omogoča preizkušanja vseh možnosti, tako kot na dejanskem pametnem mobilnem telefonu.
Tako nam emulator denimo ne omogoča uporabe kamere v starejših različicah operacijskega
sistema Android. Ob začetku programiranja ustvarimo Android projekt v razvojnem okolju
Eclipse. Zatem ustvarimo vse potrebne datoteke za aplikacijo, v katerih je shranjena koda
aplikacije. Slednjo predstavljajo datoteke, zapisane v programskem jeziku Java, ki so
izvajalne, medtem ko XML datoteke vsebujejo podatke, kot so na primer podoba
uporabniškega vmesnika mobilne aplikacije.
Aplikacija je narejena tako, da posamezna obvestila prikaže samo tistim uporabnikom,
katerim so namenjena. Primer tega je obvestilo profesorja ali referata študentom, da se je
spremenil datum izpita. Obvestila so besedila, ki jih študentje, profesorji ali referat objavijo
na elektronski oglasni deski in so namenjena vsem trem skupinam ali samo eni izmed njih.
Obvestila se po objavi tudi zapišejo v podatkovno zbirko. Prikaz objav je mišljen, da študentje
vidijo samo tista obvestila, ki so jih objavili in spremenili sami in obenem vidijo tudi
11
objavljena obvestila, ki jih je vnesel referat ali profesor, in so tudi namenjena študentom.
Dolžina obvestil, ki jih uporabniki iz prej omenjenih skupin objavijo na elektronsko oglasno
desko, ni omejena. Elektronska oglasna deska uporabnikom (študentu, profesorju ali referatu)
pomaga, da preko nje vidijo podatke zapisane v zbirki podatkov. Obvestila so podatki, ki so
namenjeni obveščanju uporabnikov, kot je na primer sprememba časa in prostora izpita. V
podatkovno jih vnese uporabnik mobilne aplikacije. Mobilna aplikacija preveri id uporabnika
v tabeli »data«, in ga primerja z id-jem v tabeli »users«, preden mu dovoli, da lahko spremeni
obvestilo. V primeru, da se obe vrednosti ujemata, lahko trenutno prijavljeni uporabnik
spreminja objavo na elektronski oglasni deski. Omenjena dejavnost se zgodi v ozadju med
izvajanjem aplikacije. Mobilna aplikacija uporabnikom omogoča shranjevanje podatkov v
podatkovno zbirko, urejanje podatkov na zaslonu mobilne aplikacije in zapis le teh v vrstico,
kjer je bila prvotna objava shranjena kot obvestilo. Shranjevanje podatkov v podatkovno
zbirko pomeni, da uporabnik vnese obvestilo v uporabniški vmesnik aplikacije, aplikacija pa
ga nato zapiše v podatkovno zbirko preko JDBC povezave. JDBC povezava je povezava, ki
skrbi, da komunikacija med mobilno aplikacijo in podatkovno zbirko poteka preko gonilnika
s programskim jezikom Java. Podatke o uporabnikih shranjujemo v podatkovno zbirko, da
vidimo in vemo, kdo se je prijavil in kdo je na novo registriran v mobilno aplikacijo.
2.5 Baze podatkov
Baze podatkov so se pojavile zaradi potrebe po hitrem dostopu do informacij, ker
shranjevanje podatkov iz preteklosti omogoča odločanje za prihodnost. Oblastniki so s tem
namenom v preteklosti gradili knjižnice ter z enakim namenom današnja podjetja vodijo
podatkovne zbirke o povpraševanju, strankah, vremenskih razmerah in sploh vsem, kar ima
možnost vpliva na bodoče poslovanje (DuBois, 2002).
Pri programiranju v podatkovnih bazah so uporabni različni SQL jeziki. SQL je standardiziran
poizvedovalni jezik, ki je najbolj razširjen jezik za delo s podatkovnimi bazami. Temelj SQL
jezika je poizvedba, ki nam vrne vse potrebne podatke iz ene ali več tabel v podatkovni bazi.
Poizvedbe omogočajo uporabniku, da opiše strukturo podatkov, ki jih želi pridobiti iz
podatkovne baze. Sistem za upravljanje s podatkovno bazo imenovan DBMS (Data Base
Management System) je odgovoren za načrtovanje, optimizacijo in izvajanje fizičnih operacij
potrebnih za izpis rezultata, ki ga želimo pridobiti. Izvedba poizvedb se nam pohitri v
primeru, da optimiziramo SQL stavke. Pri podatkovnih bazah uporabljamo SQL jezike, kot so
MySQL, Oracle SQL in ostale SQL jezike (DuBois, 2002).
12
Za urejanje podatkovnih baz poznamo različna orodja oziroma programska okolja. Eno izmed
programskih okolij za urejanje podatkovnih baz je MySQL Workbench. To okolje nam
pomaga pri ustvarjanju računa za delo s podatkovnimi bazami. Zatem si ustvarimo
podatkovno zbirko, ki nam shranjuje vse podatke na strežniku. To pomeni, da podatke, ki jih
vnesemo v podatkovno zbirko preko uporabniškega vmesnika, shranimo na strežnik, ki ga
namestimo na svoj računalnik ali zanj uporabimo poseben računalnik.
To orodje nam pomaga urejati podatke v podatkovni bazi takoj, ko si ustvarimo uporabniški
račun za delo z njo. MySQL Workbench je preprost za uporabo in uporabnika vodi pri izvedbi
poizvedb na določeni podatkovni bazi (DuBois, 2002).
2.6 Raziskovalno vprašanje
Tematika moje raziskave je povezana z operacijskim sistemom Android, programskim
jezikom Java, sistemom za podatkovne zbirke MySQL in povezavo med njima preko JDBC.
S pomočjo omenjenih tehnologij želim razviti Android aplikacijo s funkcijo elektronske
oglasne deske. Elektronska oglasna deska bo uporabnikom operacijskega sistema Android
pomagala pri izmenjavi podatkov. Moja motivacija pri tem je, da lahko z uporabo prostih in
odprtokodnih orodij sprogramiram aplikacijo, ki bo shranjevala podatke v podatkovno zbirko
in jih izpisovala na zaslon.
Predvidevam, da lahko z uporabo prostih in odprtokodnih orodij, ki jih uporabljamo za
programiranje v operacijskem sistemu Android, razvijem praktično uporabno rešitev za
komunikacijo znotraj zmerno velikih skupin uporabnikov, kot je na primer skupina 80−100
študentov Fakultete za Informacijske študije. Elektronska oglasna deska je namenjena
uporabnikom pametnih mobilnih telefonov z operacijskim sistemom Android. Pri oglasnih
deskah poznamo več različnih vrst. Ena izmed njih je klasična oglasna deska, ki si jo dejansko
lahko ogleda le malo uporabnikov. Elektronska oglasna deska ima prednost od klasične v tem,
da si jo, tako kot klasično, lahko ogleda več uporabnikov, toda uporabniki klasične oglasne
deske morajo najprej priti do lokacije, kjer se klasična oglasna deska nahaja. Dostop do
elektronske oglasne deske je lažji za uporabnike, saj jim ni potrebno hoditi naokrog, da bi
prebrali podatke zapisane na njej, ne glede na to, kje se uporabnik elektronske oglasne deske
nahaja oziroma ni odvisna od njegove lokacije.
Uporabniki klasične oglasne deske so lahko na primer zaposleni v določenem podjetju ali
prebivalci večstanovanjske stavbe. Uporabniki elektronske oglasne deske bi lahko bili vsi, ki
so del šolskega sistema. To pomeni, da imajo dostop do nje učenci, dijaki, študentje ter
13
učitelji in profesorji. Elektronsko oglasno desko si lahko ogleda mnogo več uporabnikov kot
klasično, ker imajo do nje vsi boljši dostop. Vsa obvestila objavljena na elektronski oglasni
deski so podatki, ki jih lahko shranimo v podatkovno zbirko in umaknemo z oglasne deske v
primeru, da niso več ažurni oziroma uporabni za obvestilo.
Obvestila v primeru klasične ali elektronske oglasne deske so obvestila o različnih dogodkih,
ki se dogajajo vsak dan ali vsakih nekaj dni. Pretekle dogodke lahko odstranimo z oglasne
deske in jih shranimo v podatkovno zbirko, kar je tudi namen raziskave. Podatkovna zbirka
bo v primeru moje raziskave temeljila na podatkovni zbirki shranjeni v sistemu za podatkovne
zbirke imenovanemu MySQL. Sistem za delo s podatkovnimi zbirkami MySQL je
najpogosteje uporabljen pri uporabnikih (DuBois, 2002), ki se niso ukvarjali z nobenim
drugim sistemom za urejanje in ustvarjanje podatkovnih zbirk.
Podatkovne zbirke so zbirke podatkov, ki jih zberemo v določenem časovnem obdobju. Za
določeno časovno obdobje lahko vzamemo leto, desetletje, stoletje ali tisočletje. V časovnem
obdobju, ki ga omenjam, se nam v podatkovno zbirko zapiše mnogo podatkov, ki jih lahko
primerjamo med seboj, pri čemer se nam pokažejo razlike.
Podatke v podatkovne zbirke zapisujemo zato, da se lahko odločamo za prihodnost glede na
podatke iz preteklosti. Iz preteklih podatkov, kot so npr. izmerjena temperatura zraka, ki se je
neprestano spreminjala, lahko sklepamo, kako se bo le-ta spreminjala v prihodnosti.
2.7 Cilji raziskave
Opravljena raziskava ima naslednje cilje:
razvoj programske rešitve za mobilno elektronsko desko sestavljeno iz mobilne
aplikacije in centralne baze podatkov,
usvojitev programskih orodij in tehnik za programiranje v operacijskem sistemu
Android za delo z bazami podatkov in za povezovanje med mobilnimi aplikacijami ter
centralnimi podatkovnimi bazami in
vrednotenje razvite programske rešitve ter analiza njenih dobrih in slabih lastnosti.
Programska rešitev razvita v raziskavi za diplomsko nalogo je sestavljena iz Android
aplikacije in centralne podatkovne zbirke. Android aplikacijo in centralno podatkovno zbirko
sem ustvaril sam s programiranjem v operacijskem sistemu Android oziroma v programskem
okolju Eclipse, ki ima dodan Android SDK, pri katerem je za programiranje v operacijskem
sistemu Android potreben Android Development Tools »ADT«. Za programiranje
podatkovne zbirke sem uporabil sistem MySQL, ki se uporablja za pridobivanje podatkov,
14
zapisanih v podatkovno zbirko. Sistem za podatkovne baze MySQL bom uporabil zaradi
pridobljenega znanja njegove uporabe, ki sem ga pridobil med študijem. Za vzpostavitev
povezave med Android aplikacijo in podatkovno zbirko bom uporabil povezavo oziroma
tehnologijo, ki jo predstavlja tehnologija JDBC.
JDBC povezava oziroma tehnologija je ena od možnosti za povezave med Android aplikacijo
in MySQL podatkovnim strežnikom. Med Android aplikacijo in podatkovnim strežnikom je
možnih več povezav, kot so na primer spletni servisi oziroma Web services, preko katerih se
mobilna aplikacija poveže najprej s spletom in potem se preko spletnega obrazca poveže tudi
s podatkovno zbirko oziroma pošlje podatke do podatkovnega strežnika preko spletnega
servisa. Podatkovna zbirka je nameščena na svoj računalnik ali na oddaljen strežnik. Strežnik
je običajno bolj zmogljiv računalnik, ki se uporablja za deljenje podatkov iz podatkovnih
zbirk ostalim uporabnikom. Vrednotenje razvite programske rešitve ter analiza njenih dobrih
in slabih lastnosti je namenjena temu, da prikažemo vse dobre in slabe lastnosti aplikacije.
Dobre lastnosti aplikacije so, da vsi uporabniki vidijo podatke pomembne zanje in jih
spreminjajo v primeru, da so napačno vneseni v podatkovno zbirko.
Podatki, vneseni v podatkovno zbirko, morajo biti vedno natančno zapisani v primeru, da so
namenjeni kot obvestilo študentom. Napačni podatki, zapisani v podatkovno zbirko, bi v
primeru študentov pomenili zmedo, saj le-ti potrebujejo vedno natančne podatke o tem, kje
imajo predavanja ali vaje in kolokvije ter izpite. Elektronska oglasna deska je namenjena
uporabnikom, da preko uporabniškega vmesnika mobilne aplikacije vnesejo obvestila v
podatkovno zbirko. Podatki, zapisani v podatkovni zbirki, prikazujejo vse, kar uporabnik v
danem trenutku potrebuje.
Operacijski sistem Android ima nekaj dobrih strani, ki sem jih navedel v poglavju
Predstavitev operacijskega sistema Android. V omenjenem poglavju sem tudi zapisal vse
slabe strani operacijskega sistema Android, ki ga uporabljamo na pametnih mobilnih
telefonih, tabličnih računalnikih in ročnih urah. Ročnim uram z operacijskim sistemom
Android pravimo tudi pametne ročne ure. Android SDK je namenjen razvijalcem aplikacij za
operacijski sistem Android. Razvijalci aplikacij za operacijski sistem Android uporabljajo
Android SDK za razvijanje aplikacij in jih preizkušajo na virtualnih mobilnih telefonih ali na
dejanskih pametnih mobilnih telefonih z operacijskim sistemom Android. Tukaj so mišljeni
tudi kolokviji in izpiti, ki jih razpišejo profesorji. Podatki, zapisani v podatkovni zbirki,
prikazujejo vse, kar uporabnik v danem trenutku potrebuje.
MySQL podatkovna zbirka, ustvarjena v času izvedbe raziskave, je nameščena na prenosniku.
Širša množica uporabnikov v temu primeru pomeni, da so to študentje FIŠ, ki bi uporabljali
15
Android aplikacijo za dostop do MySQL podatkovne zbirke. JDBC povezava uporabljena za
povezavo med MySQL podatkovno zbirko in Android aplikacijami mora biti sprogramirana
tako, da ne dovoljuje dostop nikomur drugemu razen uporabnikom z uporabniškim imenom in
geslom.
Uporabniško ime in geslo, ki je zahtevano pri vpisu v MySQL podatkovno zbirko, je
uporabljeno zaradi urejanja podatkov, ki jih vanjo vnese uporabnik oziroma administrator.
Administrator za podatkovno zbirko pomeni uporabnika z vsemi pravicami za delo s
podatkovno zbirko. Uporabnik, ki ni obenem tudi administrator podatkovne zbirke, nima vseh
pravic za urejanje podatkov. Administrator podatkovne zbirke ima možnost, da vpisuje
podatke v podatkovno zbirko oziroma tabelo, ureja tabele v podatkovni zbirki, odstranjuje
tabele iz podatkovne zbirke, dodaja nove tabele vanjo in omejuje dostop ostalim uporabnikom
podatkovnih zbirk.
Uporabnik Android aplikacije sprogramirane v teku raziskave se bo moral najprej vpisati v
zbirko podatkov, da bi si pridobil uporabniško ime in geslo za delo s podatkovno zbirko.
Podatki zapisani v tabeli se pridobijo iz nje s pomočjo poizvedbe. Izvedbo poizvedb je
mogoče pohitriti z optimizacijo. Pri optimizaciji govorimo o tem, da zapišemo poizvedbe,
katere pošljemo na podatkovni strežnik na način, s katerim se njihovo izvajanje izvede hitreje
kot pri poizvedbah, ki jih predhodno nismo optimizirali. Optimizacija pomeni, da je zapis
poizvedbe zapisan bolj enostavno kot poizvedba, ki ni optimizirana. Primerjava hitrosti
izvedbe obeh je narejena zaradi pridobitve informacije, katera izmed njiju je boljša pri izvedbi
za Android aplikacijo.
3. EMPIRIČNI DEL
3.1 Zasnova celotne rešitve
Pri izvedbi raziskave za diplomsko nalogo sem uporabil operacijski sistem Android, JDBC
povezavo in MySQL podatkovno zbirko. Ob začetku programiranja Android aplikacije sem
namestil programsko okolje imenovano Eclipse z nameščenim dodatkom za Android. S
pomočjo tega orodja in dodatka sem se lotil programiranja aplikacije, ki shranjuje podatke v
16
podatkovno zbirko, do katere dostopa preko JDBC povezave. Podatkovna zbirka, sestavljena
v MySQL sistemu, je zanesljiva in odporna proti različnim vdorom.
Android aplikacija, sprogramirana v primeru raziskave, bo shranjevala podatke v podatkovno
zbirko in jih izpisovala na zaslon v primeru, če bo uporabnik želel videti, kaj je zapisano.
Operacijski sistem Android je tako kot programski jezik, ki ga uporablja, sestavljen iz več
različnih plasti, do večine katerih lahko dostopajo samo razvijalci aplikacij, medtem ko
navadni uporabniki ne morejo. Navadni uporabniki so mišljeni kot uporabniki pametnih
telefonov z Androidom.
JDBC povezava je največkrat uporabljena možnost za povezave med Android aplikacijo in
MySQL podatkovnim strežnikom. Podatkovna zbirka je nameščena na strežniku, ki ga imamo
nameščenega na svoj računalnik ali na oddaljen strežnik. Dejansko je vsak računalnik lahko
strežnik. Specializiran strežnik je prilagojen računalnik in ni nujno, da je bolj zmogljiv kot
ostali. Strežniki se uporabljajo za podporo spletnih strani, podatkovnih zbirk in za mnogo
podobnih nalog, ki jih opravlja podatkovni strežnik.
3.2 Zasnova in razvoj mobilne aplikacije
Za razvoj mobilne aplikacije, oziroma programiranje le-te, je bilo uporabljeno nekaj obsežne
literature, ki jo najdemo na spletu. Prav tako je dostopna literatura v tiskani obliki. Literatura
je mišljena kot pomoč pri programiranju mobilne aplikacije in tudi zapisu besedila o njenem
programiranju. Opis mobilne aplikacije se nahaja v nadaljevanju tega poglavja.
Mobilna aplikacija je zasnovana kot pomoč uporabnikom oziroma kot elektronska oglasna
deska, preko katere lahko le-ti preberejo podatke, zapisane v podatkovni zbirki. Uporabniški
vmesnik mobilne aplikacije je zasnovan iz treh zaslonov in dveh možnosti za prehod med
njimi. Prvi izmed treh zaslonov predstavlja prijavni in registracijski zaslon. Prijavni in
registracijski zaslon mobilne aplikacije vsebujeta polji za vnos uporabniškega imena in gesla
ter gumba za prijavo oziroma registracijo v primeru, da uporabnik še ni zapisan v podatkovno
zbirko.
Drugi zaslon mobilne aplikacije je namenjen prikazu tabele iz podatkovne zbirke. Na tem
zaslonu vidimo podatke pridobljene iz MySQL podatkovne zbirke, ki jih prenesemo preko
tehnologije JDBC. Omenjena tehnologija je namenjena varnemu prenosu podatkov in dostopu
do podatkovne zbirke, ki ni nameščena na enaki napravi kot aplikacija. V primeru, da
uporabljamo podatkovno zbirko na napravi, kjer imamo nameščeno aplikacijo, ki je v mojem
primeru nameščena na pametnem mobilnemu telefonu s sistemom Android, se uporablja tudi
17
drugačna različica SQL jezika. Sistem za pametne mobilne telefone imenovan Android
uporablja različico SQL jezika, ki se imenuje SQLite.
Tretji in obenem zadnji izmed zaslonov mobilne aplikacije predstavlja zapis oziroma urejanje
podatkov zapisanih v tabeli, ki je shranjena na strežniku z MySQL sistemom. Ob kliku na
gumb »shrani obvestilo«, se objava shrani v podatkovno zbirko. Nad gumbom je obvestilo z
okencem, ki uporabniku pove, ali je objava prikazana ali ne. Z njim prikažemo ali skrijemo
določeno objavo na zaslonu.
Možnosti, ki sem jih omenjal zgoraj, sta odjava in objava. Objava pomeni, da se z zaslona,
kjer prikazujemo podatke, zapisane v podatkovni zbirki, premaknemo na aktivnost objava
besedila (angleško PublishActivity). Ko pritisnemo gumb »shrani obvestilo«, se vrnemo na
aktivnost, ki nam prikazuje podatke na zaslon. Pri shranjevanju besedila v podatkovno zbirko,
nam tega prikaže na zaslonu le v primeru, da smo predhodno označili prikaz objave na
zaslonu.
Mobilna aplikacija je zasnovana kot rešitev problema obveščanja uporabnikov preko
elektronske oglasne deske. Pred začetkom zasnove sem moral namestiti razvojno okolje
Eclipse in vso programsko opremo, ki jo potrebujem za programiranje v operacijskem sistemu
Android.
Zatem sem se lotil programiranja algoritmov, s katerimi mobilna aplikacija dostopa do
podatkovne zbirke preko tehnologije JDBC. Algoritmi so potrebni zato, da se mobilna
aplikacija izvede, kot je potrebno in s tem nam tudi prikazuje podatke na zaslonu preko
uporabniškega vmesnika mobilne aplikacije.
Uporabniški vmesnik mobilne aplikacije je zasnovan na način, da uporabniku ob zagonu
aplikacije prikaže prijavni oziroma registracijski zaslon, za katerim sledi zaslon z izpisi
podatkov, ki so zapisani v podatkovni zbirki. Uporabniški vmesnik mobilne aplikacije se tudi
osveži v primeru, če administrator podatkovne zbirke izbriše iz nje vrstico. Algoritem za
osvežitev uporabniškega vmesnika mobilne aplikacije je nastavljen tako, da se aktivira le v
primeru, če se število vrstic v tabeli, zapisanih na strežniku, ne ujema s tisto, ki jo imamo
prikazano na zaslonu mobilne aplikacije. V primeru, da smo izbrisali vrstico iz podatkovne
zbirke, se nam to izvede tudi na zaslonu emulatorja pametnega mobilnega telefona.
Podatkovna zbirka je v primeru opisane raziskave sestavljena iz več tabel, kamor shranjujemo
podatke. Tabele, katere bom obravnaval v tem delu, so podatki o uporabnikih (users), tabela
»podatki« (data), tabela »skupin uporabnikov« (user_groups) in tabela »objav vidnih v
skupinah uporabnikov« (post_in_groups). V tabeli »podatki« so zapisana vsa obvestila, ki jih
v podatkovno zbirko vnesejo uporabniki, npr. študentje, referat ali profesorji. Tabela »skupin
18
uporabnikov« ima zapisana imena skupin in njihove id–je, s pomočjo katerih lahko prikažemo
podatke na uporabniškem vmesniku mobilne aplikacije. Zadnja tabela, ki je omenjena zgoraj,
je v podatkovni zbirki iz razloga, da vemo, katera skupina uporabnikov lahko vidi podatke,
namenjene njim in katera jih ne sme videti. Pri slednji je mišljeno, da so podatki namenjeni
študentom, profesorjem ali referatu in vsem skupinam ob enakem času.
3.3 Zasnova in razvoj centralne baze podatkov
Centralna baza podatkov oziroma centralni podatkovni strežnik je sestavljen iz podatkovne
zbirke in tabel, ki jih le-ta vsebuje. Za programiranje mobilne aplikacije in podatkovne zbirke
sem namestil orodje imenovano MySQL Workbench in MySQL strežnik, ki je potreben, da
podatkovna zbirka lahko deluje, kot je potrebno. Podatkovna zbirka, kreirana v času moje
raziskave, vsebuje podatke, vnešene preko uporabniškega vmesnika mobilne aplikacije.
Orodje MySQL Workbench, ki je bilo nameščeno na moj prenosnik v času raziskave, sem
uporabil za oblikovanje podatkovne zbirke. To orodje je odprtokodno in ne potrebuje veliko
učenja za ravnanje z njim.
Podatkovna zbirka vsebuje podatke, ki so za eksperiment pri raziskavi izmišljeni. Pri
izmišljenih podatkih je mišljeno, da so to podatki, ki sem jih vzel z oglasne deske spletnega
referata Fakultete za informacijske študije in jih uporabil kot testne podatke, da sem lahko
preizkusil mobilno aplikacijo, ki jo predstavlja pričujoče besedilo. Podatki so v podatkovno
zbirko zapisani tako, kot jih je uporabnik vnesel vanjo in jih lahko spremenimo le v
podatkovni zbirki. Uporabnik podatke, zapisane v podatkovni zbirki, ureja preko
uporabniškega vmesnika mobilne aplikacije in jih shranjuje vanjo preko povezave z JDBC.
Podatkovna zbirka v primeru moje raziskave vsebuje dve tabeli. V prvi tabeli se zapisujejo
podatki o uporabnikih mobilne aplikacije, kot so id, uporabniško ime (ta podatek je v tabeli
zapisan kot user_name) in geslo (ta podatek je v tabeli zapisan kot password). Prva tabela se
imenuje »uporabniki« oziroma »users« v angleščini. Druga tabela se imenuje »podatki«
oziroma »data« v angleščini. Tabela »data« vsebuje stolpce imenovane podatki, id (v tem
stolpcu je id objave), id_user (tukaj je zapisan id uporabnika) in stolpec imenovan »active«, ki
s »true« ali »false« prikaže, ali je objava prikazana na zaslonu ali ne. Tabela »uporabnikov« je
nastala na podlagi tega, da vidimo, kdo vse se vpisuje v aplikacijo in prebira iz nje podatke. V
tabeli s podatki se nam zapisujejo objave, ki jih uporabniki vnesejo v podatkovno zbirko
preko mobilne aplikacije.
19
3.4 Uporabniška dokumentacija
To poglavje predstavlja, kako je mobilna aplikacija videti in kaj vse lahko uporabnik dela z
njo. Za predstavitvijo opisa videza se nahajajo tudi zaslonski posnetki mobilne aplikacije
posneti med izvedbo. Uporabnik se lahko prijavi v aplikacijo, ali se pred prijavo vanjo
registrira, prebere že objavljene informacije, nato se premakne na zaslon z novimi objavami.
Na tem mestu ima možnost zapisa nove objave, ki jo pred tem uredi in označi v okencu, v
katerem je vprašanje, ali je prikazana objava. Vse te funkcije potekajo s pomočjo kode,
zapisane v programskem jeziku Java. Mobilna aplikacija, predstavljena v tem poglavju, ima
tri različne zaslone in dve možnosti za prehod med njimi, ki jih uporabnik lahko uporablja
med izvedbo mobilne aplikacije. Primeri uporabe mobilne aplikacije so lahko na primer vnos
objave, ki se zgodi s strani referata, izbris objave, ki se zgodi s strani referata in pregled objav,
ki se zgodi s strani študenta.
Na Sliki 3.1 je prikazan primer uporabe mobilne aplikacije kot vnos objave s strani referata,
pri katerem so dodane zaslonske slike. V času, ko uslužbenec referata zažene mobilno
aplikacijo in preden se prijavi vanjo kot uporabnik, se mu na zaslonu mobilne aplikacije
prikaže prijavni zaslon. Zaslonski posnetek prijavnega zaslona, ki se prikaže delavcu v
referatu, sledi v nadaljevanju.
20
Slika 3.1: Prijavni zaslon mobilne aplikacije brez podatkov za prijavo
Vir: Demšar, lastni prikaz (2015)
Na Sliki 3.2 je prikazan posnetek zaslona v času, ko določen uporabnik, ki je v trenutnem
primeru uslužbenec referata, vpiše svoje prijavne podatke in pritisne gumb »prijava«.
Omenjeni gumb se nahaja pod poljema za uporabniško ime in geslo. Pod njim je tudi dodan
gumb »registracija«, ki ga uporabnik pritisne le v primeru, da ni predhodno registriran v
mobilno aplikacijo. Zaslonski posnetek je prikazan v nadaljevanju.
21
Slika 3.2: Prijavni zaslon s podatki za prijavo v mobilno aplikacijo
Vir: Demšar, lastni prikaz (2015)
Na Sliki 3.3 je prikazan zaslonski posnetek, ki predstavlja zaslon z izpisi podatkov iz
podatkovne zbirke. Uporabnik pride do tega zaslona takrat, ko pritisne gumb prijava na
prijavnem zaslonu. Mobilna aplikacija je prototip in ni popolnoma primerna za uporabo v
prodaji. S tem je mišljeno, da so vse zaslonske slike narejene s pomočjo emulatorja
pametnega mobilnega telefona. Na zaslonskemu posnetku, ki sledi v nadaljevanju, uslužbenec
referata lahko vidi vse podatke, ki jih je vnesel sam in tiste, ki so jih vnesli drugi uporabniki
in so vidni tudi njemu oziroma skupini, v katero spada.
22
Slika 3.3: Zaslon z izpisi iz podatkovne zbirke
Vir: Demšar, lastni prikaz (2015)
Na Sliki 3.4 je prikazan posnetek zaslona z izpisi iz podatkovne zbirke, obenem je na njem
prikazan prav tako skriti gumb »shrani obvestilo« in »odjava«. Ker je tukaj opisan primer
vnosa nove objave s strani referata, se osredotočam le na gumb »shrani obvestilo«. Ob
pritisku na omenjeni gumb se aplikacija premakne na zaslon z novo objavo, kjer uporabnik
doda svoje obvestilo, določi katera skupina ga lahko vidi in ali je objava sploh vidna na
zaslonu ali ne.
23
Slika 3.4: Zaslon z gumbom »shrani obvestilo« in »odjava«
Vir: Demšar, lastni prikaz (2015)
Na Sliki 3.5 je prikazan zaslonski posnetek, ki nam predstavlja zaslon za dodajanje nove
objave. Ta je sestavljen iz polja z besedilom, ki je pred dodajanjem novega besedila prazno,
za njim sledi polje z izborom skupin, ki se uporabniku prikaže takoj, ko pritisne na del
zaslona z napisom »objavi v vse skupine«. Nato se uporabniku pojavi seznam vseh skupin,
izmed katerih izbere tiste, ki lahko vidijo njegovo objavo. Na spodnjemu delu zaslona je
vrstica z vprašanjem »prikažem objavo?« in gumb »shrani obvestilo«, ki je enako
24
poimenovan kot gumb na zaslonu z izpisi podatkov. To, da sta gumba enako poimenovana,
pomeni, da opravljata enako funkcijo oziroma omogočata možnost shranjevanja nove objave
ali oblikovanja že vnesene objave.
Slika 3.5: Zaslon za dodajanje objave brez dodanega besedila
Vir: Demšar, lastni prikaz (2015)
Na Sliki 3.6 je prikazan zaslonski posnetek, ki predstavlja enak zaslon, kot je prikazan na
Sliki 3.5, le s to razliko, da je na njem tudi dodano besedilo, ki se kasneje shrani v podatkovno
zbirko s pomočjo tehnologije JDBC, preko katere se mobilna aplikacija poveže do
podatkovne zbirke in s tem tudi shrani podatke vanjo. Besedilo, ki ga je uporabnik vnesel v
uporabniški vmesnik mobilne aplikacije, se prikaže na zaslonu z izpisi podatkov shranjenih v
podatkovni zbirki le v primeru, da se je uspešno shranilo v podatkovno zbirko.
25
Slika 3.6: Zaslon za dodajanje novih objav z dodanim besedilom
Vir: Demšar, lastni prikaz (2015)
Na Sliki 3.7 je prikazan primer izpisa podatkov iz podatkovne zbirke, pri katerem se izpisi
prikazujejo v dopolnjeni različici z objavo, ki jo je uporabnik dodal v podatkovno zbirko
preko uporabniškega vmesnika mobilne aplikacije. V primeru, da administrator, ki se ukvarja
s podatkovno zbirko, izbriše vrstico iz tabele, se nam zaslon osveži s tem, da se izbrisana
vrstica umakne z zaslona mobilne aplikacije. Ko se določena vrstica izbriše iz podatkovne
zbirke, se ob tem izbriše tudi id izbrisane vrstice. To povzroči, da se vsaka naslednja vrstica v
26
tabeli šteje za eno več zaradi izbrisanega id-ja vrstice, ki je bila izbrisana s strani
administratorja podatkovne zbirke.
Slika 3.7: Zaslon z dopolnjenimi izpisi iz podatkovne zbirke
Vir: Demšar, lastni prikaz (2015)
Na Sliki 3.8 je prikazan drugi primer uporabe mobilne aplikacije oziroma pregled objav, ki se
zgodi samo s strani študentov. Študent se kot uporabnik prijavi v mobilno aplikacijo, tako kot
je opisano pod primerom vnosa nove objave s strani uslužbenca v referatu. Študent najprej
zažene mobilno aplikacijo na svojem mobilnem telefonu, ki ga v trenutnem primeru
predstavlja emulator. Na zaslonu se mu prikaže prijavni zaslon, ki je prikazan v nadaljevanju.
27
Temu je dodan posnetek zaslona, na katerem so navedeni tudi podatki uporabnika. Prvi zaslon
mobilne aplikacije, ki ga vidi vsak uporabnik, je zaslon z dvema praznima poljema za
besedilo in dvema gumboma.
Slika 3.8: Zaslon s katerim se vsak nov uporabnik prijavi ali registrira v mobilno aplikacijo
Vir: Demšar, lastni prikaz (2015)
Na Sliki 3.9 je prikazan zaslonski posnetek študenta, ki se je vpisal s svojimi uporabniškimi
podatki, ki se za razliko od posnetka zaslona pri uslužbencu referata ne razlikuje. Uporabniški
podatki študenta se razlikujejo od uporabniških podatkov uslužbenca referata v vsem razen
gesel, saj gre le za testne podatke. Dejanski uporabniki predstavljene mobilne aplikacije bi
imeli svoja lastna uporabniška imena in gesla, česar ne moremo trditi za trenutne uporabnike
28
in podatke, ki so vneseni v podatkovno zbirko. Zaslonski posnetek s podatki za primer
študenta sledi v nadaljevanju.
Slika 3.9: Zaslon s podatki, ki služi kot primer za študenta
Vir: Demšar, lastni prikaz (2015)
Na Sliki 3.10 je prikazan zaslonski posnetek, ki predstavlja drugi zaslon oziroma zaslon z
izpisi iz podatkovne zbirke in je prilagojen glede na to, v katero skupino je uporabnik
dodeljen ob registraciji v mobilno aplikacijo oziroma po tem, ko se pogovori z
administratorjem podatkovne zbirke o tem, v kateri skupini želi biti. Kot primer je podan
študent, pri katerem lahko vidimo le podatke zapisane v podatkovno zbirko in prikazane v tej
29
skupini. Skupina imenovana »študentje« lahko vidi objave vnesene v podatkovno zbirko s
strani študentov, profesorjev in referata. Obenem lahko tudi sami objavljajo obvestila in jih
prikažejo v vseh treh skupinah kot vsi ostali uporabniki mobilne aplikacije.
Slika 3.10: Zaslon z objavami, ki jih vidi vsak študent
Vir: Demšar, lastni prikaz (2015)
Tretji primer uporabe mobilne aplikacije je izbris objave s strani referata. Tega primera ne
morem prikazati z zaslonskimi slikami, ker se objave lahko izbrišejo le s strani
administratorja podatkovne zbirke. Administrator podatkovne zbirke je zadolžen za delovanje
podatkovnega strežnika in njegovo vzdrževanje.
30
3.5 Uporabniški vmesnik
V poglavju o uporabniškem vmesniku je opisano, kako je videti uporabniški vmesnik mobilne
aplikacije, obenem je na omenjenem mestu predstavljena tudi programska koda aplikacije ter
uporabniškega vmesnika, ki ji pripada.
Na Sliki 3.11 je prikazan prvi zaslon mobilne aplikacije, ki predstavlja prijavni in
registracijski zaslon. Prijavni zaslon pomeni, da se vsi uporabniki, ki so že registrirani v
mobilni aplikaciji, lahko vanjo prijavijo. Preko mobilne aplikacije lahko nato dodajajo nove
objave v podatkovno zbirko ali urejajo tiste, ki so že zapisane v njej. Registracijski zaslon
deluje podobno kot prijavni. Pri registracijskem zaslonu se uporabnik najprej registrira kot
nov uporabnik in šele zatem dobi možnost, da lahko objavlja nove podatke oziroma obvestila
na elektronsko oglasno desko ter jih tam tudi spreminja, kot je zapisano v primeru že
obstoječega uporabnika. Na Sliki 3.12 je prikazan drugi zaslon mobilne aplikacije, ki
prikazuje podatke iz podatkovne zbirke in se tudi osvežuje v primeru, da administrator
podatkovne zbirke izbriše nepotrebno obvestilo iz nje. Na Sliki 3.13 je prikazan zaslon, ki
predstavlja zaslon za objavo novega obvestila, kamor uporabnik zapiše besedilo v za to
predvideno polje. Za vpisom besedila izbere, v kateri skupini uporabnikov je objava vidna, in
ali je vidna v aplikaciji ali ne, ter shrani obvestilo v podatkovno zbirko. Obvestilo, ki ga
uporabnik shrani v podatkovno zbirko se obenem tudi prikaže na zaslonu aplikacije. Mobilna
aplikacija ima dve možnosti, ki sta prikazani v meniju ter vodita uporabnika mobilne
aplikacije do objave novega obvestila ali odjave iz aplikacije. Odjava iz aplikacije pomeni, da
se uporabnik odjavi in se s tem vrne nazaj na prijavni in registracijski zaslon mobilne
aplikacije.
V nadaljevanju tega podpoglavja bodo tudi zaslonski posnetki mobilne aplikacije, ki bodo
nazorno prikazali vse, kar je bilo opisano zgoraj. Koda mobilne aplikacije, JDBC povezave in
MySQL podatkovne zbirke se nahaja v prilogi diplomske naloge. Prvi posnetek zaslona, ki je
dodan v nadaljevanju, predstavlja prijavni in registracijski zaslon.
31
Slika 3.11: Prvi zaslon mobilne aplikacije, ki prikazuje prijavni zaslon za prijavo uporabnika
in registracijski zaslon, ki prikazuje registracijo uporabnika
Vir: Demšar, lastni prikaz (2015)
Na Sliki 3.11 je prikazan zaslonski posnetek prvega zaslona mobilne aplikacije, ki ima dve
polji za vnos besedila in dva gumba. Prvo polje, ki ga vsebuje prijavni in obenem tudi
registracijski zaslon, je imenovano uporabniško ime. Drugo polje, ki ga vsebujeta oba
zaslona, se imenuje geslo. Prijavni zaslon vsebuje tudi gumb imenovan »prijava«.
32
Registracijski zaslon vsebuje gumb imenovan »registracija«. V polji uporabniško ime in geslo
uporabnik vnese zahtevane podatke, ki ju predhodno ustvari za prijavo v aplikacijo.
Uporabniško ime in geslo se uporabljata tudi pri registraciji uporabnika v aplikacijo. Pri
registraciji uporabnika se uporabniško ime in geslo zapišeta v podatkovno zbirko. Uporabniku
se ob registraciji samodejno dodeli skupina študent. V primeru, da uporabnik želi biti v kateri
drugi skupini, mora priti v stik z administratorjem podatkovne zbirke. Prijava deluje podobno
kot registracija, toda uporabnik ne potrebuje vpisati skupine, v kateri je zapisan v podatkovni
zbirki.
Na Sliki 3.12, ki se nahaja na naslednji strani, je prikazan zaslonski posnetek aplikacije, ki
prikazuje vse zapise v podatkovni zbirki. Zapisi so lahko prikazani bodisi posamičnemu
uporabniku bodisi celotni skupini uporabnikov glede na to, ali je le-ta označena za prikaz
podatkov ali ne. Iz iste slike je razvidno, da nam mobilna aplikacija prikaže samo objave, ki
so namenjene določenemu uporabniku. Na omenjeni zaslonski sliki so prikazane vse objave,
ki jih lahko vidi uporabnik imenovan »root«. Omenjeni uporabnik spada v skupino referat in
lahko vidi objave, ki jih je objavil sam in objave, ki so sicer objavljene pod drugimi
uporabniškimi imeni, toda spadajo v enako skupino kot omenjeni uporabnik. Vse objave, ki
so prikazane na spodnji zaslonski sliki, so namenjene samo preizkusu aplikacije, ker bodo
dejanske objave vidne v njej šele takrat, ko bo aplikacija dovolj optimizirana za uporabo v
širši množici. Pri objavah so prikazana tudi uporabniška imena testnih uporabnikov, razmik
med njimi je označen z zeleno črto ter praznim prostorom okoli nje. Po posodobitvi aplikacije
zaradi osveževanja se zelene črte ne vidi, ker je bilo potrebno spremeniti zaslon, na katerem
so prikazani podatki. V primeru, da je objav več, kot jih lahko vidimo na zaslonu, se nam
prikažejo s pomočjo drsnika, ki je sicer neviden, toda uporaben za premikanje po zaslonu
navzgor in navzdol. Trenutna zaslonska slika prikazuje le štiri testne objave in s tem se drsnik
ob zaslonu še ne uporabi, ker ni potreben. Izris celotnega zaslona z objavami je v mobilni
aplikaciji rešen programsko. Izris podatkov na zaslon z objavami se zgodi takoj, ko se
določen uporabnik prijavi v mobilno aplikacijo in osveži v primeru, da administrator
podatkovne zbirke izbriše vrstico v tabeli. Takoj, ko administrator podatkovne zbirke izbriše
vrstico v tabeli, se celotna aktivnost zapre in ponovno odpre, kar pomeni, da se celoten zaslon
s podatki izriše popolnoma na novo.
33
Slika 3.12: Drugi zaslon mobilne aplikacije prikazuje podatke pridobljene iz podatkovne
zbirke izrisane na zaslonu
Vir: Demšar, lastni prikaz (2015)
Na Sliki 3.13 je prikazan zaslonski posnetek mobilne aplikacije, ki predstavlja objavo novega
besedila na elektronsko oglasno desko. Ta zaslon ima na vrhu polje, v katerega vnesemo
besedilo. Pod poljem z besedilom se nahaja izbira, v kateri skupini je vidna objavljena objava.
Na dnu zaslona sta vidna vprašanje »prikažem objavo?« in gumb imenovan »shrani
34
obvestilo«. Možnost imenovana »shrani objavo« uporabniku pomaga, da pride do zaslona, ki
je opisan zgoraj.
Slika 3.13:Tretji in obenem zadnji zaslon aplikacije prikazuje zaslon za objavo novega
obvestila
Vir: Demšar, lastni prikaz (2015)
Na Sliki 3.13 je prikazan zaslonski posnetek mobilne aplikacije, ki predstavlja zaslon za vnos
novega obvestila. Zaslon vsebuje polje za vnos besedila, v katerega uporabnik zapiše besedilo
namenjeno za objavo. Pod tem poljem izbere, v katero skupino naj se nova objava prikaže, na
dnu zaslona ima prav tako izbiro, ali naj bo objava prikazana ali ne. Ko uporabnik pritisne
35
gumb imenovan »shrani obvestilo« se besedilo zapiše v podatkovno zbirko in prikaže
uporabniku v njegovi skupini. Da se besedilo res prikaže samo uporabniku in vsem v njegovi
skupini, skrbi izbor, v kateri skupini je objava prikazana.
Možnosti, ki sta dodani v aplikaciji za prehod med tremi aktivnostmi, sta gumba »objava
obvestila« in »odjava«. Oba omenjena gumba se nahajata v meniju, do katerega lahko
dostopamo samo na zaslonu s prikazanimi objavami. Meni z omenjenima gumboma se nahaja
v zgornjem desnem kotu zaslona in obenem v naslovni vrstici aplikacije. Naslovna vrstica
aplikacije je del zaslona, ki je temnejše barve, na njem pa se izpiše ime aplikacije. Prvi in
tretji zaslon mobilne aplikacije tega nimata, ker je drugi zaslon edini, na katerem ni gumba in
potrebuje meni, pri katerem se uporabnik odloči, kaj bo naredil. V primeru, da se odloči za
shranjevanje novega besedila, klikne na gumb »objava obvestila« in s tem pride na zaslon za
objavo novega obvestila. V primeru, da se odloči za odjavo iz aplikacije, torej klikne na gumb
»odjava«, ga aplikacija vodi nazaj do prijavnega oziroma registracijskega zaslona.
Pri objavi novega obvestila uporabnik doda besedilo na elektronsko oglasno desko, izbere
katera skupina uporabnikov ga lahko vidi, izbere ali je objava vidna in shrani obvestilo. Po
shranitvi besedila, vrne aplikacija uporabnika na prikaz podatkov, kjer je kot prva prikazana
objava, ki jo je zapisal sam, vse starejše objave pa so prikazane pod njo. Da so starejše objave
prikazane pod novejšo, pomeni, da sem pri programiranju mobilne aplikacije uporabil
poizvedbo, katera uredi id objav od najnovejše proti najstarejši oziroma uporablja padajoči
vrstni red za njihovo objavo. Objave prikaže tudi glede na id uporabnika in id skupine, v
kateri se trenutno prijavljeni uporabnik nahaja, kar pomeni, da je poizvedba napisana na
način, s katerim je to mogoče narediti.
Pri odjavi iz aplikacije uporabnik samo pritisne na gumb »odjava« in aplikacija se vrne na
zaslon, preko katerega se je prijavil vanjo oziroma se mu je prikazal kot prvi zaslon takoj, ko
je zagnal mobilno aplikacijo na svojem pametnem mobilnem telefonu. Uporabniku se ob
zagonu mobilne aplikacije takoj prikaže zaslon, ki je predstavljen pod sliko 1 in opisan nad
dodanim posnetkom zaslona. Da se uporabnik lahko registrira v mobilno aplikacijo, mora
najprej vpisati uporabniško ime in geslo v polji predvideni za to in pritisniti gumb imenovan
»registracija«. V času, ko uporabnik pritisne gumb »registracija«, se mu v ozadju izvajanja
mobilne aplikacije samodejno pripiše skupino in njegove podatke shrani v podatkovno zbirko
oziroma natančneje v tabelo imenovano »users«. Objave, ki jih na novo registrirani oziroma
pozneje prijavljeni uporabnik zapiše v mobilno aplikacijo, se preko nje shranijo v tabelo
imenovano »data«. Ob prijavi predhodno registrirani uporabnik vpiše svoje uporabniško ime
in geslo v mobilno aplikacijo in objavlja nove objave na elektronsko oglasno desko in jih
36
spreminja. Da jih lahko spreminja, mora mobilna aplikacija v ozadju preveriti njegov id in id
uporabnika iz tabele »data« ter ju primerjati med seboj. V primeru, da se vrednosti ujemata
oziroma sta enaki, je uporabniku dovoljeno spreminjati objavo, ki jo je sam zapisal. V
nasprotnemu primeru, ko sta vrednosti različni, uporabnik ne more spreminjati objave
prikazane na zaslonu pametnega mobilnega telefona. Uporabnik lahko objavlja nove objave
na elektronsko oglasno desko, toda ureja in s tem spreminja pa lahko le vse tiste, ki jih je sam
dodal. Uporabnikov mobilne aplikacije je lahko več tisoč, a jih je v testnem primeru oziroma
v primeru pričujoče raziskave mnogo manj, kot bi jih bilo v primeru aplikacije dostopne na
odprtem tržišču.
Na naslednjemu primeru je prikazan del kode, ki skrbi, da se izriše prijavni ter registracijski
zaslon mobilne aplikacije. Oba sta izdelana s pomočjo programskega jezika Java in jezika
XML, ki je uporabljen za videz zaslona. Programski jezik Java skrbi za to, da se mobilna
aplikacija izvaja v operacijskem sistemu, medtem ko XML skrbi le za to, kako je vsebina
zaslonov videti s strani uporabnika. Primeri programske kode z deli kode so dodani v
nadaljevanju poglavja. Prvi primer programske kode je koda zapisana v programskem jeziku
Java, ki skrbi, da se polja in gumba na prvem zaslonu, dodanem zgoraj, sploh izrišeta. Opis in
podrobnejša razlaga, kaj določen del programske kode počne, se nahajata pod priloženim
primerom programske kode.
package com.example.bulletinboard;
import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android widget.Button;
import android.widget.EditText;
import android.widget.Toast;
import java.sql.Connection;
import java.sql.ResultSet;
37
import com.example.bulletinboard.DataBaseAccess.Callback;
public class MainActivity extends ActionBarActivity implements onClickListener {
Connection con;
Button buttonAuth;
Button registrationButton;
EditText username;
EditText password;
static int id_uporabnika = -1;
static int id_group = -1;
static String uporabnisko_ime = "";
static String uporabnisko_geslo = "";
ResultSet rs;
static int rowcount;
Callback cb = new Callback() {
@Override
public void onComplete(String myResult) {
makeToast(myResult);
startActivity();
}
};
Na zgoraj prikazanem primeru programske kode je podan začetni del aktivnosti MainActivity,
ki nam prikazuje paket, v katerem je aplikacija shranjena in pakete, s katerimi lahko sploh
izvedemo aplikacijo in definicijo glavne aktivnosti oziroma začetnega razreda mobilne
aplikacije. Pod definicijo glavne aktivnosti definiramo še metodo imenovano Callback(), ki
nam pomaga, da se aplikacija ne zaustavi, medtem ko izrisujemo zaslon na pametnem
mobilnem telefonu. Nadaljnji deli kode se nahajajo pod tem odstavkom.
38
@Override
proteted void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.i("MainActivity", "onCreate");
buttonAuth = (Button)findViewById(R.id.buttonAuth);
buttonAuth.setOnClickListener(this);
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
return super.onOptionsItemSelected(item);
}
@Override
public void onClick(View v) {
39
Na primeru programske kode, ki je prikazan zgoraj, vidimo kodo metode imenovane
onCreate(). Metoda se izvede ob zagonu aplikacije in nam izriše zaslon, ki ga vidimo na Sliki
3.11 oziroma primer zaslona prikazan na začetku poglavja v katerem govorim o videzu
uporabniškega vmesnika mobilne aplikacije za pametni mobilni telefon z operacijskim
sistemom Android. Naslednja metoda imenovana onSaveInstanceState() se izvede ob vsaki
prekinitvi oziroma ponovnem zagonu mobilne aplikacije. Metodi, kot sta
onCreateOptionsMenu() in onOptionsItemSelected(), se izvedeta samo v primeru, če imata
kakšno lastnost definirano in če uporabnik pritisne na gumb, ki se skriva v meniju. Metoda
onClick(), pri kateri je na zgornjemu primeru programske kode samo naslovni del, se izvede v
primeru, da uporabnik pritisne na gumb »prijava« ali »registracija«, ki sta prikazana na
zaslonu njegovega pametnega mobilnega telefona. Nadaljevanje razlage oziroma opisa kaj
počne programska koda, se nahaja pod naslednjim primerom programske kode.
If(v.getId() == R.id.buttonAuth) {
EditText username = (EditText)findViewById(R.id.user_name);
EditText password = (EditText)findViewById(R.id.pass_word);
Uporabnisko_ime = username.getText().toString();
Uporabnisko_geslo = password.getText().toString();
if(uporabnisko_ime.equals("") || uporabnisko_geslo.equals("")) {
Toast toast = Toast.makeText(this, "Uporabniško ime ali geslo
ne sme biti prazno!", Toast.LENGTH_LONG);
Toast.show();
}
else {
DataBaseAccess access = new DataBaseAccess(cb);
Access.execute("prijava");
}
}
If(v.getId() == R.id.registrationButton {
40
EditText username = (EditText)findViewById(R.id.user_name);
EditText password = (EditText)findViewById(R.id.pass_word);
uporabnisko_ime = username.getText().toString();
uporabnisko_geslo = password.getText().toString();
if(uporabnisko_ime.equals("") || uporabnisko_geslo.equals("")) {
Toast toast = Toast.makeText(this, "Uporabniško ime ali geslo
ne sme biti prazno!" Toast.LENGTH_LONG);
Toast.show();
}
else {
Na primeru programske kode, ki je viden zgoraj, je prikazana omenjena metoda onClick(), s
katero se izvede del kode, ki se nahaja v »if« stavku zgoraj. V omenjenem »if« stavku
preverimo uporabnikov vnos v polji »username« in »password«, ki sta tipa EditText. Če je
katero izmed polj prazno, se izvede notranji »if« stavek in na zaslonu mobilne aplikacije se
izpiše »pop up« okence z obvestilom »uporabniško ime ali geslo ne sme biti prazno!«. Če
uporabnikov vnos ni prazen, se izvede »else« stavek, kar pomeni, da aplikacija ustvari novo
nit, s katero se poveže s podatkovno zbirko. S tem postopkom obenem preverimo, ali so
podatki pravilno vneseni. V primeru, da se uporabnik na novo registrira v mobilno aplikacijo,
se izvede del kode, ki se nahaja v drugem »if« stavku in preverja, ali je uporabnik pritisnil
gumb za registracijo. Znotraj tega »if« stavka, podobno kot pri prejšnjem, preverjamo, ali sta
polji za uporabniško ime oziroma geslo prazni. V primeru, da je eno polje prazno, izpišemo
obvestilo. Pri tem delu kode je le naslovni del stavka »else«, pri katerem se tako kot v
prejšnjem primeru vzpostavi povezava s podatkovno zbirko in preveri, ali so vsi podatki
pravilno vneseni. Preostanek stavka »else« in razlaga ostale kode se nahajata pod naslednjim
primerom programske kode.
DataBaseAccess access = new DataBaseAccess(cb);
41
Access.execute("registracija");
}
}
}
public void makeToast(String myResult) {
if(myResult != null) {
Toast toast = Toast.makeText(this, myResult, Toast.LENGTH_LONG);
Toast.show();
}
}
public void startActivity() {
if(id_uporabnika != -1) {
startActivity(new Intent(this, BulletinBoardActivity.class));
}
}
public static void setUserId(int id) {
id_uporabnika = id;
}
public static void setUserGroupId(int group) {
id_group = group;
}
public static int getId_group() {
return id_group;
42
}
Na zgornjemu primeru programske kode je prikazan tako del kode oziroma preostanek stavka
»else« kot tudi metode, ki mu sledijo. Ena izmed metod je imenovana makeToast() in skrbi,
da se izpišejo besedila v »pop up« okencih pri prehodu med aktivnostmi. Metoda imenovana
startActivity() poskrbi, da se trenutna aktivnost preneha izvajati in odpre novo, s katero
prikažemo vse objave iz podatkovne zbirke. Za omenjeno metodo sledijo get() in set()
metode, ki nam vračajo podatke potrebne za izvedbo mobilne aplikacije. Vse »get« in »set«
metode se kličejo iz preostalih aktivnosti, katerih dele kod predstavljamo z primeri
programske kode, priloženimi v nadaljevanju. Naslednji primer programske kode predstavlja
del kode, ki pripada aktivnosti imenovani MainActivity, za katero so prikazani vsi primeri
prograsmke kode dodani zgoraj.
public void startActivity() {
if(id_uporabnika != -1) {
startActivity(new Intent(this, BulletinBoardActivity.class));
}
}
public static int getUserId() {
return id_uporabnika;
}
public static void setUserGroupId(int group) {
id_group = group;
}
public static String getUser() {
return uporabnisko_ime;
43
}
public static int getRowCount() {
return rowcount;
}
public static void setRowCount(int count) {
rowcount = count;
}
}
Na zgoraj prikazanemu primeru je prikazan zadnji del javanske kode, ki je uporabljen za
delovanje procesov v mobilni aplikaciji. Programska koda, ki skrbi, da se drugi zaslon sploh
prikaže, je prav tako dodana v nadaljevanju. Aktivnost, imenovana BulletinBoardActivity,
uporablja podobne metode kot prejšnja aktivnost, le da so prirejene za delo z izrisom
podatkov. V programski kodi je na začetku, tako kot v prejšnjem primeru, zapisan paket, v
katerem je shranjena celotna aplikacija. Za tem sledijo definicije paketov, ki jih potrebujemo
za izvedbo aktivnosti, definicija glavne aktivnosti, definicija spremenljivk potrebnih, da se
aplikacija sploh izvede in metode, ki so potrebne za izvedbo aktivnosti ter s tem izrisa
podatkov na zaslon mobilne aplikacije.
Statične metode, kot so setUpdatePostId(), getUpdatePostId() in getBesedilo(), nam vrnejo
vrednosti, kot sta id objave in besedilo, ki ga pridobimo iz podatkovne zbirke. Metoda
Callback() nam pomaga pri preprečitvi zmrzovanja izvajanja uporabniškega vmesnika,
medtem ko čakamo na izvedbo druge niti. V primeru BulletinBoardActivity se po izvajanju
niti naredi izris podatkov na zaslon. Za tem je implementirana še ena Callback() metoda, ki pa
se izvede samo v primeru osvežitve zaslona oziroma v primeru, da administrator izbriše
vrstico iz podatkovne zbirke.
Za statičnimi metodami in metodami imenovanimi Callback() se izvede metoda onCreate(), ki
zažene nit za pridobivanje objav iz podatkovne zbirke. Metoda onCreateOptionsMenu() se
izvede podobno kot v prejšnji aktivnosti, medtem ko se metoda OnOptionsItemSelected() ne
izvede enako kot v prejšnji aktivnosti, ker imamo tukaj na izbiro »odjavo« in »objavo«
44
novega obvestila. V primeru, da uporabnik pritisne gumb »odjava«, se odpre prva aktivnost.
V primeru, da uporabnik pritisne gumb »objava« obvestila, se odpre aktivnost za izvedbo
objave novega obvestila. Za metodama opisanima v prejšnjem odstavku, se izvede metoda
izrisPodatkov(), ki nam izriše vse podatke pridobljene iz podatkovne zbirke na zaslon oziroma
v uporabniški vmesnik mobilne aplikacije. Podrobnejši opis vseh metod sledi za posameznim
primerom programske kode dodanim v nadaljevanju.
package com.example.bulletinboard;
import java.util.LinkedHashMap;
import com.example.bulletinboard.DataBaseAccess.Callback;
import android.support.v7.app.ActionBarActivity;
import android.text.Html;
import android.text.Spanned;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.Toast;
public class BulletinBoardActivity extends ActionBarActivity {
static LinkedHashMap<Integer, Post> objave;
static CharSequence besedilo = "";
static int updatePostId = -1;
protected static final int REFRESH = 0;
ListView list;
45
public static void setUpdatePostId(int updatePostId) {
BulletinBoardActivity.updatePostId = updatePostId;
}
public static int getUpdatePostId() {
return besedilo;
}
Callback cb = new Callback() {
@Override
V zgornjemu primeru programske kode so prikazani vse potrebni podatki, da se aktivnost
začne izvajati. Najprej definiramo paket, v katerem je shranjena aktivnost. Zatem definiramo
spremenljivke potrebne za delo z aktivnostjo, nato samo ime aktivnosti. Pod njenim imenom
definiramo tudi spremenljivke, ki jih uporabljamo samo v aktivnosti, katero sedaj opisujemo.
Metode, kot so setUpdatePostId() in getUpdatePostId() ter getBesedilo(), nam vrnejo
vrednosti potrebne za izris podatkov na zaslon mobilne aplikacije. Metoda Callback() se nam
tako kot v prejšnjem primeru izvede med izrisom podatkov na zaslon in preprečuje
zmrzovanje izvajanja aplikacije, pri čemer se izvaja nit imenovana DataBaseAccess.
Naslednji primer programske kode prikazan spodaj prikazuje prav ta del programske kode.
Omenjena metoda se izvaja tudi med vsako osvežitvijo zaslona, pri čemer se uporablja
DataBaseAccess nit kot dostop do podatkovne zbirke in do tabel, v katerih so podatki, ki jih
poskušamo prikazati na zaslonu mobilne aplikacije.
public void onComplete(String myResult) {
izrisPodatkov();
}
};
Callback c = new Callback() {
46
@Override
public void onComplete(String myResult) {
if(!myResult.equals("false")) {
DataBaseAccess a = new DataBaseAccess(cb);
a.execute("objave");
}
DataBaseAccess a = new DataBaseAccess(c);
a.execute("osvezi");
}
};
// Metoda BulletinBoard.onCreate se izvede ob zagonu aktivnosti in zažene nit za
pridobivanje objav iz podatkovne zbirke.
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_bulletin_board);
DataBaseAccess access = new DataBaseAccess(cb);
access.execute("objave");
DataBaseAccess a = new DataBaseAccess(c);
a.execute("osvezi");
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.bulletin_board, menu);
return true;
47
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. This action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
if(id == R.id.odjava) {
Vse metode opisane v zgornjih odstavkih se izvedejo samo takrat, ko odpremo aktivnost za
izris podatkov in se izvajajo toliko časa, dokler se nahajamo v njej. Vse metode so kot del
programske kode predstavljene v primerih dodanih v nadaljevanju tega poglavja.
MainActivity.setUserId(-1);
updatePostId = -1;
navigateUpTo(new Intent(this, MainActivity.class));
finish();
return true;
}
if(id == R.id.objava) {
updatePostId = -1;
startActivity(new Intent(this, PublishActivity.class));
besedilo = "";
return true;
}
return super.onOptionsItemSelected(item);
}
48
Object [] ids;
ArrayAdapter<String> adapter;
public void izrisPodatkov() {
String[] besedila = new String[objave.size()];
ids = objave.keySet().toArray;
for(int i = 0; i < objave.size(); i++) {
String b = objave.get(ids[i]).besedilo;
Spanned besedilo = Html.fromHtml("<b>" +
objave.get(ids[i]).getUser_name() + "</b>" + b);
besedila[i] = besedilo.toString();
}
list = (ListView)findViewById(R.id.mainListView);
list.removeAllViewsInLayout();
adapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1,
android.R.id.text1, besedila);
for(int i = 0; i < list.getChildCount(); i++) {
ViewGroup.MarginLayoutParams mlp = (ViewGroup.MarginLayoutParams)
list.getChildAt(i).getLayoutParams();
mlp.setMargins(0, 20, 0, 20);
}
list.setAdapter(adapter);
list.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
49
String itemValue = (String)list.getItemAtPosition(position);
int postUserId = get PostUserId(Integer.parseInt(ids[position].toString()));
if(postUserId == MainActivityGetUserId()) {
updatePostId = Integer.parseInt(ids[position].toString());
besedilo = itemValue.substring(itemValue.indexOf(" ") +1);
startActivity(new Intent(App.context, PublishActivity.class);
}
}
};
Na zgornjemu primeru programske kode vidimo del kode metode izrisPodatkov(), ki skrbi, da
se vsi podatki, potrebni za izris, prikažejo na zaslonu, kot je potrebno. Najprej z id-jem
mainTable poiščemo tabelo, v katero izrišemo objave. Za tem se s for() zanko sprehodimo
preko vseh id-jev v HashMapu. Definiramo TableRow, mu dodamo lastnost, s katero lahko
kliknemo nanj in definiramo onClickListener(), s katerim poslušamo klike na vrstice v tabeli.
V metodi OnClick() pridobimo id uporabnika in besedilo, ki ga je objavil. Primerjamo tudi id
uporabnika, ki je obvestilo objavil in id uporabnika, ki je trenutno prijavljen v aplikaciji, da
mu lahko dovolimo spreminjati objavo. Shranimo id in besedilo objave, ki jo želimo
spremeniti ter zaženemo aktivnost imenovano PublishActivity. Aktivnost, imenovana
PublishActivity, predstavlja tretji zaslon mobilne aplikacije. Programska koda, ki jo
predstavlja, bo ravno tako kot koda prvih dveh aktivnosti dodana s primeri v nadaljevanju. V
aktivnosti PublishActivity spremenimo objavo, ki smo jo predhodno izbrali in s tem tudi
končamo trenutno aktivnost oziroma zapremo aktivnost imenovano BulletinBoard.
Definiramo tudi TextView(), mu pripišemo vrednost id-ja objave in nastavimo besedilo.
adapter.notifyDataSetChanged();
adapter.notifyDataSetInvalidated();
}
public static int getPostUserId(int id_objave) {
return objave.get(id_objave).getId_user();
50
}
Besedilo, ki smo ga predhodno shranili v spremenljivki TextView, dodamo v TableRow, nato
pa še v TableLayout. Za tem definiramo nekaj »get« in »set« metod, ki nam vrnejo potrebne
podatke za izvedbo aplikacije in ki so pridobljeni iz podatkovne zbirke. Metoda refresh(), ki
je v celoti predstavljena na naslednjemu primeru programske kode, se izvede takrat, ko želimo
osvežiti zaslon mobilne aplikacije oziroma, ko izbrišemo vrstico iz podatkovne zbirke in se
nam mora osvežiti zaslon mobilne aplikacije. Primer tega dela kode, ki je bil sedaj opisan,
sledi v nadaljevanju. Metoda makeToast() nam, kot je bilo že nekajkrat omenjeno, prikaže
besedilo v »pop up« okencih in v tej metodi obenem tudi definiramo, kako dolgo morajo biti
objave prikazane, da uporabnik ve, kaj je naredil prav in kaj narobe pri uporabi mobilne
aplikacije.
public static void setObvestila(LinkedHashMap<Integer, Post> obvestila) {
objave = obvestila;
}
public void MakeToast(String myResult) {
if(myResult != null) {
Toast toast = Toast.makeText(this, myResult, Toast.LENGTH_LONG);
Toast.show();
}
}
}
Pri tretjem oziroma zadnjemu primeru kode mobilne aplikacije je morda največ programske
kode, ki skrbi, da se mobilna aplikacija izvede, kot je potrebno. Na začetku datoteke, v kateri
je ta shranjena, smo izpisali paket, kamor smo shranili aplikacijo, definirali vse pakete
potrebne za izvedbo aktivnosti in definirali glavno aktivnost, ki se imenuje PublishActivity.
Pri definiciji glavne aktivnosti smo zapisali tudi, da razširja ActionBarActivity in ima
51
implementirani metodi OnClickListener ter MultiSpinnerListener, s katerima posluša
dogodke ob pritisku na gumb in izbiri skupin pri MultiSpinnerju. Pod naslovom aktivnosti,
tako kot v prejšnjih dveh, definiramo spremenljivke potrebne za delo z njo. Zatem definiramo
nekaj statičnih metod, saj jih potrebujemo tudi pri izvedbi drugih dveh aktivnosti. Metoda
Callback nam tako kot v prejšnjih dveh primerih preprečuje zmrzovanje med izvajanjem
druge niti. V metodi onCreate() definiramo različne spremenljivke, ki jih uporabimo samo
znotraj omenjene metode, toda z njimi kličemo tudi nekatere metode izven aktivnosti.
package com.example.bulletinboard;
import android.support.v7.app.ActionBarActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.Toast;
import java.util.ArrayList;
import java.util.HashMap;
import com.example.bulletinboard.DataBaseAccess.Callback;
import com.example.gui.MultiSpinner;
import com.example.gui.MultiSpinner.MultiSpinnerListener;
public class PublishActivity extends ActionBarActivity implements OnClickListener,
MultiSpinnerListener {
static String isChecked;
EditText text;
Button buttonPublish;
static CharSequence besedilo = "";
52
boolean update = false;
static HashMap<String, Integer> skupine;
static ArrayList<Integer> group_id;
static ArrayList<Boolean> post_in_groups = new ArrayList<>();
public static void setPost_in_groups(ArrayList<Boolean> in_groups) {
post_in_groups = in_groups;
}
public static ArrayList<Integer> getGroup_id() {
return group_id;
}
Callback cb = new Callback() {
@Override
public void onComplete(String myResult) {
Vse omenjene metode so predstavljene na primeru programske kode na naslednji strani, saj je
na tem mestu opisano vse, kar se dogaja s pomočjo programske kode, deli katere se vidijo na
primerih dodanih med besedilom. Kot že znano, programska koda, zapisana v programskemu
jeziku Java, skrbi, da se med izvajanjem mobilne aplikacije kaj zgodi, medtem ko XML koda
poskrbi le za prikaz podatkov na zaslonu pametnega mobilnega telefona. Slike zaslonov, ki so
dodane v začetku tega poglavja, so izrisane s pomočjo XML jezika oziroma kode zapisane v
njem. Aktivnost, imenovana PublishActivity, se izvede samo takrat, ko uporabnik želi zapisati
novo objavo ali shraniti že obstoječo objavo, ki jo je predhodno uredil. Aktivnost, ki je
zadolžena za prijavni oziroma registracijski zaslon, se izvaja le takrat, ko se uporabnik želi
prijaviti v aplikacijo oziroma registrirati v primeru, da njegovih podatkov še ni zapisanih v
podatkovni zbirki. Do omenjene aktivnosti se uporabnik vrne tudi takrat, ko se odjavi iz
mobilne aplikacije.
@Override
53
public void onComplete(String myResult) {
BulletinBoardActivity.setUpdate PostId(-1);
startActivity();
}
};
Callback c = new Callback() {
@Override
public void onComplete(String myResult) {
loadSpinner();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_vnos_podatkov);
buttonPublish = (Button)findViewById(R.id.buttonPublish);
buttonPublish.setOnClickListener(this);
DataBaseAccess access = new DataBaseAccess(c);
Access.execute("skupina");
besedilo = BulletinBoardActivity.getBesedilo();
if(!besedilo.equals("")) {
update = true;
EditText obvestilo = (EditText)findViewById(R.id.text);
obvestilo.setText(besedilo);
}
54
}
@Override
protected void onSaveInstanceState(outState) {
super.onSaveInstanceState(outState);
}
Naslednji primer programske kode predstavlja del kode, pri katerem se izvede onClick()
metoda, ki nam pomaga pri poslušanju dogodkov. Ti se zgodijo ob uporabnikovem pritisku na
gumbe v mobilni aplikaciji. Omenjena metoda se izvede le v času, ko se uporabnik mobilne
aplikacije dejansko odloči, da pritisne na gumb za shranitev nove objave na elektronsko
oglasno desko. Preden uporabnik dejansko objavi novo besedilo, aplikacija v ozadju preveri,
ali je polje z besedilom prazno ali izpolnjeno. V primeru, da je polje z besedilom prazno,
uporabnik želi dodati novo objavo. V primeru, da je polje z besedilom izpolnjeno, mora
uporabnik najprej urediti objavo in jo šele kasneje shraniti nazaj na elektronsko oglasno
desko. Obvestilo se kot besedilo shrani v podatkovno zbirko in s tem prikaže na drugem
zaslonu aplikacije, katerega kodo sem opisal že v prejšnjih odstavkih.
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
55
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
if(id = R.id.odjava) {
navigateUpTo(new Intent(this, MainActivity.class);
return true;
}
return super.onOptionsItemSelected(item);
}
// V metodi onClick() se izvede koda, ki se izvede po kliku na gumb.
@Override
public void onClick(View v) {
if(v.getId() == R.id.buttonPublish) {
EditText obvestilo = (EditText)findViewById(R.id.text);
besedilo = obvestilo.getText().toString();
// Primerjamo ali je besedilo objave prazno in izpišemo obvestilo, da
objava ne sme biti prazna.
if(besedilo.equals("") {
Toast toast = Toast.makeText(this, "Objava ne more biti
prazna!", Toast.LENGTH_LONG);
Toast.show();
}
else {
// Preverimo stanje CheckBox - a in ga shranimo v
spremenljivko imenovano isChecked.
56
CheckBox check = (CheckBox)findViewById(R.id.checkBox);
Primer programske kode, priložen zgoraj, nam prikazuje metodo onClick(), pri kateri
preverjamo, ali je uporabnik vnesel besedilo ali ne in ali je objava vidna na zaslonu po zapisu
v podatkovno zbirko. V »else« stavku, ki je v zgornjem zaslonskem posnetku zapisan le
delno, saj bo nadaljevanje programske kode sledilo takoj po opisu, preverjamo, ali je objava
prikazana na zaslonu pametnega mobilnega telefona oz. ni in definiramo novo nit, ki shrani
novo objavo ali le nadgradi oziroma prepiše staro objavo z malo bolj urejeno. Pri malo bolj
urejeni objavi je mišljeno, da uporabnik doda datum oziroma ga spremeni v primeru, da ga je
imela prvotna objava in ni več ažuren. Vsi primeri programske kode so priloženi diplomski
nalogi z namenom nadaljnje raziskave.
If(check.isChecked()) {
isChecked = "true";
}
else {
isChecked = "false";
}
// Definiramo novo nit DataBaseAccess in preverimo vrednost
spremenljivke update ter objavo shranimo v podatkovno zbirko v primeru, da je vrednost
spremenljivke update false.
// V primeru, da je vrednost spremenljivke update true se
spremenjena objava posodobi v podatkovni zbirki.
DataBaseAccess access = new DataBaseAccess(cb);
if(update == false) {
access.execute("shrani");
}
57
else {
access.execute("update");
}
}
}
}
private void loadSpinner() {
ArrayList<String> niz = new ArrayList<>();
for(String skupina : skupine.keySet()) {
niz.add(skupina);
}
MultiSpinner multiSpinner = (MultiSpinner)findViewById(R.id.multiSpinner);
multiSpinner.setItem(niz, getString(R.string.for_all), this, post_in_groups);
group_id = new ArrayList<>();
Object[] ids = skupine.values().toArray();
for(int i= 0; i < ids.length; i++) {
group_id.add(Integer.parseInt(ids[i] + ""));
}
}
Metoda loadSpinner() nam omogoča, da na zaslonu prikažemo izbor skupin in njihova imena.
MultiSpinner je v temu primeru narejen zaradi izbire več različnih možnosti, ki jih ima
uporabnik na voljo. Uporabnikova izbira se vidi v tem, da je objava lahko vidna v njegovi
skupini ali ni vidna v primeru, da se tako odloči pri objavljanju. Enako se zgodi tudi v
primeru, da se uporabnik odloči urediti objavo in pri tem izbere, da objava ni vidna v vseh
58
treh skupinah. Tri skupine uporabnikov so mišljene kot študenti, profesorji in referat, ki
pripadajo določeni fakulteti. Zadnji primer programske kode, ki je dodan v nadaljevanju,
vsebuje še preostanek kode zapisan za aktivnost imenovano PublishActivity, dodan pa bo za
sledečim opisom. Metoda onItemsSelected() preveri ali se id-ji skupin ujemajo z velikostjo
polja skupine in nam ne vrne rezultata, ker je podatkovnega tipa »void«. Metoda setSkupine(),
ki je zapisana pod njo, nam ravno tako ne vrača rezultata zaradi podatkovnega tipa »void«. V
omenjeni metodi nastavimo skupine in jih uporabimo v metodi, ki smo jo zapisali v drugemu
delu kode in jo tam tudi uporabimo.
// Get in Set metode nam vrnejo rezultate potrebne za delo z njimi.
public static CharSequence getText() {
return besedilo;
}
public void startActivity() {
navigateUpTo(new Intent(this, BulletinBoardActivity.class));
}
public static String getIsChecked() {
return isChecked;
}
@Override
public void onItemsSelected(boolean[] selected) {
group_id = new ArrayList<>();
Object[] ids = skupine.values().toArray();
for(int i = 0; i < selected.length; i++) {
if(selected[i]) {
59
group_id.add(Integer.parseInt(ids[i] + ""));
}
}
}
public static void setSkupine(HashMap<String, Integer> groups) {
skupine = groups;
}
}
Vsi primeri programske kode dodani v besedilu so opisani in razloženi, kar pomeni, da je
pred in za vsako zapisan opis tega, kar predstavlja. Opis pomeni, da je vsak del kode,
predstavljen na primerih opisan razumljivo za katerega koli uporabnika.
3.6 Vrednotenje razvite programske rešitve
V tem poglavju bom predstavil vrednotenje programske rešitve oziroma mobilne aplikacije.
Mobilna aplikacija ima dobre strani, kot je na primer pomoč uporabniku pri prijavi ali
registraciji vanjo, prebiranju podatkov iz podatkovne zbirke, dodajanju nove objave v
podatkovno zbirko preko mobilne aplikacije in odjavo iz nje. V primeru, da bi mobilno
aplikacijo želeli uporabiti na kateri izmed fakultet, bi jo moral najprej optimizirati za
delovanje na mobilnem telefonu in testirati delovanje in uporabnost pri skupini uporabnikov.
Aplikacija, nastala v času raziskave, je preizkušena samo na emulatorju pametnega mobilnega
telefona in ne na pravem mobilnem telefonu.
Pomoč uporabniku pri prijavi oziroma registraciji je mišljena, da uporabnik zapiše
uporabniško ime in geslo v polji predvideni za to. Pri prijavi uporabnika se aplikacija
premakne na zaslon s prikazanimi objavami. Pri registraciji uporabnika se mu v ozadju dodeli
skupina študent in zatem se aplikacija, tako kot pri prijavi, premakne na drugi zaslon.
Prebiranje podatkov iz podatkovne zbirke pomeni, da uporabniki vidijo le tiste podatke, ki so
jim namenjeni. Pri teh je mišljeno, da uporabniki vidijo le vse tiste podatke, ki so namenjeni
skupini, v kateri so se registrirali na začetku oziroma skupini, v kateri so po tem, ko so prišli v
stik z administratorjem za podatkovno zbirko. Ta jih vanjo uvrsti glede na željo uporabnika.
60
Dodajanje nove objave v podatkovno zbirko pomeni, da uporabnik pride na tretji zaslon
aplikacije, če najprej klikne gumb imenovan »objava obvestila«, ki je, kot je že omenjeno,
skrit v meniju. Na zaslonu za dodajanje nove objave uporabnik v polje pod naslovno vrstico
vpiše svoje besedilo, nato izbere, v kateri skupini bo prikazano in ali je objava prikazana ali
ne. Možnost za prikazano objavo je nad gumbom »shrani obvestilo«. Gumb »shrani
obvestilo« uporabnika znova vrne na drugi zaslon in obenem prikaže njegovo objavo kot
prvo. Prikaz objav je urejen tako, da uporabniku prikaže najprej prvo objavo oziroma tisto, ki
je bila vpisana na elektronsko oglasno desko kot zadnja in prvo objavo kot zadnjo. Odjava iz
aplikacije poteka tako, da mora uporabnik izbrati možnost »odjava«, ki ga vrne na prvi
oziroma prijavni zaslon aplikacije. Prijava oziroma registracija v mobilno aplikacijo je
podrobneje opisana v prejšnjemu poglavju.
Dobra stran mobilne aplikacije je tudi ta, da se izvaja na dveh nitih oziroma dveh različnih
procesih. To pomeni, da je obremenitev strojne opreme pametnega mobilnega telefona
manjša, kot bi bila v primeru, če bi se aplikacija oziroma njeni procesi izvajali na eni oziroma
glavni niti. Mobilna aplikacija, ki je nastala v primeru pričujoče raziskave se izvaja na glavni
niti in asinhroni, s katero pridobimo samo povezavo s podatkovno zbirko in jo ohranjamo,
dokler se aplikacija ne preneha izvajati oziroma dokler je uporabnik pametnega mobilnega
telefona ne zaustavi. Glavna nit skrbi večinoma za to, da se izrišejo vsi zasloni in prikažejo
vsi podatki, ki jih je določen uporabnik zahteval iz podatkovne zbirke s poizvedbami.
Mobilna aplikacija nima veliko slabih strani, ki bi vplivale na njeno izvedbo. Slaba stran
mobilne aplikacije je morda edino ta, da se celotna aktivnost namenjena izrisu podatkov na
zaslonu mobilne aplikacije zapre in ponovno odpre ter izriše osveženo tabelo na zaslon.
Osveževanje tabele je v mobilni aplikaciji rešeno na ta način, da se določene objave izbrišejo
iz podatkovne zbirke, s tem pa se mora tudi osvežiti prikaz podatkov na zaslonu mobilne
aplikacije. Izvedba aplikacije se tako malce upočasni. Izvedba mobilne aplikacije ne potrebuje
veliko prostora na pametnem mobilnem telefonu, ker zbira podatke iz oddaljenega strežnika,
kjer je nameščena podatkovna zbirka in s tem uporablja le prostor na strežniku. Oddaljen
strežnik je v primeru raziskave prenosnik, na katerem je nameščena MySQL podatkovna
zbirka. Ta ima shranjene vse potrebne podatke in jih prikaže določenemu uporabniku le, če ta
pravilno zapiše poizvedbo, kar pomeni, da mora uporabnik zapisati v MySQL Workbench,
katere podatke želi pridobiti iz podatkovne zbirke.
Analiza dobrih in slabih strani mobilne aplikacije je pokazala, da ima mobilna aplikacija, ki je
nastala kot del pričujoče raziskave, več dobrih strani za uporabnike in eno slabo. Dobre strani
mobilne aplikacije za uporabnike pomenijo, da bodo z aplikacijo zadovoljni. Slabo stran
61
aplikacije predstavlja njena omejena funkcionalnost. Pred uporabo aplikacije v praksi bi bilo
potrebno nabor njenih funkcionalnosti razširiti z ostalimi funkcionalnostmi spletnega referata
in jo preizkusiti s skupino testnih uporabnikov.
4. ZAKLJUČEK
V diplomski nalogi je predstavljena mobilna aplikacija, JDBC povezava in MySQL
podatkovna zbirka, ki predstavljajo moje avtorsko delo. Posamezni deli kode, ki so
uporabljeni za mobilno aplikacijo, izhajajo iz spleta in so bili naknadno prilagojeni. Beseda
»sprogramiral« pomeni, da je mobilna aplikacija sestavljena iz več datotek, v katerih je
spravljena programska koda. JDBC povezava je nastavljena tako, da uporabnik lahko vpisuje
podatke v podatkovno zbirko, v kateri so shranjene vse objave, ki so jih vanjo vnesli
uporabniki mobilne aplikacije. Besedilo je zapisano tako, da bi ga vsak, ki želi ponoviti
raziskavo, lahko razumel in brez težav izvedel razvoj aplikacije s podobnim rezultatom.
Literature o vsakem orodju, ki sem ga uporabil, je ogromno in jo je iz tega razloga težko
obdelati v celoti.
Pri raziskavi sem uporabil orodja, kot so razvojno okolje Eclipse, Android SDK in MySQL
Workbench, s katerim sem nadziral podatkovno zbirko ter jo urejal, preden sem naredil
dostop do nje preko mobilne aplikacije. Opisana mobilna aplikacija uporablja tehnologijo
imenovano JDBC za dostop do podatkovne zbirke. JDBC pomeni Java Data Base
Connectivity Technology in z njeno pomočjo lahko dostopamo do podatkovnih zbirk iz
platforme, ki temelji na programskem jeziku Java in do podatkovne zbirke, ki temelji na
proceduralnem jeziku SQL oziroma v mojem primeru MySQL. Podatkovna zbirka, temelječa
na jeziku MySQL, je nastala med izvedbo mobilne aplikacije in bo ravno tako kot mobilna
aplikacija dodana v prilogi. Kot priloga diplomski nalogi je mišljeno, da bodo priložene
programska koda mobilne aplikacije in v njej poizvedbe, ki so potrebne, da nam mobilna
aplikacija prikaže vse podatke, ki jih uporabnik pričakuje, da jih bo dobil iz podatkovne
zbirke.
Mobilno aplikacijo, ki je nastala z raziskavo, je mogoče izboljšati na način, da dodamo vsaj
eno funkcionalnost, ki je vsebovana v spletnem referatu fakultete. Da bi mobilna aplikacija
62
podpirala vse možnosti spletnega referata, bi jo bilo potrebno preurediti in sprogramirati več
funkcionalnosti, s katerimi bi bila bolj uporabna za vse uporabnike.
63
5. LITERATURA IN VIRI
1. A developer's first look at android (2008) Overview Developers, Januar 2008, str. 48−50.
2. ABLESON, FRANK, COLLINS, CHARLIE in SEN, ROBI (2009) Unlocking Android: a
developer`s guide. Greenwich: Manning.
3. BALAŽIC, MITJA (2011) Izdelava aplikacije Študentska borza na mobilni platformi
Android. Diplomsko delo. Ljubljana: Univerza v Ljubljani, Fakulteta za računalništvo in
informatiko.
4. DIMARZIO, JEROME (J. F.) (2008) Android: A programmer's guide. New York idr:
McGrawHill. Dostopno prek: http://www.BookFi.org (12. 12. 2015).
5. DOKUMENTACIJA SISTEMA MYSQL. MySQL Documentation. Dostopno prek:
http://dev.mysql.com/doc/ (12. 12. 2015).
6. DUBOIS, PAUL (2002) MySQL Cookbook. Sebastopol: O'Reilly.
7. ECKEL, BRUCE (2006) Thinking in Java. New York idr: President, Mindview Inc.
8. FABJAN, BORUT in MESOJEDEC, UROŠ (2004) Java 2: temelji programiranja.
Ljubljana: Pasadena.
9. FINŽGAR, LUKA (2010) Implementacija elektronske vozovnice na mobilnem telefonu.
Diplomsko delo. Ljubljana: Univerza v Ljubljani, Fakulteta za računalništvo in
informatiko.
10. JAVAPAPERS. Using database from Android app. Dostopno prek: http://javapapers.com/
Android/using-database-from-an-Android-application/ (12. 12. 2015).
11. KRAŠOVEC, MATJAŽ (2014) Mobilna aplikacija za hranjenje in prikaz lokacijskih
podatkov. Diplomsko delo. Ljubljana: Univerza v Ljubljani, Fakulteta za računalništvo in
informatiko.
12. KRIVEC, IGOR (2013) Mobilna aplikacija za upravljanje naprav in nadzor njihove
porabe. Diplomsko delo. Ljubljana: Univerza v Ljubljani, Fakulteta za računalništvo in
informatiko.
13. MELTON, JIM in EISENBERG, ANDREW (2000) Understanding SQL and Java
Together A Guide to SQLJ, JDBC and Related Technologies. San Francisco: Academic
Press United States of America.
65
14. MEŽNAR, SAŠO (2012) Razvoj mobilne aplikacije na platformi Android Tutorial –
Connect Android app to MySQL database. Diplomsko delo. Ljubljana: Univerza v
Ljubljani, Fakulteta za računalništvo in informatiko. Dostopno prek:
http://www.basic4ppc.com/Android/forum/threads/connect-Android-to-mysql-database-
tutorial.8339/ (12. 12. 2015).
15. ORACLE. JDBC Overview. Dostopno prek: http://www.oracle.com/technetwork/java/
overview-141217.html (12. 12. 2015).
16. ORACLE. Lesson JDBC basics. Dostopno prek: http://docs.oracle.com/javase/tutorial/
jdbc/basics/ (12. 12. 2015).
17. POTEŽICA, NEBOJŠA SAŠA (2009) Razvoj aplikacij za pametne mobilne telefone.
Diplomsko delo. Ljubljana: Univerza v Ljubljani, Fakulteta za računalništvo in
informatiko.
18. RAZVOJ APLIKACIJ ZA SISTEM ANDROID. Site for developing Android apps.
Dostopno prek: http://developer.Android.com/index.html (12. 12. 2015).
19. SIMČIČ, MATEJ (2012) Avtomatizacija naročil v taksi službi. Diplomsko delo.
Ljubljana: Univerza v Ljubljani, Fakulteta za računalništvo in informatiko.
20. STACK OVERFLOW. How to connect to MySQL database from Android app.
Dostopno prek: https://www.google.com/search?btnG=1&pws=0&q=
how+to+connect+to+a+database+with+Android&gws_rd=ssl (12. 12. 2015).
21. WIKIPEDIA. Android software development. Dostopno prek:
http://en.wikipedia.org/wiki/Android_software_development (12. 12. 2015).
22. WIKIPEDIA. App inventor for Android. Dostopno prek:
http://en.wikipedia.org/wiki/App_Inventor_for_Android (12. 12. 2015a).
23. WIKIPEDIA. HyperNext. Dostopno prek: http://en.wikipedia.org/wiki/HyperNext (12. 12.
2015b).
24. ZIGURD, MEDNIEKS, LAIRD, DORNIN in G. BLAKE, MEIKE in MASUMI,
NAKAMURA (2011) Programming Android. Sebastopol: O'Reilly.
25. ZIMIC, MATEJ (2012) Medplatformski razvoj mobilnih aplikacij. Diplomsko delo.
Ljubljana: Univerza v Ljubljani, Fakulteta za računalništvo in informatiko.
Priloga 1: Programska koda
Vsebina datoteke MainActivity.java:
package com.example.bulletinboard;
// Paketi potrebni za izvedbo naše aplikacije se uvozijo tukaj in se uporabljajo pri izvedbi
aplikacije.
import android.content.Intent; // Paket intent je uporabljen za prehod med dvema aktivnostima
v aplikaciji.
import android.os.Bundle; // implementacija paketa Bundle je potrebna za samo izvedbo
aplikacije.
import android.support.v7.app.ActionBarActivity; // Paket ActionBarActivity potrebujemo za
implementacijo ActionBar, ki je prikazana na vrhu zaslona aplikacije.
import android.util.Log; // Paket Log je uporabljen v metodi onCreate(), ki se izvede ob
zagonu aplikacije in nam prikaže napake v logcatu.
import android.view.Menu; // Paket Menu je uporabljen za prikaz menija v uporabniškemu
vmesniku aplikacije.
import android.view.MenuItem; // Paket MenuItem je uporabljen za action bar, ki spremlja
klike na gumb Home / Up dokler imamo definirano katero koli aktivnost.
import android.view.View; // Paket View se uporablja za prikaz pogleda v uporabniškemu
vmesniku.
import android.view.View.OnClickListener; // Paket OnClicklistener je namenjen poslušanju
klikov na gumba buttonAuth in registrationButton.
import android.widget.Button; // Paket Button je namenjen prikazu gumbov na
uporabniškemu vmesniku aplikacije.
import android.widget.EditText; // Paket EditText uporabljamo za prikaz besedila shranjenega
v EditText - u oziroma vnesenega preko uporabniškega vmesnika aplikacije.
import android.widget.Toast; // Paket Toast uporabljamo za prikaz besedila v popUp okencu,
ki mu moramo tudi določiti dolžino prikaza na zaslonu.
import java.sql.Connection; // Paket Connection uporabljamo za primer vzpostavljanja
povezave med aplikacijo in podatkovno zbirko.
import java.sql.ResultSet; // Paket ResultSet je namenjen prikazu rezultata iz podatkovne
zbirke na zaslonu aplikacije.
import com.example.bulletinboard.DataBaseAccess.Callback; // Paket Callback je namenjen
temu, da se aplikacija med izvajanjem ne zaustavi popolnoma. Pri tem je mišljeno
zaustavljanje uporabniškega vmesnika.
// definicija glavne aktivnosti.
public class MainActivity extends ActionBarActivity implements OnClickListener {
// Tukaj definiramo spremenljivke, ki jih potrebujemo za izvedbo kode začetnega dela
aplikacije.
Connection con; // Spremenljivka potrebna za povezavo do podatkovne zbirke.
Button buttonAuth; // Definicija gumba, ki ga uporabimo za prijavo v aplikacijo.
Button registrationButton; // Definicija gumba, ki ga uporabimo za registracijo v
aplikacijo.
EditText username; // Definicija EditText - a, ki je uporabljen za vnos uporabniškega
imena uporabnika.
EditText password; // Definicija EditText - a, ki je uporabljen za vnos uporabnikovega
gesla.
static int id_uporabnika = -1; // Id uporabnika se uporablja za priredbo vrednosti, ki jo
zapišemo v podatkovno zbirko poleg besedila namenjenega za to.
static int id_group = -1;
static String uporabnisko_ime = ""; // Niz imenovan uporabnisko_ime se uporablja za
prebiranje uporabnikovega vnosa uporabniškega imena v uporabniškemu vmesniku in
kasnejši obdelavi v podatkovni zbirki.
static String uporabnisko_geslo = ""; // Niz imenovan uporabnisko_geslo se uporablja
za prebiranje uporabnikovega vnosa gesla v uporabniškemu vmesniku in kasnejši obdelavi v
podatkovni zbirki.
ResultSet rs; // ResultSet se uporablja za prikaz rezultatov poizvedb izvedenih na
podatkih v podatkovni zbirki.
static int rowcount;
// Callback metoda se uporablja za izris uporabniškega vmesnika po končanih
opravilih v DataBaseAccess niti in omogoča, da nam ne zmrzne med izvajanjem aplikacije,
// ko čakamo, da se druga nit izvede do konca.
Callback cb = new Callback() {
@Override
public void onComplete(String myResult) {
makeToast(myResult);
startActivity();
}
};
// Metoda MainActivity.onCreate se izvede ob zagonu aplikacije in nam omogoči
prijavo ali registracijo v aplikacijo.
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.i("MainActivity", "onCreate");
buttonAuth = (Button)findViewById(R.id.buttonAuth);
buttonAuth.setOnClickListener(this);
registrationButton = (Button)findViewById(R.id.registrationButton);
registrationButton.setOnClickListener(this);
}
// Metoda onSaveInstanceState se izvede ob prekinitvi izvajanja aplikacije in
ponovnemu zagonu.
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
return super.onOptionsItemSelected(item);
}
// Metoda onClick nam izvede določen del kode potem, ko pritisnemo na gumb za
prijavo v aplikacijo ali gumb za registracijo v aplikacijo (oba gumba se nahajata na
uporabniškemu vmesniku).
@Override
public void onClick(View v) {
// Izvede se ob kliku na gumb za prijavo.
if(v.getId() == R.id.buttonAuth) {
// Preberemo uporabnikov vnos preko uporabniškega vmesnika
EditText username = (EditText)findViewById(R.id.user_name);
EditText password = (EditText)findViewById(R.id.pass_word);
uporabnisko_ime = username.getText().toString();
uporabnisko_geslo = password.getText().toString();
// Preverimo ali je uporabniško ime ali geslo prazno.
if(uporabnisko_ime.equals("") || uporabnisko_geslo.equals("")) {
Toast toast = Toast.makeText(this, "Uporabniško ime ali geslo
ne sme biti prazno!", Toast.LENGTH_LONG);
toast.show();
}
// Če uporabnikov vnos ni prazen se ustvari nova nit za dostop do
podatkovne zbirke in preverimo ali so podatki pravilno vneseni.
else {
DataBaseAccess access = new DataBaseAccess(cb);
access.execute("prijava");
}
}
// Izvede se ob kliku na gumb za registracijo uporabnika.
if(v.getId() == R.id.registrationButton) {
// Preberemo uporabnikov vnos preko uporabniškega vmesnika.
EditText username = (EditText)findViewById(R.id.user_name);
EditText password = (EditText)findViewById(R.id.pass_word);
uporabnisko_ime = username.getText().toString();
uporabnisko_geslo = password.getText().toString();
// Preverimo ali je uporabniško ime ali geslo prazno.
if(uporabnisko_ime.equals("") || uporabnisko_geslo.equals("")) {
Toast toast = Toast.makeText(this, "Uporabniško ime ali geslo
ne sme biti prazno!", Toast.LENGTH_LONG);
toast.show();
}
// Če nista prazna se ustvari nova nit, dostopa do podatkovne zbirke in
doda novega uporabnika v podatkovno zbirko.
else {
DataBaseAccess access = new DataBaseAccess(cb);
access.execute("registracija");
}
}
}
// Metoda makeToast nam prikaže besedilo v popUp okencih.
public void makeToast(String myResult) {
if(myResult != null) {
Toast toast = Toast.makeText(this, myResult, Toast.LENGTH_LONG);
toast.show();
}
}
// Metoda startActivity nam požene naslednjo aktivnost na katero preidemo po končani
izvedbi trenutne aktivnosti.
public void startActivity() {
if (id_uporabnika != -1) {
startActivity(new Intent(this, BulletinBoardActivity.class));
}
}
// get and set metode nam pridobijo podatke potrebne za izvedbo določenih metod, ki
se nahajajo v trenutni in jih kličemo iz preostalih aktivnosti.
public static int getUserId() {
return id_uporabnika;
}
public static void setUserId(int id) {
id_uporabnika = id;
}
public static void setUserGroupId(int group) {
id_group = group;
}
public static int getId_group() {
return id_group;
}
public static String getUser() {
return uporabnisko_ime;
}
public static String getPassword() {
return uporabnisko_geslo;
}
public static int getRowcount() {
return rowcount;
}
public static void setRowcount(int count) {
rowcount = count;
}
}
Vsebina datoteke BulletinboardActivity:
package com.example.bulletinboard;
// Tukaj uvozimo vse potrebne pakete, ki jih uporabljamo v trenutni aktivnosti.
import java.util.LinkedHashMap; // Paket LinkedHashMap se uporablja pri pridobivanju
tabele iz podatkovne zbirke.
import com.example.bulletinboard.DataBaseAccess.Callback; // Paket Callback je namenjen
temu, da se aplikacija med izvajanjem ne zaustavi popolnoma. Pri tem je mišljeno
zaustavljanje uporabniškega vmesnika.
import android.support.v7.app.ActionBarActivity; // Paket ActionBarActivity potrebujemo za
implementacijo ActionBar, ki je prikazana na vrhu zaslona aplikacije.
import android.text.Html; // Paket Html se uporablja v času prikaza objav na zaslonu mobilne
aplikacije.
import android.text.Spanned; // Paket Spanned se uporablja za prikaz besedila na zaslonu
mobilne aplikacije.
import android.content.Intent; // Paket Intent je namenjen poganjanju nove aktivnosti, ki jo
napovemo s class definicijo.
import android.os.Bundle; // implementacija paketa Bundle je potrebna za samo izvedbo
aplikacije.
import android.view.Menu; // Paket Menu je uporabljen za prikaz menija v uporabniškemu
vmesniku aplikacije.
import android.view.MenuItem; // Paket MenuItem je uporabljen za action bar, ki spremlja
klike na gumb Home / Up dokler imamo definirano katero koli aktivnost.
import android.view.View; // Paket View se uporablja za prikaz pogleda v uporabniškemu
vmesniku.
import android.view.ViewGroup; // Paket ViewGroup je uporaben pri nadzoru pogledov
oziroma videza zaslona mobilne aplikacije.
import android.widget.AdapterView; // Paket AdapterView je uporabljen zaradi pridobivanja
podatkov iz ListViewa.
import android.widget.AdapterView.OnItemClickListener; // Paket OnItemClickListener se
obnaša podobno kot onClickListener s to razliko, da tukaj poslušamo klike na item in ne na
vrstico.
import android.widget.ArrayAdapter; // Paket ArrayAdapter uporabimo za pridobivanje
podatkov iz ListViewa.
import android.widget.ListView; // Paket ListView je uporabljen namesto paketa
TableLayout, ker osveževanje zaslona mobilnega telefona tam ne deluje kot bi moralo.
import android.widget.Toast; // Paket Toast potrebujemo za prikaz pop up okenc na zaslonu
mobilne aplikacije.
// definicija aktivnosti imenovane BulletinBoard.
public class BulletinBoardActivity extends ActionBarActivity {
static LinkedHashMap<Integer, Post> objave; // Spremenljivka objave nam pomaga
pri prikazu objav na zaslon.
static CharSequence besedilo = ""; // besedilo je objava, ki jo ob kliku nanjo
spreminjamo preko uporabniškega vmesnika aplikacije.
static int updatePostId = -1; // Spremenljivka updatePostId se uporablja za prireditev
vrednosti id, ki jo kasneje povozimo s id besedila iz podatkovne zbirke.
protected static final int REFRESH = 0;
ListView list;
public static void setUpdatePostId(int updatePostId) {
BulletinBoardActivity.updatePostId = updatePostId;
}
// Metodi getUpdatePostId in getBesedilo nam vrneta id objave in besedilo, ki ga
pridobimo iz podatkovne zbirke.
public static int getUpdatePostId() {
return updatePostId;
}
public static CharSequence getBesedilo() {
return besedilo;
}
// Metoda Callback nam pomaga pri preprečevanju zmrzovanja izvajanja
uporabniškega vmesnika medtem, ko čakamo na izvedbo druge niti.
// V temu primeru se po izvajanju niti naredi izris podatkov na zaslon.
Callback cb = new Callback() {
@Override
public void onComplete(String myResult) {
izrisPodatkov();
}
};
Callback c = new Callback() {
@Override
public void onComplete(String myResult) {
if(!myResult.equals("false")) {
DataBaseAccess a = new DataBaseAccess(cb);
a.execute("objave");
}
DataBaseAccess a = new DataBaseAccess(c);
a.execute("osvezi");
}
};
// Metoda BulletinBoard.onCreate se izvede ob zagonu aktivnosti in zažene nit za
pridobivanje objav iz podatkovne zbirke.
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_bulletin_board);
DataBaseAccess access = new DataBaseAccess(cb);
access.execute("objave");
DataBaseAccess a = new DataBaseAccess(c);
a.execute("osvezi");
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.bulletin_board, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
if (id == R.id.odjava) {
MainActivity.setUserId(-1);
updatePostId = -1;
navigateUpTo(new Intent(this, MainActivity.class));
finish();
return true;
}
if (id == R.id.objava) {
updatePostId = -1;
startActivity(new Intent(this, PublishActivity.class));
besedilo = "";
return true;
}
return super.onOptionsItemSelected(item);
}
Object[] ids;
ArrayAdapter<String> adapter;
// Metoda izrisPodatkov nam izriše vse podatke pridobljene iz podatkovne zbirke na
zaslon oziroma v uporabniški vmesnik.
public void izrisPodatkov() {
// { "Kaj je novega tukaj", "Kako priti do polne tabele nizov", "Kje najti
besedilo za tabelo nizov", "Kako napolniti tabelo nizov z besedilom najdenim na spletu",
"Kako besedilo zapisano v tej tabeli izpisem na zaslon", "Kako dobiti uporabno besedilo, da
ga prikazem tukaj in izpisem na zaslon", "Koliko znakov mora besedilo vsebovati, da je daljse
kot obsega zaslon mobilnega telefona", "Kako zapisati novo besedilo na kolikor je mogoce
dolgo", "Zakaj nikakor ne morem dostopati do podatkovne zbirke", "Kako urediti dostop do
podatkovne zbirke, da deluje kot je potrebno", "Kje se nahajajo napake, ki jih moram
odpraviti, da bo podatkovna zbirka dostopna", "Kje dobiti uporabno besedilo za prikaz na
zaslonu pametnega mobilnika in ga tudi dejansko prikazati na njem", "Kaj je narobe, da moja
podatkovna zbirka ne more biti dostopna drugim uporabnikom", "Kako odpraviti vse napake,
da bo mobilna aplikacija delovala kot potrebujem in da bo uporabna za uporabnika kateremu
je namenjena", "Uporabnik mobilne aplikacije ne bo vesel, ce mobilna aplikacija ne bo
delovala kot zeli" };
String[] besedila = new String[objave.size()];
ids = objave.keySet().toArray();
for(int i =0; i < objave.size(); i++){
String b = objave.get(ids[i]).besedilo;
Spanned besedilo = Html.fromHtml("<b>" +
objave.get(ids[i]).getUser_name() + "</b> " + b);
besedila[i] = besedilo.toString();
}
list = (ListView)findViewById(R.id.mainListView);
list.removeAllViewsInLayout();
adapter = new ArrayAdapter<String>(this,
android.R.layout.simple_list_item_1, android.R.id.text1, besedila);
for(int i = 0; i < list.getChildCount(); i++){
ViewGroup.MarginLayoutParams mlp =
(ViewGroup.MarginLayoutParams) list.getChildAt(i).getLayoutParams();
mlp.setMargins(0, 20, 0, 20);
}
list.setAdapter(adapter);
// Tukaj nastavimo onClickListener za vrstico na katero kliknemo oziroma jo
uporabnik izbere ter uredi.
list.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView<?> parent, View view, int position,
long id) {
String itemValue = (String) list.getItemAtPosition(position);
int postUserId =
getPostUserId(Integer.parseInt(ids[position].toString()));
// Primerjamo id uporabnika, ki je obvestilo objavil in id uporabnika, ki
je trenutno prijavljen v aplikacijo.
if(postUserId == MainActivity.getUserId()) {
// Shranimo id in besedilo objave, ki jo želimo spremeniti in
zaženemo aktivnost imenovano PublishActivity v kateri spremenimo objavo in jo shranimo
ter končamo trenutno aktivnost.
updatePostId =Integer.parseInt(ids[position].toString());
besedilo =itemValue.substring(itemValue.indexOf(" ") + 1);
startActivity(new Intent(App.context, PublishActivity.class));
}
}
});
adapter.notifyDataSetChanged();
adapter.notifyDataSetInvalidated();
}
// Get in set metode nam vrnejo podatke, ki jih potrebujemo za izvedbo aplikacije in
pridobimo jih iz podatkovne zbirke.
public static int getPostUserId(int id_objave) {
return objave.get(id_objave).getId_user();
}
public static void setObvestila(LinkedHashMap<Integer, Post> obvestila) {
objave = obvestila;
}
public void makeToast(String myResult) {
if(myResult != null) {
Toast toast = Toast.makeText(this, myResult, Toast.LENGTH_LONG);
toast.show();
}
}
}
Vsebina datoteke PublishActivity:
package com.example.bulletinboard;
// Uvoz vseh paketov potrebnih za izvedbo aktivnosti.
import android.support.v7.app.ActionBarActivity; // Paket ActionBarActivity je potreben
zaradi action bar, ki ga imamo v aplikaciji.
import android.content.Intent; // Paket Intent je uporabljen za začetek nove aktivnosti pred
čemer zapremo trenutno.
import android.os.Bundle; // Paket Bundle je potreben pri izvedbi metod OnCreate in ostalih,
ki jih imamo v aktivnosti.
import android.view.Menu; // Paket Menu uporabimo pri prikazu menijev, ki jih uporabljamo
in prikazujemo na uporabniškemu vmesniku aplikacije.
import android.view.MenuItem; // Paket MenuItem se uporablja za prikaz izbranega elementa
v vrstici z menijem.
import android.view.View; // Paket View se uporablja za prikaz pogleda oziroma
uporabniškega vmesnika.
import android.view.View.OnClickListener; // Paket OnClickListener se uporablja za
poslušanje aktivnosti, ki se dogaja v času uporabnikovega pritiska na gumb.
import android.widget.Button; // Paket Button se uporablja za prikaz gumba na uporabniškem
vmesniku in poslušanje dogajanja preko OnClickListener() metode.
import android.widget.CheckBox; // Paket CheckBox se uporablja za prikaz CheckBoxa
oziroma potrditvenega gumba na uporabniškemu vmesniku aplikacije.
import android.widget.EditText; // Paket EditText je uporabljen pri prikazu polja za urejanje
besedila.
import android.widget.Toast; // Paket Toast se uporablja za prikaz besedila v popUp oknu.
import java.util.ArrayList; // Paket ArrayList je namenjen shranjevanju polj in dodajanju
novih podatkov vanje.
import java.util.HashMap; // Paket HashMap je uporabljen za prikaz skupin.
import com.example.bulletinboard.DataBaseAccess.Callback; // Paket Callback se uporablja
za ustavitev zmrzovanja uporabniškega vmesnika med izvajanjem druge niti.
import com.example.gui.MultiSpinner; // Paket MultiSpinner je namenjen prikazu skupin, ki
jih potrebujemo za objavo nove objave in pri spreminjanju objave, da vemo kdo jo vidi in kdo
ne.
import com.example.gui.MultiSpinner.MultiSpinnerListener; // Paket MultiSpinnerListener je
uporaben in deluje podobno kot paket OnClickListener.
// Definicija glavnega dela aktivnosti.
public class PublishActivity extends ActionBarActivity implements OnClickListener,
MultiSpinnerListener {
// Tukaj so definirane vse spremenljivke potrebne za izvedbo aktivnosti.
static String isChecked; // Spremenljivka isChecked je definirana zaradi metode
getIsChecked().
EditText text; // Spremenljivka text je definirana zaradi metode getText(), ki nam vrne
besedilo izpisano na uporabniški vmesnik aplikacije.
Button buttonPublish; // Spremenljivka buttonPublish je namenjena gumbu objavi
besedilo.
static CharSequence besedilo = ""; // Spremenljivka besedilo se ukvarja z besedilom,
ki ga pridobimo z uporabniškega vmesnika aplikacije.
boolean update = false; // Spremenljivka update skrbi za spremembo besedila
zapisanega v podatkovno zbirko.
static HashMap<String, Integer> skupine;
static ArrayList<Integer> group_id;
static ArrayList<Boolean> post_in_groups = new ArrayList<>();
public static void setPost_in_groups(ArrayList<Boolean> in_groups) {
post_in_groups = in_groups;
}
public static ArrayList<Integer> getGroup_id() {
return group_id;
}
Callback cb = new Callback() {
@Override
public void onComplete(String myResult) {
BulletinBoardActivity.setUpdatePostId(-1);
startActivity();
}
};
Callback c = new Callback() {
@Override
public void onComplete(String myResult) {
loadSpinner();
}
};
// Izrišemo uporabniški vmesnik.
// Poiščemo gumb ButtonPublish preko id - ja buttonPublish in mu nastavimo
onClickListener, ki posluša klike na gumb buttonPublish.
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_vnos_podatkov);
buttonPublish = (Button)findViewById(R.id.buttonPublish);
buttonPublish.setOnClickListener(this);
DataBaseAccess access = new DataBaseAccess(c);
access.execute("skupina");
// Pridobimo vrednost spremenljivke besedilo iz BulletinBoardActivity
aktivnosti.
// Če ni prazno to pomeni, da ga želimo urediti in ne dodati novega besedila.
besedilo = BulletinBoardActivity.getBesedilo();
if(!besedilo.equals("")) {
// S spremenljivko update si pomagamo, da vemo ali dodajamo novo
objavo ali spreminjamo že obsoječo.
update = true;
// Poiščemo grafični gradnik EditText in mu nastavimo oziroma
pripišemo vrednost besedila in končamo aktivnost imenovano BulletinBoardActivity.
EditText obvestilo = (EditText)findViewById(R.id.text);
obvestilo.setText(besedilo);
}
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
if (id == R.id.odjava) {
navigateUpTo(new Intent(this, MainActivity.class));
return true;
}
return super.onOptionsItemSelected(item);
}
// V metodi onClick() se izvede koda, ki se izvede po kliku na gumb.
@Override
public void onClick(View v) {
if(v.getId() == R.id.buttonPublish) {
EditText obvestilo = (EditText)findViewById(R.id.text);
besedilo = obvestilo.getText().toString();
// Primerjamo ali je besedilo objave prazno in izpišemo obvestilo, da
objava ne sme biti prazna.
if(besedilo.equals("")) {
Toast toast = Toast.makeText(this, "Objava ne more biti
prazna!", Toast.LENGTH_LONG);
toast.show();
}
else {
// Preverimo stanje CheckBox - a in ga shranimo v
spremenljivko imenovano isChecked.
CheckBox check = (CheckBox)findViewById(R.id.checkBox);
if(check.isChecked()) {
isChecked = "true";
}
else {
isChecked = "false";
}
// Definirano novo nit DataBaseAccess in preverimo vrednost
spremenljivke update ter objavo shranimo v podatkovno zbirko v primeru, da je vrednost
spremenljivke update false.
// V primeru, da je vrednost spremenljivke update true se
spremenjena objava posodobi v podatkovni zbirki.
DataBaseAccess access = new DataBaseAccess(cb);
if(update == false) {
access.execute("shrani");
}
else {
access.execute("update");
}
}
}
}
private void loadSpinner() {
ArrayList<String> niz = new ArrayList<>();
for (String skupina : skupine.keySet()) {
niz.add(skupina);
}
MultiSpinner multiSpinner = (MultiSpinner)
findViewById(R.id.multi_spinner);
multiSpinner.setItems(niz, getString(R.string.for_all), this, post_in_groups);
group_id = new ArrayList<>();
Object[] ids = skupine.values().toArray();
for(int i = 0; i < ids.length; i++) {
group_id.add(Integer.parseInt(ids[i]+""));
}
}
// Get in Set metode nam vrnejo rezultate potrebne za delo z njimi.
public static CharSequence getText() {
return besedilo;
}
public void startActivity() {
navigateUpTo(new Intent(this, BulletinBoardActivity.class));
}
public static String getIsChecked() {
return isChecked;
}
@Override
public void onItemsSelected(boolean[] selected) {
group_id = new ArrayList<>();
Object[] ids = skupine.values().toArray();
for(int i = 0; i < selected.length; i++) {
if(selected[i]) {
group_id.add(Integer.parseInt(ids[i]+""));
}
}
}
public static void setSkupine(HashMap<String, Integer> groups) {
skupine = groups;
}
}
Vsebina datoteke MultiSpinner.java
package com.example.gui;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnCancelListener;
import android.content.DialogInterface.OnMultiChoiceClickListener;
import android.util.AttributeSet;
import android.widget.ArrayAdapter;
import android.widget.Spinner;
import java.util.ArrayList;
import java.util.List;
public class MultiSpinner extends Spinner implements OnMultiChoiceClickListener,
OnCancelListener {
private List<String> items;
private boolean[] selected;
private String defaultText;
private MultiSpinnerListener listener;
public MultiSpinner(Context context) {
super(context);
}
public MultiSpinner(Context arg0, AttributeSet arg1) {
super(arg0, arg1);
}
public MultiSpinner(Context arg0, AttributeSet arg1, int arg2) {
super(arg0, arg1, arg2);
}
@Override
public void onClick(DialogInterface dialog, int which, boolean isChecked) {
if (isChecked) {
selected[which] = true;
}
else {
selected[which] = false;
}
}
@Override
public void onCancel(DialogInterface dialog) {
// refresh text on spinner
StringBuffer spinnerBuffer = new StringBuffer();
boolean someUnselected = false;
for (int i = 0; i < items.size(); i++) {
if (selected[i] == true) {
spinnerBuffer.append(items.get(i));
spinnerBuffer.append(", ");
}
else {
someUnselected = true;
}
}
String spinnerText;
if (someUnselected) {
spinnerText = spinnerBuffer.toString();
if (spinnerText.length() > 2)
spinnerText = spinnerText.substring(0, spinnerText.length() - 2);
}
else {
spinnerText = defaultText;
}
ArrayAdapter<String> adapter = new ArrayAdapter<String>(getContext()
android.R.layout.simple_spinner_item, new String[] { spinnerText });
setAdapter(adapter);
listener.onItemsSelected(selected);
}
@Override
public boolean performClick() {
AlertDialog.Builder builder = new AlertDialog.Builder(getContext());
builder.setMultiChoiceItems(items.toArray(new CharSequence[items.size()]),
selected, this);
builder.setPositiveButton(android.R.string.ok;
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.cancel();
}
});
builder.setOnCancelListener(this);
builder.show();
return true;
}
public void setItems(List<String> items, String allText,
MultiSpinnerListener listener, ArrayList<Boolean> post_in_groups) {
this.items = items;
this.defaultText = allText;
this.listener = listener;
// all selected by default
selected = new boolean[items.size()];
for (int i = 0; i < post_in_groups.size(); i++)
selected[i] = post_in_groups.get(i);
if(post_in_groups.contains(false)) {
StringBuffer spinnerBuffer = new StringBuffer();
for (int i = 0; i < items.size(); i++) {
if (selected[i] == true) {
spinnerBuffer.append(items.get(i));
spinnerBuffer.append(", ");
}
}
allText = spinnerBuffer.toString();
}
// all text on the spinner
ArrayAdapter<String> adapter = new
ArrayAdapter<String>(getContext(), android.R.layout.simple_spinner_item, new String[] {
allText });
setAdapter(adapter);
}
public interface MultiSpinnerListener {
public void onItemsSelected(boolean[] selected);
}
}
Vsebina datoteke PublishActivity:
package com.example.bulletinboard;
// Uvoz vseh paketov potrebnih za izvedbo aktivnosti.
import android.support.v7.app.ActionBarActivity; // Paket ActionBarActivity je potreben
zaradi action bar, ki ga imamo v aplikaciji.
import android.content.Intent; // Paket Intent je uporabljen za začetek nove aktivnosti pred
čemer zapremo trenutno.
import android.os.Bundle; // Paket Bundle je potreben pri izvedbi metod OnCreate in ostalih,
ki jih imamo v aktivnosti.
import android.view.Menu; // Paket Menu uporabimo pri prikazu menijev, ki jih uporabljamo
in prikazujemo na uporabniškemu vmesniku aplikacije.
import android.view.MenuItem; // Paket MenuItem se uporablja za prikaz izbranega elementa
v vrstici z menijem.
import android.view.View; // Paket View se uporablja za prikaz pogleda oziroma
uporabniškega vmesnika.
import android.view.View.OnClickListener; // Paket OnClickListener se uporablja za
poslušanje aktivnosti, ki se dogaja v času uporabnikovega pritiska na gumb.
import android.widget.Button; // Paket Button se uporablja za prikaz gumba na uporabniškem
vmesniku in poslušanje dogajanja preko OnClickListener() metode.
import android.widget.CheckBox; // Paket CheckBox se uporablja za prikaz CheckBoxa
oziroma potrditvenega gumba na uporabniškemu vmesniku aplikacije.
import android.widget.EditText; // Paket EditText je uporabljen pri prikazu polja za urejanje
besedila.
import android.widget.Toast; // Paket Toast se uporablja za prikaz besedila v popUp oknu.
import java.util.ArrayList; // Paket ArrayList je namenjen shranjevanju polj in dodajanju
novih podatkov vanje.
import java.util.HashMap; // Paket HashMap je uporabljen za prikaz skupin.
import com.example.bulletinboard.DataBaseAccess.Callback; // Paket Callback se uporablja
za ustavitev zmrzovanja uporabniškega vmesnika med izvajanjem druge niti.
import com.example.gui.MultiSpinner; // Paket MultiSpinner je namenjen prikazu skupin, ki
jih potrebujemo za objavo nove objave in pri spreminjanju objave, da vemo kdo jo vidi in kdo
ne.
import com.example.gui.MultiSpinner.MultiSpinnerListener; // Paket MultiSpinnerListener je
uporaben in deluje podobno kot paket OnClickListener.
// Definicija glavnega dela aktivnosti.
public class PublishActivity extends ActionBarActivity implements OnClickListener,
MultiSpinnerListener {
// Tukaj so definirane vse spremenljivke potrebne za izvedbo aktivnosti.
static String isChecked; // Spremenljivka isChecked je definirana zaradi metode
getIsChecked().
EditText text; // Spremenljivka text je definirana zaradi metode getText(), ki nam vrne
besedilo izpisano na uporabniški vmesnik aplikacije.
Button buttonPublish; // Spremenljivka buttonPublish je namenjena gumbu objavi
besedilo.
static CharSequence besedilo = ""; // Spremenljivka besedilo se ukvarja z besedilom,
ki ga pridobimo z uporabniškega vmesnika aplikacije.
boolean update = false; // Spremenljivka update skrbi za spremembo besedila
zapisanega v podatkovno zbirko.
static HashMap<String, Integer> skupine;
static ArrayList<Integer> group_id;
static ArrayList<Boolean> post_in_groups = new ArrayList<>();
public static void setPost_in_groups(ArrayList<Boolean> in_groups) {
post_in_groups = in_groups;
}
public static ArrayList<Integer> getGroup_id() {
return group_id;
}
Callback cb = new Callback() {
@Override
public void onComplete(String myResult) {
BulletinBoardActivity.setUpdatePostId(-1);
startActivity();
}
};
Callback c = new Callback() {
@Override
public void onComplete(String myResult) {
loadSpinner();
}
};
// Izrišemo uporabniški vmesnik.
// Poiščemo gumb ButtonPublish preko id - ja buttonPublish in mu nastavimo
onClickListener, ki posluša klike na gumb buttonPublish.
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_vnos_podatkov);
buttonPublish = (Button)findViewById(R.id.buttonPublish);
buttonPublish.setOnClickListener(this);
DataBaseAccess access = new DataBaseAccess(c);
access.execute("skupina");
// Pridobimo vrednost spremenljivke besedilo iz BulletinBoardActivity
aktivnosti.
// Če ni prazno to pomeni, da ga želimo urediti in ne dodati novega besedila.
besedilo = BulletinBoardActivity.getBesedilo();
if(!besedilo.equals("")) {
// S spremenljivko update si pomagamo, da vemo ali dodajamo novo
objavo ali spreminjamo že obsoječo.
update = true;
// Poiščemo grafični gradnik EditText in mu nastavimo oziroma
pripišemo vrednost besedila in končamo aktivnost imenovano BulletinBoardActivity.
EditText obvestilo = (EditText)findViewById(R.id.text);
obvestilo.setText(besedilo);
}
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
if (id == R.id.odjava) {
navigateUpTo(new Intent(this, MainActivity.class));
return true;
}
return super.onOptionsItemSelected(item);
}
// V metodi onClick() se izvede koda, ki se izvede po kliku na gumb.
@Override
public void onClick(View v) {
if(v.getId() == R.id.buttonPublish) {
EditText obvestilo = (EditText)findViewById(R.id.text);
besedilo = obvestilo.getText().toString();
// Primerjamo ali je besedilo objave prazno in izpišemo obvestilo, da
objava ne sme biti prazna.
if(besedilo.equals("")) {
Toast toast = Toast.makeText(this, "Objava ne more biti
prazna!", Toast.LENGTH_LONG);
toast.show();
}
else {
// Preverimo stanje CheckBox - a in ga shranimo v
spremenljivko imenovano isChecked.
CheckBox check = (CheckBox)findViewById(R.id.checkBox);
if(check.isChecked()) {
isChecked = "true";
}
else {
isChecked = "false";
}
// Definirano novo nit DataBaseAccess in preverimo vrednost
spremenljivke update ter objavo shranimo v podatkovno zbirko v primeru, da je vrednost
spremenljivke update false.
// V primeru, da je vrednost spremenljivke update true se
spremenjena objava posodobi v podatkovni zbirki.
DataBaseAccess access = new DataBaseAccess(cb);
if(update == false) {
access.execute("shrani");
}
else {
access.execute("update");
}
}
}
}
private void loadSpinner() {
ArrayList<String> niz = new ArrayList<>();
for (String skupina : skupine.keySet()) {
niz.add(skupina);
}
MultiSpinner multiSpinner = (MultiSpinner)
findViewById(R.id.multi_spinner);
multiSpinner.setItems(niz, getString(R.string.for_all), this, post_in_groups);
group_id = new ArrayList<>();
Object[] ids = skupine.values().toArray();
for(int i = 0; i < ids.length; i++) {
group_id.add(Integer.parseInt(ids[i]+""));
}
}
// Get in Set metode nam vrnejo rezultate potrebne za delo z njimi.
public static CharSequence getText() {
return besedilo;
}
public void startActivity() {
navigateUpTo(new Intent(this, BulletinBoardActivity.class));
}
public static String getIsChecked() {
return isChecked;
}
@Override
public void onItemsSelected(boolean[] selected) {
group_id = new ArrayList<>();
Object[] ids = skupine.values().toArray();
for(int i = 0; i < selected.length; i++) {
if(selected[i]) {
group_id.add(Integer.parseInt(ids[i]+""));
}
}
}
public static void setSkupine(HashMap<String, Integer> groups) {
skupine = groups;
}
}
Vsebina datoteke DataBaseAccess:
package com.example.bulletinboard;
// Tukaj uvozimo vse potrebne pakete za delo z aktivnostjo.
import java.sql.Connection; // Paket Connection je potreben za vzpostavitev povezave med
aplikacijo in podatkovno zbirko.
import java.sql.DriverManager; // Paket DriverManager je namenjen uporabi gonilnika za
vzpostavitev povezave med podatkovno zbirko in aplikacijo.
import java.sql.PreparedStatement; // Paket PreparedStatement se uporablja za izvedbo
poizved potrebnih za izvedbo aplikacije.
import java.sql.ResultSet; // Paket ResultSet nam prikaže rezultate pridobljene preko
uporabniškega vmesnika aplikacije.
import java.sql.SQLException; // Paket SQLException nam vrne SQL napako v primeru, da
se pojavi med izvajanjem kode v obliki poizvedb.
import java.sql.Statement; // Paket Statement se uporablja za prenos poizvedb med aplikacijo
in podatkovno zbirko.
import java.util.ArrayList; // Paket ArrayList nam pomaga pri izdelavi polja za shranjevanje
vrednosti spremenljivk.
import java.util.LinkedHashMap; // Paket LinkedHashMap se uporablja pri podatkovnemu
tipu Linked HashMap, ki predstavlja tabelo zurejenimi podatki.
import android.os.AsyncTask; // Paket AsyncTask predstavlja task pri katerem se izvajanje
glavne niti ne ustavi tako kot bi se v primeru, da nimamo dodatne niti za izris uporabniškega
vmesnika.
// Definicija glavnega dela aktivnosti.
public class DataBaseAccess extends AsyncTask<String, Void, String> {
// Spremenljivke potrebne za delo z aktivnostjo.
private String operation; // Spremenljivka operation skrbi, da se v delu kode z imenom
switch sploh kaj zgodi.
private Connection con; // Spremenljivka con se uporablja za vzpostavitev povezave
med aplikacijo in podatkovno zbirko.
private static final String url = "jdbc:mysql://192.164.1.4:3306/diplomska_naloga"; //
String url se uporablja za povezavo do podatkovne zbirke.
private static final String user = "root"; // String user se uporablja kot uporabniško ime
potrebno za prijavo v podatkovno zbirko (android aplikacijo).
private static final String pass = "root"; // String pass se uporablja kot uporabnikovo
geslo potrebno za prijavo v podatkovno zbirko (android aplikacijo).
private Callback callback; // Spremenljivka callback se uporablja za metodo callback
pri kateri se nam ne ustavi izris uporabniškega vmesnika zaradi izvedbe druge niti.
// Callback metoda se izvaja zaradi izvajanja druge niti in se nam s tem ne ustavi izris
uporabniškega vmesnika.
public static interface Callback{
public void onComplete(String myResult);
}
public DataBaseAccess(Callback callback) {
this.callback = callback;
}
// Metoda doInBackground() se izvaja v ozadju in skrbi za vzpostavitev povezave med
podatkovno zbirko ter aplikacijo.
@Override
protected String doInBackground(String... params) {
if(this.isCancelled()) {
return null;
}
// Spremenljivki operation pripišemo vrednost iz argumentov razreda.
operation = params[0];
try {
try {
// Registriramo nov driver za mysql podatkovno zbirko.
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
try {
// Vzpostavimo povezavo do podatkovne zbirke.
Class.forName("com.mysql.jdbc.Driver");
con = DriverManager.getConnection(url, user, pass);
if (con == null) {
return "Dostop do baze ni uspel!";
}
}
catch(SQLException e) {
e.printStackTrace();
}
}
catch(Exception e) {
e.printStackTrace();
}
}
catch (Exception e) {
e.printStackTrace();
}
String result = null;
// Pri switch delu kode kličemo ustrezno metodo glede na spremenljivko
operation.
switch(operation) {
case "prijava":
result = verifyUser();
break;
case "registracija":
result = registrateUser();
break;
case "objave":
getPosts();
result = "true";
break;
case "shrani":
novaObjava(PublishActivity.getText().toString());
break;
case "update":
updatePost(PublishActivity.getText().toString());
break;
case "skupina":
skupine();
break;
case "osvezi":
result = refresh();
break;
}
try {
con.close();
}
catch (SQLException e) {
e.printStackTrace();
}
return result;
}
// Izvede se po končani izvedbi metode doInBackground()
@Override
protected void onPostExecute(String result) {
super.onPostExecute(result);
callback.onComplete(result);
};
// Metoda VerifyUser() preveri uporabnikov vnos in ga primerja z podatki v
podatkovni zbirki.
public String verifyUser() {
MainActivity.setUserId(-1);
int id = -1;
int id_group = -1;
try {
// Niz poizvedba nam pridobi podatke (uporabniško ime in geslo) iz
podatkovne zbirke.
String poizvedba = String.format("SELECT id, group_id FROM users
WHERE user_name= '%s' AND password= '%s';", MainActivity.getUser(),
MainActivity.getPassword());
// Ustvarimo in izvedemo poizvedbo nad podatkovno zbirko ter shranimo
rezultat v ResultSet.
Statement st = con.createStatement();
ResultSet rs = st.executeQuery(poizvedba);
// Premikamo se skozi vrstice rezultata in shranimo id uporabnika.
while(rs.next()) {
id = rs.getInt(1);
id_group = rs.getInt(2);
}
// Če je id še vedno -1 to pomeni, da je bil rezultat poizvedbe prazen oziroma ni
vrnila nobene vrstice v tabeli.
// Iz tega sklepamo, da ni uporabnika z uporabniškim imenom in geslom.
if(id == -1) {
return "Uporabniško ime ali geslo je napačno!";
}
// Kličemo metodo setUserId() z argumentom id uporabnika, ki ga pridobimo iz
podatkovne zbirke.
MainActivity.setUserId(id);
MainActivity.setUserGroupId(id_group);
}
catch(SQLException e) {
e.printStackTrace();
}
// Vedno zapremo povezavo z podatkovno zbirko, da ne pride do zapolnitve
dovoljenih povezav.
finally {
try {
con.close();
}
catch (SQLException e) {
e.printStackTrace();
}
}
return "Prijava je bila uspešna!";
}
// Metoda registrateUser() nam preveri ali je uporabnik s imenom, ki je bilo vneseno v
uporabniški vmesnik že shranjen v podatkovno zbirko ali ne.
public String registrateUser() {
MainActivity.setUserId(-1);
try {
// Pošljemo poizvedbo, ki nam vrne id uporabnika z istim imenom kot
ga je vnesel uporabnik in pridobimo rezultat.
String poizvedba = String.format("SELECT id FROM users WHERE
user_name= '%s';", MainActivity.getUser());
Statement st = con.createStatement();
ResultSet rs = st.executeQuery(poizvedba);
// Če rezultat poizvedbe ni prazen to pomeni, da je uporabnik s tem
imenom že shranjen.
if(rs.next()) {
return "Uporabniško ime je že zasedeno!";
}
}
catch(SQLException e) {
e.printStackTrace();
}
try {
con.close();
}
catch (SQLException e1) {
e1.printStackTrace();
return "Registracija ni uspela";
}
return "Registracija ni uspela";
}
// Uporabnika dodamo v podatkovno zbirko v primeru, da ni že shranjen v njej.
String poizvedba = "INSERT INTO users (user_name, password, group_id) VALUES
(?, ?, ?);";
int affectedRows = 0;
try {
PreparedStatement statement = null;
try {
statement = con.prepareStatement(poizvedba,
Statement.RETURN_GENERATED_KEYS);
statement.setString(1, MainActivity.getUser());
statement.setString(2, MainActivity.getPassword());
statement.setInt(3, 1);
affectedRows = statement.executeUpdate();
}
catch (SQLException e1) {
e1.printStackTrace();
return "Registracija ni uspela";
}
if (affectedRows == 0) {
return "Registracija ni uspela";
}
try {
// Pridobimo uporabnikov id, ki je bil avtomatsko generiran v
podatkovni zbirki.
ResultSet generatedKeys = statement.getGeneratedKeys();
if (generatedKeys.next()) {
// Shranimo uporabnikov id z metodo MainActivity.setUserId().
MainActivity.setUserId(generatedKeys.getInt(1));
}
else {
return "Registracija ni uspela";
}
}
catch(SQLException e) {
e.printStackTrace();
return "Registracija ni uspela";
}
}
finally {
try {
con.close();
return "Registracija uspešna";
}
catch (SQLException e) {
e.printStackTrace();
}
}
return "";
}
// Pridobimo vse prikazane objave iz podatkovne zbirke.
public void getPosts() {
try {
// Ustvarimo poizvedbo in jo pošljemo v podatkovno zbirko preko
povezave.
String poizvedba = String.format("SELECT DISTINCT data.id,
data.podatki, data.id_user, users.user_name" + " FROM users" + " INNER JOIN data ON
data.id_user = users.id" + " INNER JOIN post_in_groups" + " ON data.id =
post_in_groups.id_post" + " WHERE (data.active= 'true' AND post_in_groups.id_group =
%d) OR (data.id_user = %d)" + " ORDER BY data.id DESC;", MainActivity.getId_group(),
MainActivity.getUserId());
Statement st = con.createStatement();
ResultSet rs = st.executeQuery(poizvedba);
LinkedHashMap<Integer, Post> obvestila = new
LinkedHashMap<Integer, Post>();
// Za vsako pridobljeno vrstico se doda: posts = id objave - besedilo
objave in user_id = id objave - id uporabnika.
while(rs.next()) {
Post obvestilo = new Post(rs.getInt(1), rs.getString(2),
rs.getInt(3), rs.getString(4));
obvestila.put(rs.getInt(1), obvestilo);
}
BulletinBoardActivity.setObvestila(obvestila);
}
catch(SQLException e) {
e.printStackTrace();
}
finally {
try {
con.close();
}
catch (SQLException e) {
e.printStackTrace();
}
}
}
// Novo objavo zapišemo v podatkovno zbirko.
public String novaObjava(String objava) {
String poizvedba = "INSERT INTO data (podatki, id_user, active)
VALUES (?, ?, ?);";
try {
PreparedStatement st = null;
st = con.prepareStatement(poizvedba,
Statement.RETURN_GENERATED_KEYS);
st.setString(1, objava.replaceAll("\\n", "<br />"));
st.setInt(2, MainActivity.getUserId());
st.setString(3, PublishActivity.getIsChecked());
st.executeUpdate();
ResultSet generatedKeys = st.getGeneratedKeys();
if (generatedKeys.next()) {
int post_id = generatedKeys.getInt(1);
ArrayList<Integer> group_id =
PublishActivity.getGroup_id();
for(int i:group_id) {
String query = String.format("INSERT INTO
post_in_groups (id_post, id_group) VALUES (%d, %d);", post_id, i);
Statement statement = con.createStatement();
statement.executeUpdate(query);
}
}
}
catch (SQLException e) {
e.printStackTrace();
}
finally {
try {
con.close();
}
catch (SQLException e) {
e.printStackTrace();
}
}
return null;
}
// Posodobimo besedilo že shranjene objave.
public String updatePost(String besedilo) {
String poizvedba = "UPDATE data SET podatki = '" +
besedilo.replaceAll("\\n", "<br />") + "', active = '" + PublishActivity.getIsChecked() + "'
WHERE id = "+ BulletinBoardActivity.getUpdatePostId() +";";
try {
Statement st = con.createStatement();
st.executeUpdate(poizvedba);
st.executeUpdate("DELETE FROM post_in_groups WHERE
id_post = " + BulletinBoardActivity.getUpdatePostId() + ";");
ArrayList<Integer> group_id = PublishActivity.getGroup_id();
for(int i:group_id) {
String query = String.format("INSERT INTO post_in_groups
(id_post, id_group) VALUES (%d, %d);", BulletinBoardActivity.getUpdatePostId(), i);
st = con.createStatement();
st.executeUpdate(query);
}
}
catch (SQLException e) {
e.printStackTrace();
}
finally {
try {
con.close();
}
catch (SQLException e) {
e.printStackTrace();
}
}
return null;
}
public void skupine() {
LinkedHashMap<String, Integer> skupine = new LinkedHashMap<>();
String skupina = String.format("SELECT group_name, group_id FROM
user_groups ORDER BY group_id;");
String query = String.format("SELECT id_group FROM post_in_groups
WHERE id_post = %d", BulletinBoardActivity.getUpdatePostId());
ArrayList<Boolean> in_groups = new ArrayList<>();
try {
Statement st = con.createStatement();
ResultSet rs = st.executeQuery(skupina);
Statement statement = con.createStatement();
ResultSet result = statement.executeQuery(query);
ArrayList<Integer> post_in_groups = new ArrayList<>();
while(result.next()) {
post_in_groups.add(result.getInt(1));
}
while(rs.next()) {
skupine.put(rs.getString(1), rs.getInt(2));
if(post_in_groups.size() != 0) {
if(post_in_groups.contains(rs.getInt(2)) ) {
in_groups.add(true);
}
else {
in_groups.add(false);
}
}
else {
in_groups.add(true);
}
}
PublishActivity.setPost_in_groups(in_groups);
PublishActivity.setSkupine(skupine);
}
catch (SQLException e) {
e.printStackTrace();
}
finally {
try {
con.close();
}
catch (SQLException e) {
e.printStackTrace();
}
}
}
public String refresh() {
Statement stmt;
String rezultat = "false";
try {
stmt = con.createStatement();
ResultSet resultSet = stmt.executeQuery("SELECT COUNT(*) FROM
data");
// Get the number of rows from the result set
resultSet.next();
int rowcount = resultSet.getInt(1);
if(rowcount < MainActivity.getRowcount()) {
rezultat = "true";
}
MainActivity.setRowcount(rowcount);
}
catch (SQLException e) {
e.printStackTrace();
}
finally {
try {
con.close();
}
catch (SQLException e) {
e.printStackTrace();
}
}
return rezultat;
}
}
Priloga 2: Seznam uporabljenih kratic
OHA - Open Handset Alliance je združenje podjetij, ki jih je ustanovil Google za odprt razvoj
trga mobilnih telefonov.
JIT - Just In Time (Compiler) je prevajalnik, ki izvede prevajanje kode ob nalaganju
aplikacije.
ART - Android Run Time je prevajalnik, ki prevede kodo pred nalaganjem aplikacije na
mobilni telefon
ADT - Android Development Tools je orodje, ki nam pomaga pri programiranju Android
aplikacije in ga potrebujemo skupaj z razvojnim okoljem Eclipse.
AOT - Ahead Of Time je prevajalnik, ki se izvede v času izvedbe aplikacije
JDBC - Java Data Base Connectivity (Technology) je tehnologija uporabljena za povezovanje
android aplikacije in MySQL podatkovne zbirke
MySQL - Sistem za upravljanje s podatkovnimi zbirkami