tanulas_andoidos_alkalmazasfejlesztes_kotlin_nyelven_1
Fehér Krisztián: Androidos alkalmazásfejlesztés Kotlin nyelven - 1. rész
Tartalomjegyzék
1 Előszó
1.1 Az Android diadalmenete
1.2 Célközönség, követelmények
1.3 Mit tanulhatunk meg a leírásból?
1.4 Mit nem tanulhatunk meg a leírásból?
2 A Kotlin programozási nyelv
2.1 Mi az a Kotlin?
2.2 Hogyan juthatunk a Kotlin nyelvhez?
2.3 Miben más a Kotlin, mint a Java?
2.4 Megjegyzések a kódban
2.5 Adattípusok, változók
2.5.1 Logikai típus
2.5.2 Numerikus típusok
2.5.3 Karaketeres típusok
2.5.4 Típuskonverzió
2.5.5 Logikai operátorok
2.5.6 Értékadó operátorok
2.5.7 Bitműveletek
2.5.8 Tömbök
2.6 Elágazási szerkezetek
2.7 Ciklusok
2.8 Metódusok, függvények
2.9 Osztályok, metódusok
2.10 Csomagok
2.11 Láthatóság, hozzáférés
2.12 Alkalmazás bezárása
3 Ismerkedés az Android Studioval
3.1 Telepítés, konfigurálás
3.2 Kipróbálás emulátorral
3.3 Futtatás valódi eszközön
3.4 Ismerkedés a kezelőfelülettel
4 Androidos alapfogalmak
4.1 API level
4.2 Activity
4.3 View
4.4 A legalapvetőbb projektfájlok
4.5 Alkalmazásengedélyek
4.6 Minimális Android verzió megadása
4.7 Verzió beállítása
4.8 A felhasználói felület leírókódja
4.9 Az alkalmazáslogika forrásfájlja
5 Egyszerű alkalmazások készítése
5.1 Szövegcímke - TextView
5.2 Nyomógomb - Button
5.2.1 Játékos kód
5.3 Szöveges bevitel - EditText
6 Alkalmazások publikálása
6.1 Fejlesztői tanúsítvány készítése
6.1.1 APK generálása
6.2 Feltöltés a Play Áruházba
6.2.1 Értékelések kezelése
6.3 A közzétett alkalmazások utóélete
7 Függelék
Az alkalmazások életciklusa
1 Előszó
A Kotlin a Google által a Java mellett hivatalosan is preferált programozási nyelv Android alapú alkalmazások fejlesztésére. A Kotlin futótűzszerűen terjed szerte a világon: a top1000 androidos alkalmazás 60 százalékát már Kotlinban fejlesztik és világszerte folyamatos az átállás erre a nyelvre az mobilalkalmazás fejlesztők körében.
Ez leírás az androidos alkalmazásfejlesztés mikéntjébe nyújt betekintést, a Kotlin nyelv felhasználásával.
1.1 Az Android diadalmenete
Az Android operációs rendszer kétségtelenül napjaink legelterjedtebb mobil operációs rendszere. Elterjedtségének egyik oka, hogy nyílt forráskódon alapuló, lényegében bárki számára elérhető, továbbfejleszthető rendszerről van szó, melyre nagyon könnyű és lényegében ingyen lehet alkalmazásokat fejleszteni.
A számos telekommunikációs cég által fémjelzett, ám de facto a Google által domináltan fejlesztett rendszer elérhető okostelefonra, tabletre, viselhető eszközökre, sőt még TV-kre is.
A rendszerről a https://www.android.com/ weboldalon olvashatunk naprakész, hivatalos információkat.
1.2 Célközönség, követelmények
A leírás egyedülálló módon három potenciális olvasótípus számára lett összeállítva:
- 1. érdeklődő olvasók, programozási ismeretek nélkül (ezen olvasók a 2. fejezetet kihagyhatják)
- 2. a C, vagy rokon (pl. Java) programozási nyelvet ismerő olvasó, aki szeretne elkezdeni Androidra fejleszteni
- 3. a Java alapú androidos fejlesztést ismerő olvasó, aki szeretné megismerni, hogyan lehet a Kotlint használni ugyanarra a célra.
A programozási lehetőségek az Android Studio-val, a Google hivatalos fejlesztőeszközével lesznek röviden szemléltetve, Windows operációs rendszeren futtatva.
1.3 Mit tanulhatunk meg a leírásból?
A leírás elsődleges célja, hogy az olvasó minél gyorsabban megismerhesse az alkalmazásfejlesztés alapjait és akár bele is kezdhessen saját mobilalkalmazások fejlesztésébe, ezzel kedvet kapjon saját appok tervezéséhez és kivitelezéséhez Kotlin nyelven.
Ennek érdekében csak a legszükségesebb és a legalapvetőbb ismeretek átadására törekedhetünk.
A leírás ismeretanyagát feldolgozva az olvasó képes lesz a nulláról indulva a fejlesztőrendszer önálló telepítésére és beüzemelésére, néhány alapvető vezérlőelem programozására és képes lesz az alkalmazásait akár publikálni is a Play Store-ban.
1.4 Mit nem tanulhatunk meg a leírásból?
A leírás nem törekszik átfogó androidos programozási ismeretek bemutatására, mert ezzel a leírás keretei túlságosan megnőnének.
További vonatkozó ismereteanyag megszerzéséhez a leírás tervezett további részei lesznek használhatóak.
2 A Kotlin programozási nyelv
Ebben a fejezetben megismerkedhetünk a Kotlin nyelvvel, melynek használatát a későbbiekben az Android szemszögéből fogjuk tárgyalni, nagyon egyszerű példákon keresztül.
Ez a fejezet egyben azok számára is hasznos, akik tömör formában meg akarják ismerni a nyelv szintaktikáját.
A bemutatásra kerülő témakörök csak egy nagyon kis szeletét képezik a nyelv teljes lehetőségeinek, de ahhoz éppen elegendőek, hogy megvessük a lábunkat: ez az elsődleges cél.
2.1 Mi az a Kotlin?
A Kotlin egy keresztplatformos szellemiségű, nyílt forráskódú projekt, pontosabban egy programozási nyelv.
Weboldalának címe: https://kotlinlang.org/
A nyelvet az a JetBrains fejleszti, ami az IntelliJ Idea fejlesztőeszközt is, ami nem mellesleg a Google hivatalos androidos fejlesztőeszköze is, Android Studio néven.
A JetBrains központja Prágában van, erős jelenléttel Oroszországban és az Egyesült Államokban is.
A nyelvhez a Google nagyon komolyan odaállt patrónusként is, aminek a Kotlin Foundation lenevezésű alapítvány ad keretet. Ez egyben biztosíték is lehet a jövőre nézve, ami egy nagyon fontos érv egy új programozási nyelv megtanulása mellett, hiszen egy bizonytalan jövőjű nyelv mellé, legyen az akármennyire innovatív, nem szívesen állnának fejlesztők tömegei.
Ez a leírás a Kotlin nyelvet az Android operációs rendszerre fejleszthető alkalmazások szempontjából tárgyalja, ennek megfelelően erre az irányra fogunk koncentrálni.
2.2 Hogyan juthatunk a Kotlin nyelvhez?
A Kotlin hivatalos androidos programozási nyelv, ezért az Android Studio telepítése, ill. konfigurálása során a nyelv használatához szükséges minden kiegészítő telepíthető.
2.3 Miben más a Kotlin, mint a Java?
A legtöbbször a nyelv tömörségét szokták felhozni nagy erősségeként és valóban, számos esetben kevesebb kóddal célt lehet érni, de ami talán még fontosabb: átláthatóbb lesz a programkód, mint Java esetében.
Jogi oldalról szemlélve is jelentős a különbség, ugyanis a Java az Oracle céghez kötődik, ennek minden hozadékával. Ebből adódott az a jogi vita is, mely a Google és az Oracle között robbant ki pár éve a Java liszenszelésével kapcsolatban. Azt, hogy ez mennyiben járult hozzá a Google-nak a nyílt forrású Kotlin felé fordulásához, a leírásom mindazonáltal nem kívánja boncolgatni. Legyen elég annyi, hogy a Kotlin egy stabil hátterű, modern szemléletű programozási nyelv, mely még sok növekedési potenciállal rendelkezik.
A Kotlin messzemenően hasonlít a Java nyelvhez, éppen ezért az egyezéseket többnyire nem tárgyaljuk, helyette igyekszünk a különbségekre, illetve azon témakörökre koncentrálni, melyeket egy új programozási nyelv megismerése során nem lehet kikerülni.
2.4 Megjegyzések a kódban
Kotlin kódban az utasításokat nem kötelező ”;” jellel lezárni. Ha valaki szeretné, nem lesz gond belőle, de elhagyható, picit tisztább is a kód külalakja tőle, bár elsőre szokatlanul hathat.
Megjegyzéseket a C nyelv szintaktikájához hasonlóan hozhatunk létre.
Példák:
//megjegyzés
/*
megjegyzés
*/
A Kotlin kisbetű-nagybetű érzékeny.
A kódban blokkokat szervezhetünk a {} jelek segítségével.
2.5 Adattípusok, változók
Kotlinban konstansokat a val kulcsszóval deklarálhatunk, melynek rögtön értéket kell adnunk. Az állandó típusát közvetlenül is megadhatjuk, de a megadott értékből is meg tudja határozni a nyelv a típust.
Példa:
val szoveg = ”Ez egy szöveges konstans.”
val szoveg : String = ”Ez egy szöveges konstans.”
„Sima” változót a var kulcsszóval vezetünk be. Ilyenkor meg kell adnunk a változó típusát is.
Példa:
val szoveg : String
2.5.1 Logikai típus
Boolean: true vagy false értéket vehet csak fel.
2.5.2 Numerikus típusok
A leggyakoribb numerikus típusok:
• Byte: 8 bites előjeles egész.
• Short: 16 bites előjeles egész.
• Int: 32 bites előjeles egész.
• Long: 64 bites előjeles egész
• Float: 32 bites előjeles lebegőpontos
• Double: 64 bites előjeles lebegőpontos
A Kotlin 1.3 óta, kísérleti jelleggel elérhetőek előjel nélküli típusok is.
• Ubyte, Ushort, UInt, Ulong: ugyanaz, mint fentebb, de előjel nélküli pozitív számok.
2.5.3 Karaketeres típusok
Char: karakter.
String: karakterlánc.
Karaktereket explicit módon aposztrófok között adhatunk meg, például: ’a’. A backslash Használatával escape szekvenicákat is használhatunk, pl.: \t, \b, \n, \r, \', \", \\ , \$ .
A sztringek lényegében karaktersorozatok. Mindegyik karakterhez közvetlenül hozzáférhetünk a [] jelek segítségével, pl.: szoveg[1].
2.5.4 Típuskonverzió
Ha biztosra akarunk menni, akkor nem hagyatkozunk az egyébként elérhető implicit típuskonverzióra, hanem azt explicit módon tesszük meg, az alábbi metódusokkal:
• toByte()
• toShort()
• toInt()
• toLong()
• toFloat()
• toDouble()
• toChar()
• toString().
Például: szoveg = egeszszam.toString().
2.5.5 Logikai operátorok
A C/Java-ban megtalálható logikai operátorok Kotlinban is használhatóak: >, <, =, >=, <=, ==, !=
Meg kell említeni viszont, hogy Kotlinban lehetőség van értékhatárok vizsgálatára is x in a..b , illetve az x !in a..b formában.
2.5.6 Értékadó operátorok
A klasszikus ++, --, +=, -=, *=, /= operátorok elérhetőek a Kotlinban is.
2.5.7 Bitműveletek
Bitműveletekre külön függvények állnak rendelkezésre:
• shl(bits) – előjeles balra eltolás
• shr(bits) – előjeles jobbra eltolás
• ushr(bits) – előjel nélküli jobbra eltolás
• and(bits) – bitenkénti ÉS
• or(bits) – bitenkénti VAGY
• xor(bits) – bitenkénti KIZÁRÓ VAGY
• inv() – bitenkénti ÁTFORDÍTÁS.
2.5.8 Tömbök
Tömbök létrehozására az arrayOf függvény használható a deklarációkban. Az egyes típusokhoz külön függvénynév tartozik, tehát például ByteArray, IntArray.
Lehetőség van a tömbelemeket a deklaráció során közvetlenül is megadni.
Példák:
// 5 elemű tömb, csupa 0 értékkel feltöltve
val arr = IntArray(5)
// 3 elemű tömb, közvetlen értékadásal a deklarációban
val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]
A [] jelekkel, valamint tömbindexekkel hivatkozhatunk az egyes tömbelemekre.
2.6 Elágazási szerkezetek
Az if..else, else if feltételvizsgálatok elérhetőek Kotlinban is:
if (feltétel) utasítás1
else if (feltétel) utasítás2
else utasítás3
A klasszikus switch – case szerkezet helyett Kotlinban a when áll rendelkezésre:
when(valtozo) {
1 -> utasítás1
fuggveny(1) -> utasítás2
in 10..20 -> utasítás3
else -> utasítás4
}
Mint a fenti példában látható, az egyes értékeknek lehetnek dinamikusak is, például egy függvényhívás eredményei.
2.7 Ciklusok
A while, do..while, valamint for ciklusok szintén rendelkezésre állnak. A for Kotlinban bármilyen objektumon végig tud iterálni, ami rendelkezik egy iterator függvénnyel.
Álalános formája:
for( ciklusvaltozo in elemlista )
{
// utasítasok
}
A while és a do..while szerkezetek a Java/C szintaktikának megfelelően használhatóak:
while (feltétel)
{
utasítások
}
do
{
utasítások
} while (feltétel)
A break, return, continue kulcsszavak szintén rendelkezésre állnak.
2.8 Metódusok, függvények
Függvényeket a fun kulcsszóval deklarálhatunk, majd zárójelben utána a paraméterlistát kell megadnunk (opcionális), rögtön ezután pedig a visszatérési érték típusát (opcionális).
Általános formában:
fun (valtozo1 : Int, valtozo2 : String) : boolean
{
utasítások;
return false;
}
A függvények visszatérési értékét a return kulcsszó után adhatjuk meg.
2.9 Osztályok, metódusok
Osztályokat a class kulcsszóval definiálhatunk. Minden osztály automatikusan rendelkezik egy ún. elsődleges konstruktorral, ami az osztály létrehozásakor végrehajtódik. A gyakorlatban ez az osztály legfelső szintű változóit jelenti.
Amennyiben komplex inicializálást szeretnénk végrehajtatni, úgy az init kulcsszóval ellátott kódblokkban adhatjuk meg ezeket.
Általános alakban:
class sajat_osztaly (valtozo : Int)
{
// osztályváltozók: konstruktor
init
{
// inicializálás: „komplex” konstruktor
}
public metodus1 ()
{
//osztály metódusa
}
}
Az osztály példányosításához az osztály nevét kell használni, mintha csak egy függvényt hívnánk meg.
Például így:
val osztalypeldany = sajat_osztaly();
Az osztály objektumok támogatják az öröklődést és a felülírást, ezekre a későbbi fejezetekben láthatunk majd pár konkrét példát.
2.10 Csomagok
Több osztály együtesét csomagnak, másnéven package-nek nevezik Kotlinban. Egy csomag külön forrásfájl is egyben, melyet az import kulcsszóval tudunk elérhetővé tenni forráskódjainkban. Az import megadásakor tulajdonképpen mappákra is hivatkozunk egyben.
Csomagokat magunk is készíthetünk és így egy nagyon hatékony programozási eszközhöz jutunk. A forrásfájl elejére ehhez a package kulcsszót kell írnunk. Fontos, hogy a fájl neve megegyezzen a package nevével, például az alábbi csomagfájl neve kötelezően TUTICSOMAG.KT.
package sajatosztaly.tuticsomag;
private var top_level_valtozo : Int = 0
public class muvelet(parameter : Int)
{
private var belso_valtozo : Int = 5
init
{
valtozo = 0
}
public erteknoveles
{
++valtozo
}
}
2.11 Láthatóság, hozzáférés
A változók és függvények láthatósága, hozzáférhetősége szabályozható (és szabályozni is kell). Erre speciális kulcsszavak állnak rendelkezésre:
public: bárhonnan az alkalmazásban.
private: csak az adott osztályban (osztálypéldányokban), ill. package-ben.
protected: csak az osztályban, vagy annak alosztályaiban.
internal: csak az adott modulon belül.
2.12 Alkalmazás bezárása
Nagyon egyszerű, de valós igény az alkalmazásaink programból történő bezárása.
Ezt nagyon egyszerűen megtehetjük a következő utasítással:
exitProcess(0)
3 Ismerkedés az Android Studioval
A Google hivatalos fejlesztőeszköze Android vonatkozásában az Android Studio, mely IntelliJ IDEA fejlesztőrendszeren alapul.
A fejlesztőeszköz üzembehelyezésének, ill. alapvető kezelésének az ismerete elengedhetetlen, ha érdemi munkát szeretnénk végezni.
Ez a leírás a legfrissebb, 3.6.3-as verziószámú Android Studio üzembe helyezését mutatja be.
3.1 Telepítés, konfigurálás
Az Android Studio-t az alábbi weboldalról tudjuk letölteni:
https://developer.android.com/studio
Bár többféle telepítési mód is elérhető, érdemes az interaktív telepítővel szerelt változatot választani.
Window operációs rendszeren az alábbihoz hasonló konfigurációval érdemes belevágnunk a munkába:
• Microsoft® Windows® 10 (64-bit)
• 8 GB RAM
• 20 GB lemezterület
• 1920 x 1080 képernyőfelbontás.
Amennyiben szerényebb konfigurációval rendelkezünk, előfordulhat, hogy komoly kompromisszumokra kényszerülünk. Elsősorban a rendszermemóriára érdemes koncentrálni.
A telepítőkészlet letöltését a „DOWNLOAD ANDROID STUDIO” gombra kattintva kezdeményezhetjük.
A tényleges letöltés a liszenszszerződés elfogadása után lehetséges.
A telepítő üdvözlőképernyőjén kattinstunk a ’Next’ gombra!
A következő oldalon az alapértelmezett beállításokat érdemes használni.
A következő lépésekben az alapértelmezett telepítési útvonal, Start menü bejegyzés is maradhat. Ezt követően kezdődik meg a telepítés, melynek végén a ’Finish’ gombra kell kattintani. Ezután elindíthatjuk a fejlesztőrendszert.
Amennyiben korábban lett volna telepítve Android Studio a rendszerünkön, akkor az ekkor felugró ablakban kezdeményezhetnénk a korábbi beállítások átvételét, de ettől most eltekinthetünk.
Ezután egy beállítás varázsló fogad minket. Kattintsunk a ’Next’ gombra!
Válasszuk a standard beállítási módot!
Ezt követően mindenki ízlésének megfelelően kiválaszthatja, hogy sötét, vagy világos háttérszínű kezelőfelületet szeretne.
A következő oldalon a ’Finish’ gombra kattintva újabb telepítési műveletre kell rábólintanunk. Több-kevesebb idő után az Android Studio tulajdonképpeni kezdőképernyője fogad.
Mielőtt fejest ugornánk egy új projektbe, ajánlott további beállításokat eszközölni, az ablak jobb alsó sarkában található ’Configure’ gombra kattintva.
Az ún. SDK Manager és az AVD Manager beállítását is el kell ugyanis végeznünk ahhoz, hogy érdemi munkát végezhessünk.
Alapértelmezetten már települt is a legfrissebb, 10-es SDK, azonban megfontolandó lehet egy korábbi verziójú telepítése is. Ezt itt végezhetjük el a későbbiekben is, ha szükségünk van rá.
Az AVD Manager az ún. Android Virtual Device Manager rövidítése, mely lehetővé teszi, hogy fizikai eszköz nélkül tesztelhessük alkalmazásunkat egy emulált, de teljesértékű virtuális eszközön.
Új eszközt a ’Create Virtual Device’ gombra kattintva tudunk létrehozni.
Az első beállításképernyőn ki kell választanunk a virtuális eszköz típusát. Ennek elsősorban a képernyőméret és a pixelsűrűség szempontjából van jelentősége.
Sokkal fontosabb az ún. rendszerkép (system image) telepítése, nélküle ugyanis nem tudjuk kipróbálni a fejlesztés alatt álló alkalmazásainkat. Fontos, hogy az előzőekben telepített SDK-hoz passzoló rendszerképpel rendelkező virtuális eszközünk is legyen!
A rendszerképek mérete tetemes, akár 10GB fölötti is lehet. miután befejeződött a rendszerkép letöltése és telepítése, eltűnik mellőle a ’Download’ címke és immár ténylegesen kiválaszthatóvá válik.
Ezután mégegyszer meg kell erősítenünk a virtuális eszközünk beállításait.
A virtuális eszközeinket az alábbi ablakból menedzselhetjük majd a későbbiekben.
Visszatérve ezután az Android Studio kezdőképernyőjére, immár vállasszuk ki a ’Start a new Android Studio project’ lehetőséget!
Ezt követően egy ún. projekt sablont választhatunk ki. A ’No Activity’ lehetőséggel egy teljesen „csupasz” projektet hozhatunk létre, de számos „konzervet” is használhatunk, amivel rengeteg munkát megspórolva kezdhetünk el egy új projektet.
Ismerkedéshez ajánlható az ’Empty Activity’ kiválasztása, amivel egy üres képernyőt és egy „Hello World!” szövegcímkét megjelenítő alkalmazást bővíthetünk igényeink szerint.
Továbbhaladva, a következő konfigurációs képernyőn kell beállítanunk, hogy Kotlin, vagy Java alapon akarunk-e programozni. Válasszuk ki értelemszerűen a Kotlin nyelvet! Ugyanitt választhatunk a telepített cél SDK-k közül is.
Már majdnem végeztünk! A fejlesztőrendszer feltárul a maga teljességében.
Mielőtt azonban pezsgőt bontanánk, vessünk egy pillantást a jobb alsó sarokra! Esetünkben Firebase és Kotlin plugin frissítésekről kaptunk értesítést.
Jobb a békesség, ezért türelmesen telepítsük ilyenkor a frissítéseket!
Adott esetben újra is kell indítanunk a fejlesztőrendszert a frissítések életbe léptetéséhez.
A főablak státuszsorában rengeteg információt találunk az éppen zajló háttérműveletekről. Mielőtt teljes mértékben elkezdhetünk dolgozni, hagyjuk ezeket végigfutni! Pár percig eltarthat, utána viszont már garantáltan olajozottabban fog menni minden.
3.2 Kipróbálás emulátorral
Van egy egyszerű módja annak, hogy kipróbáljuk, minden megfelelően működik-e: virtuális eszközünkön futtatjuk a létrehozott projektet, elvégre is ez egy teljesen működőképes alkalmazás, még ha meglehetősen üreske is.
Ehhez válasszuk ki a zöld ’Futtatás’ gombot a Run menüpont alatt. A lehetőség egy zöld lejátszás ikonként van ábrázolva.
Ekkor több dolog elindul a háttérben. Először is lefordítódik a programkód, majd az Android Studio feltelepíti a virtuális eszközre az alkalmazást.
Ennek során elindul a virtuális eszköz: az operációs rendszer betöltődik, akár egy valódi eszközön. Kisvártatva pedig elindul az alkalmazás is.
Érdemes figyelni az Android Studio státuszsorában megjelenő üzeneteket. Az alkalmazás telepítéséről például az alábbi módon kaphatunk értesítést:
A kipróbálás egyes fázisai láthatóak az alábbi képeken.
3.3 Futtatás valódi eszközön
Amennyiben rendelkezünk egy tényleges Androidot futtató eszközzel, akkor azt számítógépünkhöz csatlakoztatva szintén használhatjuk alkalmazásaink kipróbálására, az Android Studio-ból indítva. Talán mondani sem kell, hogy egy ilyen élmény jelentősen erősíti az ember motivációját is, hiszen egy valódi alkalmazásként jelenik meg programunk.
Ehhez az eszközön aktiválni kell a Fejlesztői beállításokat, ill. az ún. USB hibakeresés funkciót.
A mobileszköz beállításai között keressük meg "A telefonról" nevű részt! Itt keressük meg a „Build szám” listaelemet, majd többször egymás után nyomjuk meg, amíg megjelenik az „Ön mostantól már fejlesztő!”, vagy hasonló üzenet!
Ezután, visszalépve a Beállítások főmenüjébe, elérhetővé válik a "Fejlesztői beállítások” lehetőség, ahol aktiválnunk kell az "USB hibakeresés" beállítást.
Ugyanitt sok más beállítási lehetőséget kiválaszthatunk, melyekkel telefonunkat professzionális módon használhatjuk alkalmazásaink tesztelésére.
Ajánlott engedélyezni a nem hivatalos forrásból származó alkalmazások telepítését is. Ezzel a telefonra esetlegesen felmásolt telepítőcsomagjainkat manuálisan is telepíthtjük.
A mobileszközt ezen a ponton már mindenképpen csatlakoztassuk számítógépünkhöz egy USB kábelen keresztül!
A mobileszközön megjelenik egy párbeszédablak, mely a számítógép és a telefon párosításáról ad tájékoztatást. Ezt engedélyeznünk kell.
Az Android értesítési sávjában megjelenik az "USB hibakereső csatlakoztatva" állapotjelzés.
Közben az Android Studio-ban is megjelenik az ikonsorban, a futtatás gombtól balra látható listában az eszköz neve. Ha már több futtatási lehetőségünk is van, jó tudni, hogy innen gyorsan kiválaszthatjuk a céleszközt, legyen az virtuális, vagy valódi (esetünkben egy régebbi, HOMTOM márkájú eszköz látható).
A Futtatást kiválasztva az alkalmazás ténylegesen feltelepül az eszközre, majd el is indul. Az alkalmazás az eszközön egyébként ezek után is ott marad feltelepítve, tehát a későbbiekben számítógép nélkül is újra kipróbálhatjuk.
3.4 Ismerkedés a kezelőfelülettel
Az Android Studio kezelőfelülete három fő területre osztható:
1. Menüsor, ikonsor és szerkesztőablakok fülei.
2. Navigációs terület, pl. projekt struktúrában.
3. Szerkesztőablakok tartalma.
Alapértelmezetten a leendő alkalmazásunk kezelőfelületének és a főprogramjának a szerkesztőablakaihoz hozzáférést biztosító ablakok lesznek megnyitva.
Előbbi esetén a jobb oldalon található kapcsolókkal váltogathatunk a tisztán grafikus nézet és a kódnézet (XML) között, sőt, akár egymás mellett is megjeleníthetjük őket, (lásd a fenti képernyőképet).
2023-as update:
Az Android Studio legújabb verzióiban (pl. Flamingo) már egy újfajta vizuális szerkesztőeszköz, az ún. Compose is elérhető. A „klasszikus”, View alapú GUI tervezés azonban továbbra is elérhető. Ehhez mindössze egy layout XML fájlt kell létrehoznunk a File – New – XML – Layout XML menüpont segítségével. Az így létrehozott fájlt megnyitva már meg fog jelenni a paletta és a klasszikusabb GUI szerkesztési lehetőségek.
4 Androidos alapfogalmak
Most röviden megismerjük a legfontosabb fogalmakat, melyekre minden referencia és dokumentáció hivatkozik. Ezek ismeretében tudni fogjuk a jövőben, hogy pontosan alkalmazásaink mely részéről esik szó.
4.1 API level
Az API level fogalma az SDK (fejlesztőkészlet) szemszögéből az android verziószámát jelenti. Egy adott verzióhoz többnyire egy meghatározott API szint (angolul: API level) tartozik. Ezzel a fogalommal az SDK-k telepítésekor is szembesülünk. Egyes rendszerfunkciók elérhetősége API szinthez kötött.
4.2 Activity
Az androidos alkalmazások látható része, ha úgy tetszik, felülete az ún. Activity. Egy Activity egy magasszintű építőelem is egyben, mellyel felhasználói felületek hierarchiája építhető fel, de maga az operációs rendszer egyes funkciói is Activity-ken keresztül érhetőek el, ilyen például a fényképező funkció.
Úgy is elképzelhetőek, mint egy köteg papírlap. Minden lap egy képernyőnyi felületet tartalmaz. Több lapot is használhatunk, de egyszerre mindig csak a logikailag „legfelső” aktív és látható.
A fentiekből következik, hogy legalább egy Activity-nek léteznie kell alkalmazásainkban.
4.3 View
Az Activity-k saját belső építőelemei a View-k. Ilyenek a nyomógombok, beviteli mezők stb.
Egyes vezérlőelemek osztályainak importjai a widget elnevezést is tartalmazzák, de ez nem összekeverendő a Widget kisalkalmazások fogalmával.
4.4 A legalapvetőbb projektfájlok
A következő alfejezetekben hivatkozni fogunk olyan fájlokra, melyek segítségével alkalmazásunk legfontosabb beállításait elvégezhetjük:
• engedélyek
• verziószámok
• felület
• alkalmazáslogika.
Az ezen beállításokhoz szükséges fájlokat a bal oldali képen is látható mappákban érhetjük el, ezek a mappák:
• manifests
• java
• res
• Gradle Scripts.
4.5 Alkalmazásengedélyek
Minden androidos alkalmazás rendelkezik egy XML alapú leírással, ami egyebek mellett az alkalmazás engedélyeiről is tárol információkat.
Legalább egy ilyen leírásnak léteznie kell, a neve kötelezően: AndroidManifest.xml (a manifests mappa alatt a projektstruktúrában). Ezt a fájlt az Android Studio-n belül is elérhetjük.
Példa egy manifest állományra, ami azt állítja be, hogy az alkalmazás telepítés után kérjen engedélyt internethozzáféréshez:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.myapplication">
<uses-permission android:name="android.permission.INTERNET"/>
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
Alkalmazásengedélyekből több száz féle létezik, ezek hivatalos listája itt található:
https://developer.android.com/reference/android/Manifest.permission.html
4.6 Minimális Android verzió megadása
A build.gradle állomány (a Gradle Scripts mappa alatt a projektstruktúrában) határozza meg, hogy melyik API level a minimálisan megkövetelt az alkalmazásunkhoz. Ezzel implicit kizárhatunk régebbi Android rendszereket alkalmazásunk elől.
Példa:
android {
...
defaultConfig {
...
minSdkVersion 28
targetSdkVersion 29
}
4.7 Verzió beállítása
Szintén a build.gradle állományban adhatjuk meg az alkalmazásunk verziószámát, amit a felhasználók is látni fognak az alkalmazás telepítésekor. Ezt a VersionName bejegyzésben szerkeszthetjük.
Példa:
android {
...
defaultConfig {
...
versionCode 1
versionName "1.1"
}
4.8 A felhasználói felület leírókódja
Az Activity-k tartalmi leírását a res – layout mappában található activity_main.xml fájl tartalmazza, ami szintén XML alapú. Alább az Empty Activity alapértelmezett lírókódja látható:
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World!"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>
4.9 Az alkalmazáslogika forrásfájlja
A hagyományos értelemben vett forráskódot a java mappában található MainActivity.kt fájl tartalmazza.
Az Empty Activity alapértelmezett sablonkódja:
package com.example.myapplication
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
}
A fenti kód az AppCompatActivity osztályt példányosítja MainActivity néven (előzőleg pedig importálja a hozzá tartozó csomagot), majd az alaposztálynak az alkalmazás indulásakor lefutó onCreate metódusát írja felül oly módon, hogy az egyrészt megpróbálja felhasználni az alkalmazás esetlegesen elmentett korábbi indításainak információit az Activity vonatkozásában (ha volt ilyen), majd aktiválja és előtérbe helyezi a megadott (fő) Activity-t. Ezzel elindítja alkalmazásunkat.
Ezen a ponton megjegyezzük, hogy szokás az androidos alkalmazások ún. életciklusáról beszélni, mely az indítás és a bezárás között többféle lehetséges állapotot különböztet meg. A Függelékben ezt egy ábrán megszemlélhetjük, de ebben a leírásban minden egyszerű szinten van tartva, így ezt nem kell tárgyalnunk a továbbiakban.
Vegyük észre, hogy a fájl egyben a myapplication package-et is deklarálja!
A következő fejezetben megismerkedünk a vezérlőelemek alapszintű kezelésével szerkesztésével, majd elkészítünk egy alkalmazást, ami ilyeneket használ.
5 Egyszerű alkalmazások készítése
Itt az idő ténylegesen belefogni egy alkalmazás elkészítésébe! A legcélszerűbb vezérlőelemekkel kezdeni az ismerkedést, mivel ezek létrehozása, kezelése jól begyakorolható és a sikerélmények előmozdítják a további, akár önállóan végzett felfedezést is.
Mindössze három vezérlőelemmel fogunk megismerkedni: szövegcímke, nyomógomb, beviteli mező.
Létrehozandó alkalmazásunkkal többek között dinamikus tartalmú szöveget fogunk tudni megjeleníteni telefonunk képernyőjén.
5.1 Szövegcímke - TextView
Az alapértelmezett projektünk már tartalmaz egy szövegcímkét, „Hello World!” tartalommal. Ez a vezérlőelem statikus (interaktívan közvetlenül nem szerkeszthető) szövegek megjelenítésére használható.
A kezelőfelület szerkesztőablakában (az activity_main.xml feliratú fül alatt) kattintsunk rá és az egérrel mozgatva helyezzük át a felhasználói felület bal felső sarkába!
A szövegcímke négyzetének valamely sarkát megragadva méretezzük is át!
Ezt követően váltsunk át kódnézetre és közvetlenül a <TextView tag alá írjuk be: android:i
Ekkor a kódszerkesztő automatikusan kilistáz többféle kódkiegészítési javaslatot, melyek közül válasszuk ki (ENTER-rel) az elsőt, az id-t! A teljes sort pedig egészítsük ki erre:
android:id="@+id/myText"
Ezzel egy egyedi azonosítót, egy programkódból hivatkozható nevet adtunk a szövegcímke objektumunknak. Ez tehát egyfajta összekötése a felület leírásának és az alkalmazáslogikának.
Keresük meg ezt a kódrészt:
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
Írjunk be a metódus végére egy sort (vastagon kiemelve):
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
findViewById<TextView>(R.id.myText).text = "Elindult a tanulás!"
}
Látható, hogy a felületleíró XML kódban megadott azonosítóra (myText) itt már közvetlenül hivatkozhattunk a Kotlin kódban.
Ha most elindítjuk az alkalmazást, láthatjuk, hogy a kiírt szöveg már valóban nem a „Hello World!”, hanem: „Elindult a tanulás!”
5.2 Nyomógomb - Button
Most el fogunk helyezni egy nyomógombot is a felhasználói felületen. A cél az, hogy a gombot megnyomva egy másik szöveg íródjon ki a képernyőre.
Váltsunk át a felület szerkesztőablakában Design módra, majd keressük meg a vezérlőelemek liustájából a Button-t!
Ezt ’Common’ csoport alatt találjuk. A gomb elhelyezéséhez jelöljük ki a ’Button’ listaelemet és az egér lenyomva tartásával egyszerűen húzzuk át alkalmazásunk vizuálisan ábrázolt képernyőjére! Íme, a gomb máris létrejött, alapbeállításokkal!
Az alábbi képen az elhelyezés pillanata látható.
A szerkesztőablak ekkor egy piros felkiáltójelet jelenít meg a jobb felső sávban: 
Rákattintva a „Missing Constraints in Constraint.Layout” hibaüzenetet láthatjuk. Ez arra utal, hogy az Activity ún. constraint-alapú elhelyezési módja megköveteli, hogy a nyomógombot is ellássuk azokkal a kis horgonykákkal, amiket a szövegcímkénknél is láthattunk.
Gombunk esetében ezt úgy tudjuk kivitelezni, hogy az egérrel kiválasztjuk a gombot magát.
Ezután „fogd és vidd” módszerrel az összes kis köröcskét fogjuk meg és húzzuk a virtuális képernyőkép széleihez, majd engedjük el őket!
Legalább egy ilyen „lehorgonyzást el kell végeznünk. Ezután a gombot bárhová átmozgathatjuk, ezek a kapcsolódási pontok a helyükön maradnak.
Megjegyezzük, hogy más elemekhez is „hozzáragaszthatjuk vezérlőelemeinket, ezáltal meglehetősen kifinomult elhelyezési viselkedéseket állíthatunk be. A Constraint alapú elrendezés nem az egyetlen, ami Android esetében rendelkezésünkre áll, de számunkra ez is elegendő az ismerkedéshez.
Az alábbi képen a sikeres elhelyezés utáni végállapot látható.
Váltsunk át ugyanitt ismét kódnézetre és az XML leírásban adjunk a nyomógombnak egyedi nevet:
<Button android:id="@+id/myButton"
Jó tudni, hogy vezérlőelemeket közvetlenül XML kóddal is létrehozhatunk, egyszerűen begépelve azokat. A megszállottságon kívül oka lehet ennek az eljárásmódnak, hogy ha valaki gyorsan el akar végezni bizonyos beállításokat az objektumon. Ilyenkor gyorsabb és pontosabb ez a módszer, mint „egerészni”.
Az Android Studio figyelmeztet minket arra is, hogy az objektumaink címkéihez statikus értékeket rendeltünk és azt inkább sztring erőforrásként kellene definiálnunk. Miről van szó?
Lehetőség van arra, hogy az alkalmazásainkban használt szöveges tartalmakat egy különálló XML-alapú, ún. erőforrásfájlban adjuk meg. A programkód így az ezekben megadott értékekre is hivatkozhat, általunk megadott azonosítókon keresztül. Ezeket a definíciókat a res - values - strings.xml fájlban lehet elhelyezni.
Ez a módszer akkor igazán hatékony, ha sok szöveges adatot kell kezelnünk az Activity-kben, vagy ha esetleg több nyelven is elérhető az alkalmazásunk és nem akarjuk minden nyelvre újrafordítani azt.
Nem kell azonban a kardunkba dőlnünk, ha példaprogramunkban ettől eltekintünk, mivel itt csak pár szöveges értéket használunk a saját tanulásunkhoz. Azért nyissuk meg a strings.xml fájlt.
Ezt találjuk benne:
<resources>
<string name="app_name">My Application</string>
</resources>
Az „app_name” tulajdonság az alkalmazásunk nevére utal. Ha a „My Application” értéket átírjuk valami másra, mondjuk „Első alkalmazásom”-ra, akkor az valóban az alkalmazás kijelzett nevét fogja megváltoztatni. Nyugodtan próbáljuk ki!
Tehát az „app_name” erőforrás az alkalmazásnevet befolyásolja. A hivatkozás erre azonban nem az activity_main.xml fájlban van, mint ahogyan talán először feltételeznénk, hanem az androidManifest.xml fájlban:
android:label="@string/app_name"
Ha már a szöveges tartalmakról volt szó, adjunk a gombunknak valamilyen egyedi feliratot: váltsunk át az activity_main.xml kódnézetére és módosítsuk a gomb text tulajdonságát!
android:text="Művelet"
Ezután a MainActivity osztálypéldány onCreate metódusának kódját egészítsük ki az alábbi sorokkal:
findViewById<Button>(R.id.myButton).setOnClickListener() {
myText.text = "Gomb lenyomva!"
}
A fenti kód egy ún. eseménykezelőt állít be, regisztrál a nyomógombunkhoz. Ez egy belső függvénytípus, mely akkor aktiválódik, ha a gombot megnyomják. A fenti művelet megint a szövegcímkét változtatja meg.
Ha készen állunk, nyomban próbáljuk is ki az alkalmazást! A gombot lenyomva megváltozik a felirat szövege. Íme, egy igazi interaktív mobilalkalmazás! Elégedettek lehetünk.
Amolyan pihenésképpen váltsunk át a kezelőfelület Deisgn nézetére, jelöljük ki a nyomógombot és vessünk egy pillantást a megjelenő tulajdonságlistára!
Mint látható, a lista tartalmazza a gomb azonosítóját és a feliratát is.
Számos tulajdonságot módosíthatunk itt anélkül, hogy az XML kódot kellene szerkesztenünk. Ez is egy kényelmes lehetőség, jó tudni róla.
A MainActivity.kt teljes forráskódja ezen a ponton:
package com.example.myapplication
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
findViewById<TextView>(R.id.myText).text = "Elindult a tanulás!"
findViewById<Button>(R.id.myButton).setOnClickListener() {
findViewById<TextView>(R.id.myText).text = "Gomb lenyomva!"
}
}
}
5.2.1 Játékos kód
Hogy kicsit tovább kódolhassunk is, játékosabbá tesszük a példánkat. A gombot minden egyes lenyomás után jobbrább helyezzük, amíg az X koordinátája el nem éri az 500 pixelt. Ennek vizsgálatát egy if feltételvizsgálattal végezzük el. Ilyenkor áthelyezzük a 10. pixelre. A folyamat ezután ismétlődik.
Továbbá kiírjuk, hogy hányszor lett lenyomva eddig a nyomógomb. A számlálást kihelyezzük a kattintas nevű függvénybe. A számlálást egy modulszinten látható változóval oldjuk meg, melynek neve szamlalo.
Alább a MainActivity.kt forráskódja, vastagon jelölve a vonatkozó, újabb kódrészekkel:
package com.example.myapplication
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*
public var szamlalo : Int = 0
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
findViewById<TextView>(R.id.myText).text= "Elindult a tanulás!"
findViewById<Button>(R.id.myButton).setOnClickListener() {
kattintas()
findViewById<TextView>(R.id.myText).text="Gomb lenyomva "+szamlalo.toString()+" alkalommal!"
myButton.x += 50
if (myButton.x > 500) {
myButton.x = 10.0F
}
}
}
}
public fun kattintas()
{
++szamlalo
}
Alább egy kép a „menekülő” nyomógombról:
5.3 Szöveges bevitel - EditText
Végezetül megismerkedünk egy szöveges adatbevitelt lehetővé tevő vezérlővel. A vezérlő a Text – Plain text objektum, melyet helyezzünk el a nyomógomb és a szövegcímke közé! A vezérlő neve myTextEdit legyen, az alapértelmezett tartalmát pedig írjuk át erre: „Írjon ide valamit!”
Alkalmazásunkat úgy módosítjuk, hogy a beviteli mezőbe írt szöveget felhasználjuk a szövegcímkében. Ehhez a nyomógomb eseménykezelő kódját az alábbiak szerint módosítjuk (vastagon kiemelve a változtatást):
findViewById<Button>(R.id.myButton).setOnClickListener() {
kattintas()
findViewById<TextView>(R.id.myText).text= myTextEdit.text.toString() + ", Ön a gombot " + szamlalo.toString() + " alkalommal nyomta le!"
findViewById<Button>(R.id.myButton).x += 50
if (findViewById<Button>(R.id.myButton).x > 500) {
findViewById<Button>(R.id.myButton).x = 10.0F
}
}
A beviteli mező text tulajdonságának tartalmát fogjuk beépíteni a kiírásba, melyet azonban a .toString() metódussal sztringgé kell alakítanunk. A szöveg elkészítését egyszerű ’+’ jelekkel végezzük el.
Noha a kód csak minimális változtatást tartalmaz, egy új vezérlőelem kezelését is sikerült bevonnunk alkalmazásunkba.
Természetesen lehetőség van a beírt szöveg számmá történő konvertálására is, amennyiben az valóban egy szám. Ehhez azonban először egy sztringgé kell átkonvertálni a mező tartalmát, majd ezt a sztringet számmá.
Valahogy így:
var szoveges_alak : String
var szam : int
szoveges_alak = findViewById<TextView>(R.id.myTextEdit).text.toString()
szam = szoveges_alak.toInt()
Ezt követően már tetszőleges módon feldolgozhatjuk a számértéket mint olyat.
6 Alkalmazások publikálása
Egy androidos alkalmazás akkor ér a legtöbbet, ha megosztják másokkal. Hogy teljeskörű legyen ismerkedésünk az Android alapú fejlesztéssel, röviden megnézzük, miként tehetjük elérhetővé alkalmazásainkat a nagyvilág számára.
6.1 Fejlesztői tanúsítvány készítése
Alkalmazásunk telepítőfájljának létrehozásához kötelezően szükségünk lesz egy tanúsítványra, melyet szerencsére az Android Studio segítségével is elkészíthetünk. Ez másrészt véd is minket, hiszen egyfajta digitális aláírásként is funkcionál.
Válasszuk ki a ’Build - Generate Signed Bundle/APK...’ menüpontot!
Itt kapásból két lehetőségünk lesz, attól függően, hogy alkalmazásáruházakon belül, vagy esetleg egyéb úton is szeretnénk elvégezni telepítőcsomagjaink terjesztését.
Maradjunk egyelőre az első lehetőségnél, majd kattintsunk a ’Next’ gombra! A megjelenő párbeszédablakban az aláíró kulcsunkat kezelhetjük.
Kattintsunk most a ’Create new...’ gombra! A ’New Key Store’ feliratú párbeszédablakban a kulcsunkat hozhatjuk létre.
A kötelező mezők:
• Key store path: az ún. kulcstárolónk helye, ami egy .JKS kiteresztésű fájl lesz (nevet is kell adnunk neki). Tehát nem csupán egy könyvtárról van szó!
• Password/Confirm: a key store jelszava.
• Alias: a kulcs szimbolikus neve.
• Password/Confirm: a kulcs jelszava.
• Certificate - First and Last Name: egy név, példának okáért a személynevünk.
A kulcsok kapcsán fontos megemlítenünk, hogy egy alkalmazást mindig csak ugyanazon kulccsal tehetünk közzé a Google Play Áruházban, az alkalmazás közzététele után ennek módosítására már nem lesz lehetőség, pontosabban a Play Áruház meg fogja tagadni az eltérő kulcsú telepítőcsomag közzétételét! Ezért nagyon fontos, hogy vigyázzunk kulcsainkra.
Az OK gombra kattintva visszatérünk az előző, ’Generate Signed Bundle or APK’ párbeszédablakhoz. Az ’Export encrypted key…’ lehetőség bekapcsolva hagyásával a Google fogja tárolni aláíró kulcsunkat. Ettől nyugodtan eltekinthetünk.
Az OK gombra kattintva végezhetjük el az alkalmazásunk telepítőcsomagjának tényleges elkészítését debug (teszt üzemű) és release (éles üzemű) kivitelben.
Az exportálás során az alkalmazásunk projektmappájában az app/debug, vagy app/release alkönyvtárakban találhatjuk meg a telepítőcsomagokat. Ezek Bundle esetén .AAB kiterjesztésű fájlok lesznek.
6.1.1 APK generálása
A klasszikusabb telepítőcsomagok .APK kiterjesztésű fájlok és némileg nagyobb méretűek lehetnek, noha ez nem feltétlenül számottevő. Az APK egy tömörített fájl, melynek tartalmát egy átlagos képességű fájlkezelő programmal is megtekinthetjük, ha kiváncsiak vagyunk rá.
Ehhez a ’Generate Signed Bundle or APK’ párbeszédablak első képernyőjén az APK lehetőséget kell kiválasztanunk. Az egyetlen lényeges különbség az App Bundle készítéséhez képest, hogy az exportálás utolsó lépésénél kétféle aláírási módot választhatunk. Érdemes az alapértelmezett V1-nél maradni.
Az exportálás alapértelmezetten itt is az alkalmazásunk projektmappájában az app/debug, vagy app/release alkönyvtáraiban hozza létre a telepítőcsomagot.
6.2 Feltöltés a Play Áruházba
A Google Play Áruház a legismertebb alkalmazásáruház, ezért érdemes erre fókuszálni, de akár saját weboldalunkon is közzétehetünk alkalmazásokat, nem tilos.
Az alkalmazások közzétételéhez rendelkeznünk kell egy Google fiókkal, praktikusan egy GMAIL fiókkal. Egy egyszeri regisztrációs díj (kb. 25 dollár) kifizetése után ingyenesen, vagy díj ellenében letölthetővé tehetjük alkalmazásainkat. Egy külön erre a célra létrehozott adminisztrációs felületen végezhetjük el az alkalmazásaink közzétételét, ill. frissítését.
Az adminisztrációs felület címe: https://play.google.com/apps/publish/?hl=hu
A bejelentkezőképernyő nagyon hasonlít a GMail bejelentkező oldalához, de itt a Play Áruház adminisztrációs felületére fogunk belépni.
Az ún. Google Play Console felülete lehetővé teszi alkalmazásaink széleskörű menedzselését. Statisztikákat olvashatunk, elemezhetünk, válaszolhatunk felhasználói visszajelzésekre, stb. Új alkalmazást a bejelentkezés utáni kezdőoldalon található „ALKALMAZÁS LÉREHOZÁSA” feliratú gombbal tudunk beregisztrálni.
Alább az adminisztrációs felület egy képernyője látható.
6.2.1 Értékelések kezelése
Alkalmazásaink sikere nagyban függ a felhasználók értékeléseitől, hiszen mi magunk is általában az alapján próbálunk ki egy appot, hogy mit írnak róla mások. Az értékelések egy 1-5-ös skálán terjedő csillagozással, illetve szövegesen zajlanak, nem anoním módon (már ha a felhasználó valós névvel használja regisztrált fiókját).
Fontos, hogy az értékeléseket alkalmazás kiadóként nem tudjuk sem törölni, sem szerkeszteni. Ez bizonyos értelemben kegyetlen dolognak tűnik és sokszor valóban az is. Lehetőségünk van viszont válaszolni az észrevételekre.
A gyakorlatban az értékelések színvonala erősen ingadozik a pozitív és az útszéli/trágár hangvétel között, ezek minden árnyalatában. Ha esetleg ilyennel szembesülnénk, ne vegyük a szívünkre, helyette próbáljuk meg azt kiolvasni belőle, hogy mi lehetett a rendkívül negatív értékelés valódi oka.
6.3 A közzétett alkalmazások utóélete
Remekül hangzik, hogy közzétehetünk alkalmazásokat, de azokat bizony gondoznunk, karbantartanunk is kell. Itt és most nem a trendi agilis agymenések szólamaira kell gondolni, hanem arra, hogy gyakran veszünk észre mi magunk is utólag hibákat az alkalmazásunkban, amiket minél hamarabb ki szeretnénk javítani, továbbá a Google nagyon következetesen frissíti a különböző szabályzatokat, technológiai frissítéseket, melyeket SDK szintjén is le kell követnünk, ha nem akarjuk, hogy a megszabott határidők után korlátozottan, vagy egyáltalán ne legyen elérhető alkalmazásunk.
Ezért rendszeresen karban kell tartani az alkalmazásokat!
7 Függelék
Az alkalmazások életciklusa
Forrás: https://developer.android.com/guide/components/activities/activity-lifecycle