Szerző Téma: Programozás Androidon (Dalvik VM) - DOS  (Megtekintve 4876 alkalommal)

Nem elérhető Szilárd

  • Emulation Expert
  • Elvetemült
  • *****
  • Hozzászólások: 660
  • Java / C# / Swift Developer
  • Op. Rendszer: OS X / iOS
Programozás Androidon (Dalvik VM) - DOS
« Dátum: 2013 Január 06, 10:08:29 pm »
Sziasztok!

Ebben a topikban néhány lépést szeretnék bemutatni az Android rendszereken történő programozásról Windows-on, ami segíthet az elindulásban mindenki számára.

Először is szükségünk lesz az Eclipse IDE-re, amibe az ADT Plug-in már előre bele van telepítve, tehát nem kell azt manuálisan nekünk megtennünk és az Android SDK-ra (Software Development Kit), amit szintén megtalálhatunk a letöltött *.RAR-ban.
Android SDK with Eclipse IDE included.

Miután letöltöttük és kicsomagoltuk a *.RAR fájlt, utána lépjünk be az eclipse mappába, és indítsuk el az eclipse.exe fájlt.

A program a SplashScreen betöltése után még egy kicsit töltögetni fog, de rögtön ez után már kezdhetjük is a programunk megírását. (Csak egy egyszerű App-ot fogunk elkészíteni, ami egy alap interface-vel rendelkezik.)
Miután teljesen betöltött az IDE, nyomjuk meg az ALT+SHIFT+N billentyűkombinációt és kattintsuk az Android Application Projectre, vagy kattintsuk ki a File->New->Android Application Project menüpontot.

Ha ez megtörtént, akkor felugrik egy ablak, ahova beírhatjuk az App-unk nevét, a projektünk nevét, és a csomag nevét, amiben az App megtalálható.



Töltsük ki például így:
Application Name: HelloWorld (Ez lesz majd később a *.apk fájl neve)
Project Name: HelloWorld (Ez fog megjelenítődni a Project Explorerben a bal oldali oszlopban)
Package Name: com.example.helloworld (Ez pedig a csomagot fogja jelképezni, amit más programok elérhetnek, ha includolod)

Minimum Required SDK-nak én az Android 2.3 (Gingerbread) opciót választottam.
Target SDK-nak az Android 3.2 (Honeycomb) opciót, mert a HTC Flyer-emen ilyen OPRendszer fut.
Compile With-re csak egyetlen opció létezik, Theme-nek pedig válasszunk, amit csak szeretnénk.

Kattintsunk a Nextre, majd a következő dialógusban vegyük ki a pipát a Create custom launcher icon elől. (Ha bent hagyjuk az sem baj, csak akkor nekünk kell kiválasztanunk 1 launcher ikont, de jelenleg elég nekünk a jó öreg Androidos is.)



Menjünk ismételten a Nextre, majd egy Create Activity dialógus fog fogadni minket. (Hacsak nem hagytuk bepipálva a Create custom launcher icont.



Activitynek kiválaszthatjuk a nekünk tetszőt. (Én a FullscreenActivityt választottam.)
Activity Name maradhat FullscreenActivity, vagy ha nagyon szeretnénk, akkor átnevezhetjük például HelloWorldActivity-nek.

Miután végeztünk mindennel, utána neki is láthatunk programunk elkészítésének. Nagyon nagy segítségünkre kaptunk egy vizualizációs eszközt, amely segítségével programunkat teljes valójában láthatjuk, és nem kell külön leprogramozni minden elemet.



Az Eclipse IDE on-the-fly compile-t alkalmaz, ami azt jelenti, hogy nem úgy kell leforgatnunk a projektünket, mint Netbeans IDE esetében, hanem már a kód elmentése után egyből láthatjuk, hogy milyen errorok fogadnának minket, ha indítanánk a programunkat.

Ahhoz, hogy egy Button / Background szövegét módosíthassuk, alul lapfülek segítségével válthatunk az XML és a Graphical Layout között. Az XML-ben láthatjuk azt, hogy mit tartalmaznak a különböző elemek. Vegyük például a Button-unkat, aminek jelen esetben "Dummy Button" a szövege.
Váltsunk át alul az activity_<activity_name>.xml tab-ra, és keressük meg a <Button .... /> tag-et. Itt láthatjuk azt, hogy az android:text mező értéke "@string/dummy_button". Ez csupán annyit takar, hogy a strings.xml tartalmaz egy dummy_button változót, aminek az értéke a "Dummy Button".
Ha szeretnénk megváltoztatni a gomb tartalmát, akkor egyszerűen módosíthatjuk az android:text-et, azonban így Warningot fogunk kapni, amiket jobb ha elkerülünk.

Oldalt a Project Tree-ben nyissuk le a res mappát. Benne található több drawable-XYZ folder, de nekünk a "values" fog kelleni. Ebben van benne a strings.xml fájl.
Kattintsunk rá kétszer, majd ez az ablak fog minket fogadni:



Itt adhatunk hozzá String változókat, vagy vehetünk el, ha esetleg fölöslegesnek találunk néhányat.

Adjunk hozzá mondjuk egy új változót hello_world néven, amelynek azt az értéket adjuk meg, hogy "Hello World!".
Váltsunk át az activity_<activity_name>.xml-re, és módosítsuk az android:text-et így: android:text="@string/hello_world", majd mentsünk egyet.

Így a Button szövege megváltozott Hello World!-re és Warningot sem kaptunk.

Most jöhet a tesztelés. Először is szeretném bemutatni azt, hogy hogyan lehet a saját készülékünkön tesztelni az app-okat. (Talán ez a legjobb, hiszen akkor már éles környezetben láthatjuk programunkat)

Elsősorban be kell dugnunk az eszközünket egy USB-adatkábelen keresztül a gépünk valamelyik portjába. Ha ezzel megvagyunk, akkor magán a telefonon/tableten be kell állítanunk a Beállítások > Alkalmazások > Fejlesztés menüpont alatt (4.0 vagy régebbi Android rendszeren) vagy a Beállítások > Fejlesztői opciók alatt azt, hogy a telefonunk USB Hibakeresés állapotban kapcsolódjon számítógépünkhöz.
Miután be van dugva a készülék, és érzékelte is a rendszerünk, utána töltsük le a legújabb USB Drivert. Ezt eszközünk hivatalos oldalán tehetjük meg. Az alábbi linken megtalálhatjátok összegyűjtve őket:
OEM USB Drivers

Ha mindennel végeztünk, mindent feltelepítettünk, és eszközünk is csatlakoztatva van a géphez, akkor nincs más tennivalónk, mint Run-olni a projektet. Kattintsunk a Project Tree-ben jobb egérgombbal a HelloWorld-ön, majd Run as > Android Application.
Ezt az ablakot kell megkapnunk, ha mindent jól csináltunk (Az alsó táblázatban lévő készülékeknek nem kell ott lennie, azokat már én adtam hozzá):



Ha sikeres volt az előbb elvégzett USB Driver telepítés, akkor elvileg a felső táblázatban meg kell jelennie készülékünknek. (Android verziószámmal együtt)

Kattintsunk az OK-ra, majd a Console fülön megjelenik az output, ami azt fogja írni, hogy a HelloWorld.apk sikeresen települt a rendszerre.

Remélem mindent érthetően írtam le, ha esetleg valami kérdésetek van, akkor azt nyugodtan tegyétek fel! :)

Szilárd
« Utoljára szerkesztve: 2013 Január 10, 11:18:47 pm írta Szilárd »
Java / C# / Swift Programmer

Apple
----------
OS X / iOS User
iPhone 6 Plus
iPad Air 2
MacBook Pro 13" Retina

Nem elérhető Action

  • Adminisztrátor
  • Cube Head
  • *****
  • Hozzászólások: 1235
  • IBF Mester!
  • Op. Rendszer: Windows 8.1
Re:Programozás Androidon (Dalvik VM) - DOS
« Válasz #1 Dátum: 2013 Január 09, 09:15:10 am »
Na ilyenekről még sok jöhet.
Szép leírás, ment a plusz. :)
A WORD elszáll, az írás megmarad.

Nem elérhető Raisen

  • Globális Moderátor
  • Elvetemült
  • *****
  • Hozzászólások: 652
  • bigtorrent.eu
    • http://lithiumwow.eu5.org/index.html
  • Op. Rendszer: Windwos 7 x86
Re:Programozás Androidon (Dalvik VM) - DOS
« Válasz #2 Dátum: 2013 Január 09, 01:18:33 pm »
Szép leírás +1 jöhet még.


▀█▀ █▀▀▄ █▀▀ █▀▀█ ▒█▀▀█ █▀▀█ █▀▀█ █░█ █▀▀█ █▀▀ █▀▀ ░ █░░█ █░░█
▒█░ █░░█ █▀▀ █░░█ ▒█▀▀▄ █▄▄█ █▄▄▀ █▀▄ █▄▄█ █░░ ▀▀█ ▄ █▀▀█ █░░█
▄█▄ ▀░░▀ ▀░░ ▀▀▀▀ ▒█▄▄█ ▀░░▀ ▀░▀▀ ▀░▀ ▀░░▀ ▀▀▀ ▀▀▀ █ ▀░░▀ ░▀▀▀

Nem elérhető Szilárd

  • Emulation Expert
  • Elvetemült
  • *****
  • Hozzászólások: 660
  • Java / C# / Swift Developer
  • Op. Rendszer: OS X / iOS
Re:Programozás Androidon (Dalvik VM) - DOS
« Válasz #3 Dátum: 2013 Január 10, 11:14:29 pm »
Sziasztok!

Szeretnék egy kis bővítést adni az előző posztomhoz. Itt már egy kicsit a Java programozást is szükséges igénybe vennünk. (Java tudás nélkül sajnos lehetetlen az Android Development)

Elsősorban két hasznos linket szeretnék közzétenni, amely elengedhetetlen a programozás során (aki már írt szoftvert az biztos használt már ilyet):
Android Packages
Java Packages

Nagyban hasonlít a kettő, hiszen közös a programnyelv, kizárólag néhány fölösleges rész kivétele, és jó pár saját csomag fűződik az Android Developerek nevéhez, mint módosítás az eredeti Java Packagingen.

Másodsorban azt szeretném még a fő hozzászóláshoz csatolni, hogy hogyan tudjuk programunkat egy virtuális Android Device emulátor segítségével tesztelni, ha esetleg fizikai eszközzel nem rendelkezünk.

Ezt egyszerűen megtehetjük, hiszen az Eclipse nagyon sok féle eszközt kínál fel lehetőségként.

Íme egy kép a használható eszközökről (nem tartalmaz nagyobb cégektől származó készülékeket, kivéve a Galaxy Nexus-t):



Itt jól látható, hogy mennyi féle felbontásban tesztelhetjük applikációnkat egy teljesen jó Android környezetben. (Olyan, mint, ha tényleg egy telefonon ügyködnénk.)

Az emulátor használata egyszerű, csak előtte el kell végeznünk egy kisebb nemű konfigurációt az Eclipse-n.

Lépések:
 1. Nyissuk meg a "Run" menüpont alatt található "Run Configurations..." opciót.
 2. Az itt felugró ablakban vigyük rá egerünket az Android Application lehetőségre, majd itt láthatjuk, hogy miket tehetünk konfigurációinkkal.
 3. Készítsünk egy újat a Configuration Tree fölött található ikonnal, amit az előző lehetőségek között is láthattunk.
 4. Nevezzük át például "HelloWorld"-re, hiszen így tudjuk identifikálni azt később.
 5. Project választásához kattintsunk a Browse... gombra, majd válasszuk ki az aktuális projektünket.
 6. Kattintsunk a Target tabra. (A tabokat a konfigurációs névmező alatt találhatod meg.)
 7. Két lehetőség közül érdemes választani, hiszen nem biztos, hogy mindig lesz egy Active Device a géphez csatlakoztatva, tehát a javasolt opciók:
   a) Always prompt to pick device
      Ezt tartom a legkézenfekvőbbnek, hiszen így mindig manuálisan választhatjuk a megfelelő emulátort, nem egy konstans készülék lesz az, amin mindig leteszteljük a programunkat.
   b) Automatically pick compatible device: Always uses preferred AVD if set below, launches on compatible device/AVD otherwise.
      Ez is egy jó opció, ha kizárólag egy eszközre szeretnénk fókuszálni (ez nem jelenti azt, hogy nem lehet több készüléket adni a listához, amiken tesztelhetünk).
      b/1)
         Ha emellett döntünk, akkor kattintsunk a Radio Button-ra, majd a jobb oldali menüben a Manager... gombra.
         Mivel alapvetően nem található készülék a listában, ezért nekünk hozzá kell adnunk az alap készülékbázisunkból.
      b/2)
         AVD Name-nek beállíthatjuk például azt, hogy QVGA, majd válasszuk ki a 2.7 inches QVGA készüléket. (Legutolsó a listában)
         Én minden más mezőt az alapértelmezett értéken hagyok, hiszen ez csak egy egyzerű HelloWorld app, amihez nem szükséges a kamera tesztje, RAM mennyiséget, etc...
      
      Ezzel készen is van a készülékünk hozzáadása a listához.
 8. Miután kiléptünk az ablakokból és eljutottunk egészen addig, hogy csak a Run Configurations dialógus álljon előttünk nincs más teendőnk, mint, hogy megnyomjuk a Run gombot.
 9. Ha 7/a) opciót választottuk, akkor felugrik egy dialógus, ami megkérdezi tőlünk, hogy melyik eszközön emulálja az appunkat.
   Válasszuk ki a QVGA-t, majd nyomjunk meg az OK-ot.
 10. Ha a 7/b) opciót választottuk, akkor az Eclipse már neki is lát az app emulálásához, a beállított eszközön.
 11. Miután feljött az emulátor, nyomjunk rá a bekapcsológombra.
 
Ha mindent jól csináltunk, akkor egy ilyen képet kell, hogy kapjunk:



Megvárjuk, míg betölt a szoftver, és már kezdhetjük is a programunk tesztelését "félig-élesben". :D

===========================

ActionListenerek lényege, használata, elkészítése
Példa a HelloWorld.apk-n keresztül bemutatva

===========================

Az ActionListenerek végzik el a gomb lenyomása után elvárt tevékenységeket.
Használatuk elengedhetetlen egy program megírása során, hiszen minden lényeges funkciót a segítégével végezhetünk el, válthatunk vele a különböző oldalak között, frissíthetjük programunkat, stb.

Egy általános példa:
Gomb lenyomása > ActionListener meghívása > Funkció elvégzése

Nagyjából egy általános Java kód esetében ez így néz ki:
Kód: (java) [Kijelölés]
// Ez csak egy kodreszlet...
Button button = new JButton("Click me!");
button.addActionListener(new ActionListener(){
@Override
public void actionPerformed(ActionEvent event){
System.out.println("Ouch! It hurts.");
}
});

A kód egyszerű, hiszen látható, hogy a példányosított ActionListener osztályból meghívtunk egy absztrakt metódust, amit minden esetben felül kell írnunk. (@Override)
A függvénynek meg kell egyeznie az ActionListener osztályban szereplő actionPerformed függvénnyel, nem lehet eltérés sem paramtérekeben, sem visibility-ben (public,private,protected).

A függvény belsejében pedig lejátszódik a System.out.println folyamat, ami ugyebár egy egyszerű konzolra való kiírás.

Androidon kicsit másképpen néz ki egy Listener elkészítése, hiszen itt nem ActionListener a neve, hanem OnClickListener.
Kód: (java) [Kijelölés]
// Ez csak egy kodreszlet...
protected void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_fullscreen);

...

findViewById(R.id.dummy_button).setOnClickListener(mClickListener);
}

View.OnClickListener mClickListener = new View.OnClickListener(){
@Override
public void onClick(View v) {
int randInt = new Random().nextInt(2);
int[] colors = new int[2];
colors[0] = Color.BLACK;
colors[1] = Color.WHITE;

findViewById(R.id.fullscreen_content).setBackgroundColor(colors[randInt]);
}
};

A fenti kódrészletben is látható, hogy nem sokban különbözik a kettő egymástól, hiszen itt a View osztályon belül található OnClickListener nested-class fogja elvégezni a gomb lenyomásához tartozó metódust.

Itt a funkció egyszerű, hiszen a "dummy_button" lenyomására megváltozik a fullscreen_content background colorja, mégpedig egy random színre, amelyet a colors[] tömbből fogunk kiválasztani.

Remélem sikerült érdemlegeset mutatnom számotokra.

Szilárd
« Utoljára szerkesztve: 2013 Január 10, 11:17:20 pm írta Szilárd »
Java / C# / Swift Programmer

Apple
----------
OS X / iOS User
iPhone 6 Plus
iPad Air 2
MacBook Pro 13" Retina

Nem elérhető Szilárd

  • Emulation Expert
  • Elvetemült
  • *****
  • Hozzászólások: 660
  • Java / C# / Swift Developer
  • Op. Rendszer: OS X / iOS
Re:Programozás Androidon (Dalvik VM) - DOS
« Válasz #4 Dátum: 2014 Január 04, 07:17:52 pm »
Üdv mindenkinek ismét!

Régen nem szóltam már hozzá ehhez a témához, ugyanis nagyon sok más dolog volt, ami sajnos fontosabb volt ennél, de most újra kedvet kaptam hozzá, és folytatnám az egyszerűbb tutorialok írását, amik segíthetnek az alapoktól indulni.

Készítsünk el egy olyan egyszerű applikációt, ami már képes valamilyen művelet elvégzésére.
A legjobb, amit egyszerűen és gyorsan elkészíthetünk, az egy mértékegység váltó program.
Én a példámban két mértékegységgel fogom szemléltetni a programot: Celsius fok és Fahrenheit fok.

Az átváltási formula lényegében nagyon egyszerű (Celsius = c, Fahrenheit = f értelemszerűen):

f = c * 9 / 5 + 32
c = (f - 32) * 5 / 9

Az utóbbinál rendkívül fontos a helyes eredmény miatt a műveleti sorrend, tehát a zárójelet ne hagyjuk le!

Az alap forrásfájl:
A forrásfájlunk neve az, amit korábban az Activity neveként megadtunk, tehát, ha a projekt elkészítésénél mi megadtuk a "MainActivity" nevet, akkor a forrásfájl jelen esetben MainActivity.java kell, hogy legyen.
Tegyük fel, hogy egy BlankActivity-t készítettünk el, ahol a forrásfájlunk így kell, hogy kinézzen:
Kód: (java) [Kijelölés]
package <valamilyen csomag név>;

import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;

public class MainActivity extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}

@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;
}

}

Folytassuk a függvényekkel:

Ehhez ugye már egyből látható, hogy szükség lesz két függvényre. Az egyik celsius-ból fahrenheit-be vált, míg a másik fordítva.

Kezeljük "double" típusú változóként a visszatérési értékeket, hiszen nem feltétlenül lesz egész szám az, amit eredményül kapunk.
Így teszünk a paraméterrel is, a függvényünk "double" típusú paramétert fog várni.

Kód: (java) [Kijelölés]
public double celsiusToFahrenheit(double celsius)
{
// Celsius -> Fahrenheit
// f = c * 9 / 5 + 32
return celsius * 9 / 5 + 32;
}

public double fahrenheitToCelsius(double fahrenheit)
{
// Fahrenheit -> Celsius
// c = (f - 32) * 5 / 9
return (fahrenheit - 32) * 5 / 9;
}

A fentebb megírt függvényeket most be kell illesztenünk a forrásfájlunkba, hogy később alkalmazhassuk majd őket.
Illesszük be az "onCreateOptionsMenu" függvény után mindkét függvényt.

Ha ezt megtettük, akkor kattintsunk rá a bal oldali "Fájl böngészőben" a projekten belüli "res/layout/activity_main.xml" fájlra.
Ezen az XML fájlon belül módosíthatjuk a grafikus felületet, hiszen az Eclipse IDE lehetőséget ad arra, hogy mi, saját magunk módosítsuk kézzel a Graphical Layoutot.
Alapvetően az Activity elkészítése után egy RelativeLayout-ot kapunk, ami esetünkben nagyon könnyű kezelést ad a bizonyos interfész elemek elhelyezéséhez.

Csináljunk meg egy szimpla kis UI-t, ami elegendő lesz az átváltáshoz.
Elsősorban képzeljük el úgy az interfészt, hogy tartalmaz:
   - 1 db Text Fields mappán belül található Numbers (Decimal) / Numbers (Signed) elemet, ami majd várni fogja inputként az átváltani kívánt számot.
   - 1 db Form Widgets mappán belül található Radio Group elemet, ami lehetővé teszi a konverzió kiválasztását.
   - 1 db Form Widgets mappán belül található Button element, amire koppintva a felhasználó utasíthatja az applikációt arra, hogy váltsa át a számot.
   
A fentebb említett mappákat ezen a képen láthatjátok: http://i.imgur.com/3S4TIbx.png

Az elemeket külön-külön saját ízlésünknek megfelelően helyezhetjük a képernyőre. Én ezt valahogy így tettem meg: http://i.imgur.com/co1t5Oz.png
Az én képemen már módosítva vannak a szövegek, de azt még nem tettük meg, így legyen ez a következő lépés.

Ehhez szükség van ahhoz, hogy megnyissuk ezt a fájlt: "res/values/string.xml"
Nekem ennek a tartalma így néz ki:
Kód: (xml) [Kijelölés]
<?xml version="1.0" encoding="utf-8"?>
<resources>

    <string name="app_name">Value Converter</string>
    <string name="action_settings">Settings</string>
    <string name="desc_celsius">To Celsius</string>
    <string name="desc_fahrenheit">To Fahrenheit</string>
    <string name="desc_valuefield">Enter value to convert</string>
    <string name="convert_button_txt">Convert</string>

</resources>

Azért van a sztringek íly módú megadására, mert különben Warningokat kapunk, amelyeket jobb fixálni, hiszen nem hiába figyelmeztet érte a compiler.

Később a sztringeket úgy használhatjuk, hogy referenciaként alkalmazzuk őket, méghozzá így: @string/<sztring_neve> (Például: @string/desc_celsius)

Térjünk vissza az "activity_main.xml" fájlunknak a Graphical Layout tabjához. Kattintsunk rá a már elhelyezett elemekre jobb egérgombbal, majd kattintsunk az Edit ID... opcióra.
Adjunk az elemnek megfelelő azonosítót, például a gombunknak "converterButton" ID-t, a szövegmezőnek "inputField" ID-t, és így tovább. Ezeket azért változtassuk meg így, hogy később tudjuk a forráskódban való alkalmazáskor, hogy melyiket is használjuk éppen.
Miután ezen túlvagyunk, váltsunk vissza a forrásfájlunkra.

Készítsünk egy OnClickListener-t a gombunknak, ahogy azt az előző posztomban bemutattam. Ebben a posztban kizárólag a függvény kitöltését mutatom majd be.

Lényegében ez a Listener fog mindent elvégezni, amire szükségünk van. A saját ID-imet használom a példa során, szóval ott kell változtatni csak a függvényen.
Kód: (java) [Kijelölés]
OnClickListener convertButtonListener = new OnClickListener()
{

@Override
public void onClick(View arg0)
{
// Ez lesz a hibakodunk.
final double errno = 0.0001;

// Deklaraljuk az input fieldet EditText-kent, hogy kesobb hasznalhassuk a fuggvenyeit.
EditText input = (EditText) findViewById(R.id.inputField);
// Igy teszunk a radio buttonokkal is.
RadioButton celsiusRadio = (RadioButton) findViewById(R.id.toCelsiusButton);
RadioButton fahrenhRadio = (RadioButton) findViewById(R.id.toFahrenheitButton);

// Ez majd kesobb a ket tizedesjegyre valo kerekitesnel lesz fontos.
DecimalFormat df = new DecimalFormat("#.##");

// Kezeljuk a modositas elotti szoveget, majd felosztjuk "space-nkent". (Fontos lesz, hiszen igy tudjuk elszeparalni a szamokat a szovegtol)
String[] gotText1 = input.getText().toString().split(" ");
// Az elozo felosztott sztring tomb elso elemet kezeljuk, hiszen annak kell a szamnak lennie, majd a benne szereplo "," karaktereket "." karakterekre csereljuk a crash elkerulese vegett.
String valueToParse = gotText1[0].replace(',', '.');

// Bevezetunk egy double tipusu number valtozot, ami majd kesobb az inputban kapott fokot fogja tartalmazni.
double number;

// Fontos, hogy egy try-catch blokkba helyezzuk a parse-t, hiszen ha rossz inputot kapunk, akkor ez segit elkerulni a program crasheleset.
try
{
// Elvegezzuk a sztring double-le torteno konvertalasat.
number = Double.parseDouble(valueToParse);
}
catch (NumberFormatException exc)
{
// Beallitjuk a hibakodot a number valtozo ertekenek.
number = errno;
}

// Ha a number megegyezik a hibakoddal, akkor az input tartalmat megvaltoztatjuk. (Fontos, hogy nem a "setText", hanem a "setHint" fuggvenyt kell hasznalnunk.)
if (number == errno)
{
input.setHint("Invalid number");

return;
}

// Itt kezeljuk azt, hogy melyik radio button van kivalaszta, hiszen az alapjan fogunk cselekedni.
if (celsiusRadio.isChecked())
{
// \u00B0 - Unicode (°)
input.setText(df.format(fahrenheitToCelsius(number)) + " \u00B0C");
}
else
{
// \u00B0 - Unicode (°)
input.setText(df.format(celsiusToFahrenheit(number)) + " \u00B0F");
}

/**********************************/
// Innentol csak egy kis esztetikai megoldas fog kovetkezni.
// Ha atvaltunk Celsiusbol Fahrenheitbe, akkor a radio button a Celsius-ra fog valtani, es forditva.

// Kezeljuk a modositas utani szoveget, majd ezt is felosztjuk.
String[] gotText2 = input.getText().toString().split(" ");

if (gotText2.length > 1)
{
// Most a mertekegyseget fogjuk kezelni, hiszen ez alapjan valtogatjuk a radio buttonok kivalasztasat.
String unit = gotText2[1];

if (unit.contains("C"))
{
fahrenhRadio.setChecked(true);
}
else if (unit.contains("F"))
{
celsiusRadio.setChecked(true);
}
}
}
};

Az onCreate függvényen belül, amit a forráskód elején találhatunk adjunk hozzá egy új sort, amivel deklarálunk egy "Button" típusú változót, azonban ehhez majd castolnunk kell az értékét az alábbi példa szerint:
Majd hozzácsatoljuk a Listenert a gombhoz, és készen is vagyunk.
Kód: (java) [Kijelölés]
// Itt lathatjuk, hogy az elobb megadott ID-t kell hasznalnunk majd, vagy az eredetit, ha esetleg nem modositottunk.
Button convertButton = (Button) findViewById(R.id.converterButton);
convertButton.setOnClickListener(convertButtonListener);

Ezzel készen is van az egyszerű kis applikációnk. Ha minden igaz, akkor a forráskód mentésre egyből lefordul *.apk fájlba, de, ha ez nincs beállítva, akkor megtehetjük így:
 Window > Preferences
  - Android > Build
   - Skip packaging and dexing until export or launch.
   
Itt vegyük ki a pipát az opció elől, majd Apply és OK.
Ezek után mentsük a forrást, majd a projekteden belül a "bin" mappában található majd a "projekt_neve.apk" fájlod.

Remélem segítettem ezzel a kis tutoriallal nektek, ha valami nem érthető, akkor nyugodtan írjátok.

Szilárd

EDIT:
Kipótolnám azzal, hogy milyen is ez működés közben.
http://i.imgur.com/eDkkiEm.png
Ezen a linken tekinthető meg.
« Utoljára szerkesztve: 2014 Január 04, 07:32:41 pm írta Szilárd »
Java / C# / Swift Programmer

Apple
----------
OS X / iOS User
iPhone 6 Plus
iPad Air 2
MacBook Pro 13" Retina

 

Sitemap 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29