Mivel manapság egyre jobban terjedőben van az Android, köszönhetően az egyre elérhetőbb áron hozzáférhető telefonoknak, egyre több emberben merülhet fel, hogy saját programot hogy is kellhet rá írni... Már elöljáróban elmondanám, hogy nem célom (legalábbis még most) tökéletesen az alapoktól elmondani, hogy is kell programozni. Erre megannyi segítséget lehet találni neten, és ha például Java kezdő anyagot kezdünk tanulni, a dolgokat nagyon nagy részt egy az egyben át lehet venni Android esetében is... Tehát ez a bejegyzés elsősorban azoknak szól, akik tudnak valamilyen szinten programozni, de nem igazán tudják, mire van szükségük az Android esetén... A másik, amit le kell szögezni, hogy nem vagyok nagy programozó, csupán érdeklődök a téma iránt, illetve egyetemen tanultam. Az egyetemi évek során önszorgalomból és tananyag szükségeként összesen legalább 10 nyelvvel megismerkedtem kisebb-nagyobb mélységben, de erősebben összetett programokat még nem írtam, csupán a fejlesztésben vettem némileg részt

Tehát mire is van szükség. Google a barátunk alapon, írjuk be a keresőbe: android development. Egyből elénk tárul az egyik legjobb referencia oldal, amire csak szükségünk lehet, ez a: developer.android.com . Itt minden szükséges információt megkaphatunk az SDK-tól kezdve a Referencia Kézikönyvig...

Annyit tudni kell, hogy a programjaink úgy futnak, mint a Java esetén, csak a köztes kódot nem a Java Virtual Machine (JVM) futtatja a telefonon, hanem egy Dalvik nevű virtuális gép. Ennek ellenére a szintaktika, metodika, minden javarészt megegyezik, csupán más csomagokat kell használni. Tehát a fejlesztés eszközeiben találhatunk ismerősöket.
Először is kell egy jó fejlesztői környezet. A Java technológiák tantárgyamat ugyan NetBeans-ben teljesítettem, az Android mégis az Eclipse-et ajánlja elsődlegesen, így én is áttértem. Természetesen a felület jórészt hasonló, így aki az egyikben otthon van, a másikban sem fog eltévedni.

Tehát kell egy Eclipse: http://www.eclipse.org/downloads/
Innen a Classic illetve a RCP verziót ajánlják elsősorban, így válasszunk azok közül egyet. Ez egy 3.6.1-es Eclipse Helios rendszer lesz, régebbi verziókat fentebb találhatunk.

Ha lejött, szükség lesz az Android SDK-ra: http://dl.google.com/android/android-sdk_r07-windows.zip
Ebben a pillanatban az r07-es verzió a legfrissebb, de a későbbiekben természetesen ez változhat.

Illetve kell még az ADT (Android Development Tools) plugin, ami a : http://dl.google.com/android/ADT-0.9.9.zip címen elérhető

Lehet magából Eclipse-ből is leszedni ezt a plugint, de bizonyos esetekben nekem úgy nem sikerült beüzemelni, így ezt a módszert taglalom.

Mivel ez még egyenlőre egy ismerkedési bejegyzés, nem szedjük le a natív kódot írni használatos NDK-t (Native Development Kit), amire úgyis csak nagyon teljesítmény-igényes kódrészleteknél lenne szükségünk, és egy egész más téma, mint a mostani. Szóval miután ezt is beszereztük, 3 fájlunk van: az r07-es sdk, az eclipse zip-je, és az ADT.

Most csomagoljuk ki az Eclipse zip-jét, az ADT-t csomagoljuk bele az Eclipse könyvtárába (figyelve ugye a helyességre, hogy a features és plugins könyvtárak tartalma helyes helyre kerüljenek). Majd csomagoljuk ki a az SDK-t is (ennek persze már nem kell benne lennie az Eclipse-ben, bárhol lehet)

Indítsuk el az Eclipse-et, és adjuk meg neki a szokásos Default könyvtárat. Ha az ADT-t megfelelő helyre másoltuk, akkor a Window menüpont alatt találunk egy Android SDK and AVD Manager nevű utasítást, amit azonban még nem tudunk elindítani, mert nem találja a program az SDK-t. Adjuk meg neki!

A Window->Preferences menüpontban ha lenyitjuk az Android sorra kattintunk bal oldalon, megadhatjuk az SDK helyét:

Ha ezt OK-val elfogadjuk, már indíthatjuk az AVD managert.

Először az Available Packages-re kattintva pipáljuk ki a megadott címet ( https://dl-ssl.google.com/android/repository/repository.xml), és válasszuk ki, mire van szükségünk, vannak itt platformfüggően SDK-k, példaprogramok, stb. Én biztos ami biztos, mindent leszedtem, de ez persze egyénfüggő... Ha megvan, Install Selected, és Accept-eljük az összes felmerülő kérdést, és várjuk meg, míg minden lejön. Ha mindent leszedünk, a 38 megás SDK könyvtárat mintegy 800 MB-ra hízlalja.

Ha ez megvan, még mindig az AVD manager-ben a Virtual Devices alatt létrehozhatjuk a virtuális készülék(-eink)et.
A New-ra kattintva:
Name: készülék neve
Target: milyen Android legyen rajta
SD kártya mérete
Skin: alapvető felbontása. Ez lehet kézzel megadott, vagy a felsoroltak valamelyike. Pár általános példa: HVGA (fél-vga: 320x480), QVGA (negyed-vga: 320x240), WVGA (széles-vga: 480x800 vagy 480x854).
Android esetén a 320x480-as felbontás (HVGA) a legfőbb általános felbontás, tehát ez a kiindulási alap mindenhol.
Hardver alatt a New-val még hozzáadhatunk olyan elemeket, amiket a virtuális készülékünk tudjon, úgymint QWERTY billentyűzet, trackball, GPS, érintőképernyő, memóriaméret, kamera, gyorsulásmérő, stb... Válogassuk össze a szimulálni kívánt eszközhöz leghasonlóbb értékeket
Ha ez is megvan, Create AVD, és ezzel létre is jött az eszköz. Ezt a rá való kattintással, valamint a Start gomb megnyomásával el is indíthatjuk. Itt a Start során feljön egy ablak, amiben lehetőségünk van nem felbontáshelyesen, hanem mérethelyesen megjeleníteni a képernyőt. Mit is jelent ez? A mobiltelefonok képernyője nagyobb pixelsűrűségű, mint a számítógép monitorai. Az én 1680x1050-es felbontású monitorom 22"-on helyez el ennyi pixelt, míg a telefonom csupán 3"-ra bezsúfolja a 320x480 pixelt. Tehát ha mondjuk egy Galaxy S-t szimulálok, annak a függőleges felbontása 800 pixel, ami majdnem annyi, mint a monitorom 1050-es függőlegese, holott a képernyő sokkal kisebb. Tehát ha azt akarjuk látni, hogy PONTOSAN mekkora lesz az adott eszköz képe, mérethelyesen kell megjelenítenünk. Ha a Start során a Scale Display to real size-ra bökünk, megadhatjuk a telefonunk képátlóját (GT540 esetén legyen 3"), és a monitorunk DPI értékét, amit a legkönnyebben a következő oldalon számíttathatjuk ki:
http://members.ping.de/~sven/dpi.html
Itt megadjuk a felbontást, a monitor képátlóját, és alatta máris írja, hogy mennyi az annyi (itt PPI-ben írja, mindegy hogy DotPerInch vagy PointPerInch). Ez az én monitoromnál 90 DPI, tehát az kerül be a megfelelő helyre. A Launch-al máris indítjuk a készüléket.

Most már van működő virtuális készülékünk, fejlesztői csomagjaink, de még mindig nem írtunk semmit Zárjuk be az AVD managert (a virtuális teló közben bootolhat nyugodtan), és File->New->Project, és válasszuk az Android Projectet

Először meg kell adnunk a Projekt nevét, ez legyen most teszt_01
Create new project in workspace, mivel újat hozunk létre, nem már meglévőt importálunk be.
a Use Default location-t ha nem pipáljuk be, természetesen simán lehet más könyvtárat is megadni a file-jainknak.
Mivel nem már létező példából készítünk projektet, ugorhatunk is a Build Target részre. Itt meg kell adnunk, mire legyen a minimálisan szükséges Android verzió. Ha például valami Live Wallpaper szerűséget szeretnénk írni, akkor 2.1 alá nem mehetünk, de lehetőség szerint maradni kell minél kisebbnél, ami csak elég a programunkhoz.
Application name: a programunk neve, bármi érthető név, például Első Programunk
Package name: a programunkat csomagokba célszerű rendezni, de ennek a felépítése rajtunk áll. Én például a programozási gyakorlásaimat az android.tutorials csomagban gyűjtöttem (magamnak találtam ki, hogy minden, ami ebben a csomagban van, az az általam írt példaprogram), tehát package name-nek adjuk meg mondjuk ezt: android.tutorials.teszt_01
Create Activity: ha be van pipálva, akkor meg kell adnunk egy nevet neki, ezen a néven jön létre automatikusan a programunk belépési pontja. Ezt nevezzük elso_program -nak.
Min SDK version: fentebbről a Build Targetből puskázhatunk, 1.6 esetén ide egy 4-es kerül, míg 2.1 esetén egy 7-es...
Ha kész, akkor Finish!

Ezzel létre is jött az első projektünk, amit a bal oldalon lévő package explorerben szépen le is nyitogathatunk. Ha felmerülne egy olyan probléma, hogy kapunk egy felkiáltó jelet, és lent az a probléma fogad, hogy az R.java file-t nem tudja létrehozni, egyszerűen csak indítsuk újra az Eclipse-ünket, és megjavul. Ehhez azt kell tudni, hogy az R.java file-t nem mi írjuk, hanem a gép generálja folyamatosan. Tehát kész a projektünk, nézzük meg, mit is tartalmaz. Nyissuk le a bal oldalon lévő package explorerben, és kattintsunk kétszer az src-ben lévő, android.tutorials.teszt_01 csomagban található elso_program.java-ra. Ha az android.jar kivételével mindent lenyitogattunk, hasonlót kell látnunk:

Az src tartalmazza az összes forrásfájlt, csomagokba rendezve. Nekünk most egy csomag és 1 file van perpillanat.
A gen-ben van a már említett, generált R.java
Az Android 2.1-update1-ben van az android.jar, amit lenyitva minden elérhető androidos csomagot megnézhetünk (sok van, azért nem nyitottam le). Itt szintén csomagokba rendeződés van, tehát ha valaki mondjuk a telefon GPS koordinátáját akarja megtudni, az ahhoz tartozó függvényt értelemszerűen az android.location csomagban találhatja
A res könyvtárban vannak az erőforrások, amik képek, szöveges információk, valamint a kinézet felépítéséhez szükséges xml-ekből állhatnak. ha a program nagy pixelsűrűségű telefonon fut, akkor automatikusan elsőnek a drawable-hdpi könyvtárban lévő képeket igyekszik használni. Ha közepes dpi-s telefonon, pl GT540, akkor a drawable-mdpi, míg kis képsűrűség esetén a drawable-ldpi könyvtárat nézi. Természetesen ha nincsennek külön képek minden dpi esetére, akkor a hozzá legközelebbit nézi, tehát megtehetjük, hogy mindent az mdpi-be teszünk, ekkor akár hdpi, akár ldpi a telefon, kénytelen az mdpi-t megnyitni, és transzformálni nagyobbra vagy kisebbre. Fontos még tudni, hogy minden képet csak innen tud beolvasni, szóval ide kell rakni a képeket...
A Layout könyvtárban vannak a képernyő felépítéséhez, szerkezetéhez szükséges xml file-ok. Az androidos programok esetén azt, hogy melyik gomb hol legyen, hol legyen felirat, lenyíló menü, milyen tulajdonságokkal bírjon, stb... ezeket mindet xml fájlokban kell megírni. A main.xml-re kattintva duplán, meg is nézhetjük, hogy már az alap programunk is rendelkezik egy LinearLayout kiosztással, amiben csupán egy szöveget megjelenítő TextView van. A TextView a szövegét a layout alatti, Values könyvtárban lévő strings.xml-ben tárolja, itt találhatjuk a programunk nevét tároló stringet is (ez utóbbit nem szabad törölni, tehát az app_name nevű string objektet).

Nah ha már ez is megvan, futtassuk is le a programot: Ctrl-F11 -el lehet futtatni, ekkor rákérdez, hogy miként fusson, legyen Android Application. Mivel már van megnyitva egy virtuális készülékünk, azon fogja elindítani a programot, míg ha nem lenne, akkor indítana egyet a meglévő AVD lehetőségek közül (mivel most csak egyet hoztunk létre, így azt az egyet indítaná). A virtuális gépen láthatjuk is a programunk eredményét, miszerint a program nevét kiírja szövegként.

Annyit tennék még hozzá, hogy ha a project névre (teszt_01, a package explorer legfelső eleme) jobbklikk->properties-t nyomunk, és ott megkeressük a Run/Debug Settings-et, akkor ha már van ott valami (pl teszt_01), vagy ha nincs, akkor a New->android application-nal egyénre szabhatjuk a futtatás paramétereit. Az így felnyíló Edit Configuration Target fülén lehetőség van megadni, hogy melyik AVD-n fusson le, vagy manual-ra is tehetjük, ekkor rákérdez, hogy milyen eszközön fusson. Ha manuálison van, és USB-n át (USB hibaelhárítást bekapcsolva) rákötöttük a telefonunkat a gépre (és minden driver is rendben van), akkor kiválaszthatjuk, hogy közvetlen a telefonon tesztelhessük a programot, ne pedig a virtuális gépen. Ez virtuális vagy valós telefonnál is úgy működik, hogy az Eclipse fordít egy APK-t a programból, ADB-vel átmásolja és feltelepíti a telefonra, majd elindítja. Ilyen szempontból tehát az Eclipse-nek lényegtelen, hogy egy virtuális telefonra, vagy a valós telefonunkra küldi adb-vel az apk fájlt, csak tudja valakinek küldeni. Ezt tesztelhetjük is, hogy ha minden rendben van, akkor az adb programunk (ami amúgy megtalálható az SDK tools mappájában) az adb devices parancs hatására a következő képpel fogad:

itt látható az emulator-5554 nevű virtuális telefon, valamint a szép hosszú kódú, valós telefonunk is. Az itt listázott eszközökre tudja a program küldeni és futtatni az apk fájlt.

Nah összességében ennyit a kezdetekről. Remélem ez alapján bárki fel tudja tenni, ki tudja alakítani az első Androidos fejlesztő-felületét. Innentől már csak programozás tudás, tutor olvasás valamint sok-sok referencia bújás kérdése minden. Apropó referencia: a developer.android.com címen minden megtalálható, egyszerűbb és bonyolultabb példaprogramoktól kezdve a komplett, minden csomag tartalmára kiterjedő függvényleírásig... fontos oldal tehát...

Nos örültem
Üdv
Magnificat (PH fórumon Menthirist)