A következő szociális oldal API, aminek nekiálltam a LinkedIn , azon belül is a Sparkle.LinkedIn nevű API. Az API beszerezhető a https://github.com/SparkleNetworks/LinkedInNET oldalról, vagy a Visual Studióban, a Nuget csomagkezelőn keresztül az Install-Package Sparkle.LinkedInNET parancs futtatásával. Egy alap dokumentációt, ami a REST API, és OAuth részeket nagyjából lefedi a https://developer.linkedin.com/docs címen érhetjük el. Ezek segítségével valósítottam meg a kis kód részletet, amellyel felhasználói adatokat tudtam lekérdezni a LinkedIn oldaláról.
Category Archives: SZTE
Kérdőív feldolgozó rendszer #4: Beüzemelés & négyzetek és válaszok felismerése
EmguCV használata a projektben
Legkönnyebben: NuGet-tel le lehet tölteni, bár a frissítés dátuma alapján, nem egy friss változat, közel fél évvel le van maradva a hivatalos kiadástól. (Changelog-ok alapján nekem ez is megfelel.)
NuGet-tel: Install-Package EmguCV, az alábbi package-ek lesznek még hozzáadva a projekthez: ZedGraph és OpenTK. Az EmguCV részéről pedig három fájl:Emgu.CV.UI.dll, Emgu.CV.UI.GL.dll, Emgu.CV.World.dll.
Add Reference-féle importálásnál pedig a fent már említett három fájlt beimportáljuk, illetve célszerű a ZedGraph-ot is mellékelni.
Képfelismerés
A programozás a Visual Studio 2015-ben, C# nyelvben történt. A példaprogram jelenleg felismeri a négyzeteket, kigyomlálja azokat, amelyeket esetleg kétszer ismert fel. (Például ha vastag a vonal vagy rossz minőségű a kép.) A kód nagy része a hivatalos példából származik, de jónéhány változtatást eszközöltem rajta.
A program bal oldali képdobozában az eredeti, feldolgozásra váró kép jelenik meg. Ezután az Elemzés gombra kattintva megjelennek a program által talált négyzetek a jobb oldali dobozban.
Jobb oldali TextBoxban pedig az algoritmusom munkája látszik, megnézi, hogy a négyzetek közül melyek vannak bejelölve, illetve kiírja a négyzetek középpontjainak a koordinátáit. Amennyiben be van jelölve egy opció, akkor a válaszhoz tartozó négyzetet nem látja a képfelismerő, ahogy az a következő példán is látszik:
Továbbá már az érvénytelen választ (itt: egynél több van bejelölve) is képes kezelni. A válaszok kezelése (mi van bejelölve és mi nincs) lista segítségével van megvalósítva.
A négyzetfelismerést kipróbáltam létező kérdőíven is, mely kiváló eredményt hozott.
Kérdőív feldolgozó rendszer #3: Követelményrendszer & hibás válaszok
Tervezett főbb funkciók listája (2016. december)
Szakdolgozat II befejezésére:
- App:
Kérdőív válaszok felismerése
Kérdőív szöveges részeinek felismerése és kivágása (személyes adatok, szöveges mezők)
Kivágott szöveges részek rendezése
Adatok mentése adatbázisba (képeknek a fájlneve)
Sql szerver konfigurálhatóság
Több fajta adatbázis támogatása
Képek tárolóból beolvasása
Alapvető OCR-funkciók implementálása - SQL szerver:
Segítség a letöltéshez és/vagy a csomag tartalmaz egy telepítőt
Silent telepítés
Alapvető hibaelhárítás (tudok-e csatlakozni, jó-e az user/pass) - Kimutatást készítő modul
Diagram, kis leírás (sablonozható) - Kézírást felvivő modul
Login/névbeállító ablak, hogy látható legyen ki fért hozzá az adatokhoz
Egyszerű egy ablakos alkalmazás, melyben megjelenik a kivágott kép
Kép nagyítható, kicsinyíthető, fekete-fehérre váltható
Szövegbeviteli mező a válaszhoz
Opcionális funkciók
- Azure integráció (storage elérés, nem VM-ben való futtatás esetén)
- Active Directory támogatás
- .NET Core támogatás – Linuxon futtatás
Javítások kitöltés közben, hibakezelés
Sokakkal előfordult – velem is -, hogy kitöltés közben elkalandozott, vagy félrecsúszott a keze és rossz opciót jelölt be. Mivel a programot fel kell készíteni az összes lehetséges helyzetre, így erre is. Az általam látott kérdőívek többségénél az volt látható, hogy a véletlenül bejelölt választ egyszerűen csak lesatírozták, aztán a jót pedig nyilvánvalóan x-szel jelölték. Emiatt nekem az fordult meg a fejemben, hogy ha egy sorban az x adható válasz helyett x+n választ adtak, akkor össze kell hasonlítani a bejelölt válaszokat, az alábbi módon:
Algoritmus megtalálja a négyzeteket, azokat kivágja, majd összehasonlítja a kettőt, amelyikben több nem fehér (vagy háttérszín) pixel van, az lesz a kérdésre adott válasz.
Hibakezelés fontos dolog lesz, hiszen a hiányosan kitöltött kérdőíveket fel kell ismerni, nem akadhat be a program, hogy keresi az adott kérdésre a választ, de ahhoz vagy nem töltöttek ki semmit, vagy mindent kitöltöttek. Például amennyiben közel az összes választ bejelölte valaki, de csak egyet kellett volna, akkor azt a válaszát érvénytelennek jelöljük és ugrunk tovább a többire.
Kimutatásnál jól jöhet, hogy melyik kérdésre hány feldolgozható, érvénytelen és üres válasz érkezett, ezzel a kérdésekről is készülne visszajelzés, amelyek alapján talán lehetne azokon is javítani.
Kérdőív feldolgozó rendszer #2: Programcsomagom & Azure
Programcsomag elképzelése
Az általam választott projekt nem csak egy kérdőív felismerést tartalmaz, hanem egy egész programcsomagot.
A programcsomag tervezett tartalma:
- Kérdőív-felismerő app (röviden: app)
- SQL szerver, konfigurációs panellel
- Kimutatást készítő modul
- Kézírást felvivő modul
Kérdőív felismerő app:
A fő alkalmazás, elindítható külön is, illetve a programcsomag részeként is. A különbség ezek között, hogy ha az egész csomagot használják, akkor projektekbe szervezhetjük a különböző kérdőívek feldolgozását, az információk (SQL címe, táblák nevei, általános beállítások) mentésre kerülnek, így az app nem kér információkat a feldolgozáshoz, ha elkülönítve van futtatva, akkor nyilván kér.
SQL szerver konfigurációs panellel:
Terveim közt szerepel, hogy az adatbázisokból legalább kétfajtát támogatok (MySQL/PostgreSQL, MSSQL), mert a MSSQL rendszerigénye a többihez viszonyítva kicsit magasnak tűnik, az esély nagy rá, hogy a programcsomag nem egy i7|16GB ram|GTX1080 kategóriájú gépen lesz futtatva, illetve a rendszerigényt szeretném alacsonyan tartani. Egynél több adatbázisrendszert pedig egyszerű támogatni, mivel nem beleégetni szeretném az adatbáziskezeléses parancsokat, hanem egy interface-t létrehozni, majd arra osztályokat. Azure támogatása sincs kizárva, de erről majd egy későbbi bejegyzésben.
Kimutatást készítő modul:
Itt egyszerű dolgokra kell gondolni, diagram, táblázat. Természetesen törekedve arra, hogy lehetőleg vektor-grafikusan lehessen menteni a képeket a kimutatásokról.
Kézírást felvivő modul:
Habár jónéhány OCR elérhető, első körben a „manuális felismerést” szeretném majd implementálni, ami annyit takarna, hogy az app kivágja azokat a részeket, ahol szövegnek kellene lennie és van is. Ennek megvalósítása aránylag egyszerűnek tűnik, a lap szélessége*0,75 hosszú vonalakat keresek, vagy ha sikerült az egész lapot beazonosítanom, akkor kivágom az előre (sablonként) megadott részt. Névfelismerésre szintén ezt használni, további részletek ebből is egy külön bejegyzésben lesznek kifejtve.
Azure – „yay or nay?”
Azure használata egy nagyon kellemes döntés lenne, semmilyen új gépet nem kellene beilleszteni a hivatali ökoszisztémába, nem kellene semmit változtatni a benti hálózati topológián. Ugyanakkor két erőteljes kérdés felmerül ezzel kapcsolatban:
1. Megéri-e?
Erre a kérdésre még nem lehet egyértelmű választ adni, hiszen nem ismert az appom sebessége, hogy milyen teljesítményű virtuális gép kellene hozzá, illetve mennyi az egy kérdőívre fordítandó keret. Viszont kényelmesnek nagyon kényelmes lenne, VM felállít, bekonfigurál, képek (kérdőívek) feltöltése, majd egyszer csak jön egy üzenet, hogy készen van, adatbázis kimentés és VM leáll.
2. Szabad-e?
Kérdőívek személyes adatokat is tartalmaznak, melyek alapján tisztán beazonosítható a kitöltő, válaszai alapján akár a politikai hovatartozása is, ezért ezek érzékeny adatnak minősülnek, melyeket elvileg csak szabályozott körülmények között szabad kiadni. Erről meg fogom kérdezni a hivatalt, hogy mi az álláspont, a felhőben való feldolgozás adatkiadásnak minősül-e a jelenleg hatályos jogszabályok alapján. Szerencsére az Azure azzal is hirdeti magát, hogy törvényi előírásoknak megfelelően lehet adatokat tárolni, amennyiben az itthoni jog teret ad ennek és az Azure-ban ez nem jelentkezik többletköltségként, akkor megfontolandó egy Azure kompatibilitást is felvenni a tervezett feature listára.
Kérdőív feldolgozó rendszer #1: Miért .NET & EmguCV
Miért a .Net, ha nincs „natív” képfelismerő?
Habár egyesek szerint van C#-nál jobb nyelv képfelismerő/feldolgozó alkalmazást írni, én a személyes (és munkahelyi) preferenciáim miatt inkább .Net vonalon képzelem el a programot. Mivel .NET Core használatával már Linux is célozható platformként, így amennyiben rendelkezésre áll egy megfelelő OpenCV wrappert vagy egy megfelelő képfelismerő alkalmazás, akkor multiplatformmá alakítható lehet az alkalmazás.
Továbbá, amennyiben iOS, Android, Windows Phone 10 eszközökön is elfogadható sebességgel fut a kérdőívek feldolgozása, akkor a Xamarin segítségével aránylag egyszerűen multiplatformosíthatóvá válik.
De természetesen ebben az esetben hatalmas időt is felemészthetne a QA, tehát ez a része nincs tervben, esetleg csak működő demo szintjén, összehasonlításban érdekes lenne, hogy a különböző operációs rendszerű telefonok miként viselkednek, illetve mennyivel lett gyorsabbak az újabb telefonok.
Miért az EmguCV?
A projekt kezdetekor én abban a hitben éltem, hogy van millió fajta képfelismerő C#/.NET-hez. Mint kicsit később kiderült tévedtem, jelentősen kevesebb van mint gondoltam. Néhányat már valamennyire ismertem, példának okáért a Matlab Image Processing Toolbox-ot, aminek a tudásán csak az ára tesz túl. Ugyanakkor, ha ezt használnám, akkor az ágyúval lőni bolhára eset állna fent: egyszerűen túl sokat tud, nekem pedig nem lesz annyira sokrétű az alkalmazásom, hogy a tudása tizedét is kihasználjam.
Open-source vizekre próbáltam evezni, már a (jellemzően) kedvezőbb licenszfeltételek miatt. Találtam is egy egészen korrektnek tűnő BSD licenszes segédletet: OpenCV.
Azonban ez csak C++-os library. De szerencsére, elég sok nyelven készül hozzá wrapper szerencsére C#-hoz is, ez lenne az EmguCV. Üröm, az örömben, hogy licenszfeltétele nem olyan engedékeny. Viszont támogatja az UWP-től kezdve a Xamarin-os appfejlesztést is, így ha esetleg multiplatformosítani akarnám az alkalmazást, akkor relatíve egyszerűen megtehetem.
Mi is az EmguCV?
Emgu CV is a cross platform .Net wrapper to the OpenCV image processing library. Allowing OpenCV functions to be called from .NET compatible languages such as C#, VB, VC++, IronPython etc. The wrapper can be compiled in Mono and run on Windows, Linux, Mac OS X, iPhone, iPad and Android devices.
Nos funkciók tekintetében ez az „image processing library” jött be leginkább, alább le is írom miért.
Kezdeném az OpenCL támogatással, ami eléggé meggyorsíthatja a képek feldolgozásának sebességét, ezt tesztek széleskörűen igazolják, persze kérdéses, hogy mennyit lehet majd az én programomban ebből kimérni. (Lesz majd összehasonlítás.) Egyetlen egy hátulütőről olvastam ezzel kapcsolatban, hogy figyeljek a grafikus meghajtókra, mert AMD kártyákon előfordultak lassulások, hibás eredmények.
Folytatva a sort, a CUDA támogatás is erősen plusz pont, de ez függ a programom használati helyétől, sajnos ezt az aspektust nem fogom tudni valószínűleg tesztelni, mivel otthoni számítógépemben Radeon van, munkahelyi GT210-es pedig annyira gyenge, hogy összehasonlítási alapnak rettenetes.
Tesseract OCR-t a listába belevenni kicsit fals dolog, mivel ez egy Google által szponzorált opensource library karakterfelismeréshez, amiről legtöbben elégedetten beszélnek, ugyanakkor része az EmguCV-s „csomagnak”, pluszban ez így lerövidítette az időt, amit OCR-ek keresésével kellett töltenem.
Szerencsére cross-platform, így linuxon futtatás is szóbajöhet, bár személy szerint engem jobban érdekelne ennél, hogy Apple A8-A10 processzoron milyen sebességű a képfeldolgozás, illetve ugyanez Androidos/Windows Phone-os telefonokon az Adreno IGP-vel.
Android programozás #7 | Új keretrendszer: Apache Cordova
Szakmai gyakorlatom során a HTML-lel, a CSS-sel, a JavaScripttel, a JQuery-vel és a Bootstrappel ismerkedtem meg. A gyakorlati helyemen ajánlották az Apache Cordova keretrendszert, amivel és az előbb felsoroltakkal lehetőség nyílik mobilalkalmazások megírására Android, iOS és Windows Phone-ra egyaránt.
Ehhez szükségünk van az Intel XDK-hoz, amit innen lehet letölteni. Ingyenesen lehet regisztrálni. Mobiltelefonra a play áruházon keresztül pedig az App Preview nevezetű alkalmazást kell letölteni, ahol szintén a regisztráció/belépés után ki lehet próbálni néhány alkalmazást. Ilyen pl. a barcode scanner, amihez itt lehet hozzájutni. Erre a későbbiekben szükség lesz, mivel a termékeket vonalkód segítségével gyorsabban lehet majd azonosítani.
Természetesen szükség lesz majd egy adatbázisra is, ebben a Firebase lesz segítségünkre.
Android programozás #6 | Szenzorok
Három főbb érzékelőt támogat az android platform:
- Mozgásérzékelők
- Környezeti érzékelők
- Pozíció érzékelők
Néhány érzékelő hardver alapú és néhány szoftver alapú. Bármilyen is legyen az érzékelő, az android lehetővé teszi számunkra, hogy nyers adatokat nyerjünk az érzékelőkből és ezeket az alkalmazás használja. Erre az android biztosít számunkra néhány osztályt.
Az android SensorManager és Sensor osztályokat biztosít a számunkra, ami által szenzorokat használhatunk az alkalmazásunkban. Annak érdekében, hogy használhassuk a szenzorokat, az első dolog, amit meg kell, hogy tegyünk, hogy példányosítunk egy objektumot a SensorManager osztályból. Íme egy példa:
SensorManager sMgr; sMgr = (SensorManager)this.getSystemService(SENSOR_SERVICE);
A következő lépés, hogy példányosítunk egy objektumot a Sensor osztályból a SensorManager osztály getDefaultSensor() metódusának meghívásával. Azaz:
Sensor light; light = sMgr.getDefaultSensor(Sensor.TYPE_LIGHT);
Amint a szenzor deklarálva van, “nyilván kell tartani” a listener-t és felülírni a két metódust, ami a onAccuracyChanged és az onSensorChanged. A szintaxis a következő:
sMgr.registerListener(this, light,SensorManager.SENSOR_DELAY_NORMAL); public void onAccuracyChanged(Sensor sensor, int accuracy) { } public void onSensorChanged(SensorEvent event) { }
A szenzorokról még sok mindent lehet “tárgyalni”, ezt majd a későbbiekben folytatom.
Android programozás #5 | Resource-ok kezelése
Sok más elem van még, amiket egy jó android alkalmazás felépítéséhez használunk. Eltekintve az alkalmazás írásától, figyelnünk kell számos egyéberő forrásra, mint pl. a statikus tartalom, amit a kód használ, például a bittérképek, a színek, az elrendezés, az animációs utasítások, és így tovább. Ezek a források mindig elkülönülve zajlanak, különböző alkönyvtárakban a projekt res/ könyvtárában.
Az alábbi leírás elmagyarázza, hogyan tervezzünk meg az alkalmazásunk erőforrásait, hogyan adjuk meg az alternatív erőforrásokat és hogyan érhetjük el őket az alkalmazáson belül.
Erőforrások megtervezése Android Studio-ban
MyProject/ app/ manifest/ AndroidManifest.xml java/ MyActivity.java res/ drawable/ icon.png layout/ activity_main.xml info.xml values/ strings.xml
Könyvtár és erőforrás típusok
anim/
XML fájlok, amik meghatározzák az animációk tulajdonságait. A res/anim/ könyvtárba mentődnek el és a R.anim osztályból érhetőek el.
color/
XML fájlok, amik meghatározzák a színek egy statikus listáját. A res/color/ könyvtárba mentődnek el és a R.color osztályból érhetőek el.
drawable/
Képfájlok, mint pl. .png, .jpg, .gif vagy XML fájlok, amik összeállnak bittérképekké, utasítás listákká, formákká, rajzolható animációkká. A res/drawable/ könyvtárba mentődnek el és a R.drawable osztályból érhetőek el.
layout/
XML fájlok, amik meghatározzák a felhasználói felület kinézetét. A res/layout/ könyvtárba mentődnek el és a R.layout osztályból érhetőek el.
menu/
XML fájlok, amik meghatározzák az alkalmazás menüjeit, mint pl. egy Beállítások menü. A res/menü/ könyvtárba mentődnek el és a R.menu osztályból érhetőek el.
raw/
Tetszőleges fájlok, amik nyers formában mentődnek el. Meg kell őket hívni a Resources.openRawResource() metódusban az erőforrás-azonosítóval, amit a R.raw.filename-mel tudjuk megnyitni.
values/
XML fájlok, amelyek magukba foglalják az egyszerű értékeket, úgymint a sztringeket, az egész számokat és a színeket. Például, itt van néhány fájlnév egyezmény az erőforrásoknak, amiket létrehozhatsz ebben a könyvtárban –
- arrays.xml a tömbök erőforrásainak, és az R.array osztályból érthetőek el.
- integers.xml az egész számok erőforrásainak és az R.integer osztályból érthetőek el.
- bools.xml a logikai vagy erőforrásainak és az R.boolean osztályból érthetőek el.
- colors.xml a szín értékeknek, és az R.color osztályból érthetőek el.
- dimens.xml a dimenzió értékeknek, és az R.dimen osztályból érthetőek el.
- strings.xml a sztring értékeknek, és az R.string osztályból érthetőek el.
- styles.xml a stílusoknak, és az R.style osztályból érthetőek el.
xml/
Tetszőleges XML fájlok, amiket futtatás közben olvashatunk a Resources.getXML() metódus meghívásával. Különböző konfigurációs fájlokat menthetsz el itt, amiket futtatás közben használtál.
Alternatív erőforrások
Az alkalmazásunknak biztosítania kell az alternatív erőforrásokat, hogy támogatni tudjunk egyedi eszközkonfigurációkat. Például, tartalmaznia kell az alternatív rajzolható erőforrásokat különböző képernyő felbontáshoz és tartalmaznia kell az alternatív sztring erőforrásokat különböző nyelvekhez. Futtatás közben az Android érzékeli az aktuális eszközkonfigurálást és betölti a megfelelő erőforrásokat az alkalmazásunk számára.
Ahhoz, hogy meghatározzuk a konfigurációt – speciális alternatívák egy erőforrás készlet számára – kövessük az alábbi lépéseket:
- Hozzunk létre egy új könyvtárat a res/ könyvtárban, az alábbi formában: <erőforrás_név>-<konfiguráció_jelző>. Itt az erőforrás_név az erőforrások bármelyike lesz a fenti felsorolásból, mint pl. layout, drawable, stb. A jelző meg fog határozni egy egyedi konfigurációt, ami ezeket a forrásokat használja. Utána tudunk nézni a hivatalos dokumentációban, az erőforrások különböző típusainak a jelzőinek egy teljes listájában.
- Mentsd el a megfelelő alternatív erőforrásokat ebbe az új könyvtárba. Az erőforrások fájlokat pontosan ugyanúgy kell elnevezni, mint az alapértelmezett erőforrás fájlok, ahogy azt az alábbi példa is mutatja. Például, bár a képfájl név ugyanaz lesz, de a nagy felbontású képernyő számára, a felbontása nagy lesz.
Az alábbiakban láthatunk egy példát, amely meghatározza a képeket egy alapértelmezett képernyő számára és meghatározza az alternatív képeket a nagy felbontású képernyő számára.
MyProject/ app/ manifest/ AndroidManifest.xml java/ MyActivity.java res/ drawable/ icon.png background.png drawable-hdpi/ icon.png background.png layout/ activity_main.xml info.xml values/ strings.xml
Az alábbi példa meghatározza a kinézetet egy alapértelmezett nyelv számára és meghatározza az alternatív kinézetet az arab nyelv számára.
MyProject/ app/ manifest/ AndroidManifest.xml java/ MyActivity.java res/ drawable/ icon.png background.png drawable-hdpi/ icon.png background.png layout/ activity_main.xml info.xml layout-ar/ main.xml values/ strings.xml
Android programozás #4 | Clicker tutorial
Az első tutorial alapján egy olyan alkalmazást hozunk létre, ahol két gomb és egy számláló látszik. A Click gombra kattintva a számláló elkezd növekedni, míg a Reset gombra kattintva visszaáll nullára.
1. Ehhez nyissuk meg az AndroidStudio-t
2. Hozzunk létre egy új projektet File/New/New Project…
- Az alkalmazás neve (Application Name) legyen Clicker (vagy amit jónak látunk). A Company Domain igazándiból mindegy, hogy mi, ebből lesz a package neve. Next.
- Phone & tablet legyen kipipálva, hisz erre a két platformra akarunk elsősorban alkalmazást írni. Next.
- Activity-t adunk az alkalmazásunkhoz. Az EmptyActivity-t választjuk. Ehhez hasonlít a BlankActivity, ami az EmptyActivity-nek egy bővített “verziója”, mivel a jobb alsó sarokban találhatunk egy plusz jelet, illetve a jobb felső sarokban a három pontot, ami a menü-re utal. Next.
- Az Activity neve marad MainActivity. Finish.
Miután a Grade Build befejeződik, automatikusan az (res/layout/)activity_main.xml és a MainActivity.java (az Activity neve) nyílik meg.
3. Nyissuk meg az activity_main.xml-t. Design nézetben láthatjuk, hogy hogyan is néz ki az adott platformon az alkalmazásunk. Alapértelmezetten felül, a kék sávban az alkalmazásunk neve, és alatta egy TextView-ban a Hello World szöveg látszik. A Design nézet mellett létezik a Text nézet. A Text nézetben az xml nyelv segítségével alakíthatjuk az alkalmazásunk kinézetét, míg Design nézetben egyszerűbb módon, különböző ún. Widget-ek segítségével készíthetjük el az alkalmazás egy részét, amit a Palettáról (Palette) tudunk kiválasztani.
4. Két gombra (Button) lesz szükségünk (Click és Reset), illetve az alapértelmezett HelloWorld TextView-t használjuk fel számlálóként. Két gombot húzzunk be a felületünkre a palettáról. Az első gombra kattintva jobb oldalt megjelenik a Properties. Keressük meg a Text-et, és írjuk be, hogy Click. Ez fog látszódni a gombon. Ugyanezt megtehetjük az Text nézetben. A másik gombot (Reset) így csináljuk meg. Láthatjuk, hogy a 3 widget-nek több, különböző “tulajdonsága” van. Keressük meg azt a Button-t, aminek a neve még nem lett átírva, és írjuk át:
android:text="Reset"
A TextView-nál pedig a HelloWorld-öt írjuk át 0-ra. Menjünk vissza Design nézetbe, és a TextView Properties-nél keressük meg a TextSize-t, amit állítsunk 32dp-re, hogyan jobban látszódjon a számolás. Text nézetben, a TextView-nál a tutorial szerint átírjuk az id-t , de nálam nem volt id,így az alábbi sort illesztettem be:
android:id="@+id/textViewCount"
mivel a Click gomb és a TextView összetartozik, ezért a layout_below tulajdonságot átírjuk:
android:layout_below="@+id/textViewCount"
Az id pedig legyen:
android:id="@+id/buttonClick"
Összességében a Click gomb Text nézetben így néz ki:
<Button android:text="Click" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_below="@+id/textViewCount" android:layout_centerHorizontal="true" android:layout_marginTop="48dp" android:id="@+id/buttonClick" />
A Reset gombnál kicsit másabb a helyzet:
android:text="Reset" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_below="@+id/buttonClick" android:layout_alignLeft="@+id/buttonClick" android:layout_alignStart="@+id/buttonClick" android:layout_marginTop="32dp" android:id="@+id/buttonReset"
Reset lesz a szöveg, ami megjelenik a gombon, és mivel a Reset gomb a Click gombbal tartozik össze, ezért az id kivételével a többi helyen a Click gombhoz “kapcsolódik”.
5. Nyissuk meg a MainActivity.java-t. Az Android Studio alapértelmezetten így hozza létre:
package nagy.anita.Clicker; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } }
Ezt egészítsük ki az alábbi módon:
Az @Override elé írom az alábbiakat, amivel létrehozzuk az objektumainkat. Két darab Button típusú gombot, és egy TextView típusú szöveget, ami a számlálónk.
Button btnClick; Button btnReset; TextView txtCount;
A létrehozás során a Button pirosan “mutatkozik”. Ha rávisszük az egeret, azt írja, hogy cannot resolve symbol ‘Button’. Az alt+enter megnyomásával importálja a szükséges osztályt, amit megtehetünk manuálisan is, legfelülre begépeljük ezt:
import android.widget.Button;
A txtCount-nál hasonló hibával találkozunk, ekkor az android.widget.TextView osztály lesz importálva.
Az onCreate metódusunkba “kössük össze” az előbb létrehozott gombokat és a szöveget azokkal a gombokkal és szöveggel, amit az xml-ben hoztunk létre:
btnClick = (Button)findViewById(R.id.buttonClick); btnReset = (Button)findViewById(R.id.buttonReset); txtCount = (TextView)findViewById(R.id.textViewCount);
Írjuk meg, hogy mi történjen akkor, amikor rákattintunk a Click gombra (szintén az onCreate metóduson belül):
btnClick.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { String countValue = txtCount.getText().toString(); int intCountValue = Integer.parseInt(countValue); intCountValue++; txtCount.setText(String.valueOf(intCountValue)); } });
A String countValue = txtCount.getText().toString(); sorban meghívjuk a számlálónkat, mint egy sztring típusú “objektumot”, amit a következő sorban átalakítunk integerré, majd ezt növeljük a következő sorban, végül ezt az értéket visszaadjuk a TextView-nak.
6. Mentsük el az alkalmazást, majd próbáljuk ki. Mivel nekem a futtatás során az Android Studio azt a hibát írta ki, hogy “Your CPU does not support NX”, ezért azt a megoldást találtam, hogy egy külső “meghajtón” próbálom ki az alkalmazást (amúgy is telefonra írom/írjuk elsősorban az alkalmazásokat, így jobb is, ha azon próbálgatom az alkalmazásokat). Ezt egy tutorial videó segítségével oldottam meg, amit itt lehet megnézni.
Természetesen a Reset gombunk még nem működik, mivel azzal még nem foglalkoztunk, de a Click gombot nyomkodva szépen növekszik a számlálónk egyesével.
7. A Reset gomb működéséhez írjunk még egy ClickOnListener-t:
btnReset.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { txtCount.setText(String.valueOf(0)); } });
Ez egy egyszerűbb Listener lesz, mivel itt csak annyi a dolgunk, hogy a számlálónkat 0-ra állítsuk.
8. Mentsük el ismét az alkalmazást és próbáljuk ki mind a két gombunkat.
Ez a tutorial egy kicsit átalakítva a későbbiekben jó lehet majd az alapanyagok mennyiségének beállításánál is.
Android programozás #3 | Alkalmazás felépítése
- Activity (a program egy “ablaka”)
- Service (háttérben futó szolgáltatás)
- Content Provider (adatok kezelése)
- Broadcast Receiver (rendszerszintű eseményekre reagál)
Minden komponensnek különböző szerepe van az alkalmazáson belül. Bármelyik komponens önállóan aktiválódhat. Akár egy másik alkalmazás is aktiválhatja az egyes komponenseket.
Android alkalmazás komponensek. |