API kutatás/tesztelés #3 (LinkedIn:Sparkle.LinkedInNET)

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.

Continue reading

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.

EREDETIKEP_KERDOIV

 

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:

negyzetek
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:

  1. Mozgásérzékelők
  2. Környezeti érzékelők
  3. 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.

clicker

 

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

Egy Android alkalmazás egy vagy több alkalmazás komponensből épül fel:

  • 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.
Activity: egy-egy Activity leszármazott egy-egy képernyő a mobil eszköz kijelzőjén. Egyszerre mindig csak egy Activity látható, de egy alkalmazáshoz több képernyőkép tartozhat, amelyeket futás közben – események hatására – szabadon cserélhetünk. Minden programnak kell legyen egy belépési pontja, amely az az Activity leszármazott, amelyet először mutat meg a felhasználónak. Minden Activity az android.app.Activity osztályból származik le.
Service: sok alkalmazás igényli, hogy bezárt ablakkal is képes legyen futni a háttérben, ezt szolgáltatásként megteheti, egyszerűen kell egy Service osztályból leszármazott példány, így marad a programunknak olyan része, amely a felfüggesztett Activity esetén is fut (gondoljunk például egy média lejátszóra). Minden szolgáltatást addig futtat a platform, amíg azok be nem fejeződnek, s a futó alkalmazások képesek hozzákapcsolódni a szolgáltatásokhoz, így képesek vagyunk vezérelni a háttérben futó szolgáltatást. Az android.app.Service osztályból kell öröklődnie.
Content Provider: általában minden alkalmazás tárol adatokat két futás között, hiszen ha felfüggesztés helyett bezárnánk az alkalmazást, akkor elvesznének az addig összegyűjtött adatok. A Content provider (tartalom szolgáltató) komponens feladata egy megosztott adatforrás kezelése. A platformon lehetőségünk van állományokba vagy SQLite adatbázisba menteni adatokat, és ezt segíti a Content Provider, illetve lehetővé teszi, hogy két alkalmazás adatokat cseréljen egymással. A Content provider-en keresztül más alkalmazások hozzáférhetnek az adatokhoz, vagy akár módosíthatják is azokat pl.: CallLog alkalmazás, ami egy Content provider-t biztosít, és így elérhető a tartalom. Az android.content.ContentProvider osztályból származik le és kötelezően felül kell definiálni a szükséges API hívásokat.
Broadcast Receiver: a Broadcast receiver komponens a rendszer szintű eseményekre (broadcast) reagál. Például: kikapcsolt a képernyő, alacsony az akkumulátor töltöttsége, elkészült egy fotó, bejövő hívás, stb. Az alkalmazás is indíthat saját „broadcast”-ot, például ha jelezni akarja, hogy valamilyen művelettel végzett (pl. letöltődött a torrent). Nem rendelkeznek saját felülettel, inkább valamilyen figyelmeztetést írnak ki például a status bar-ra, vagy elindítanak egy másik komponenst (jeleznek például egy service-nek). Az android.content.BroadcastReceiver osztályból származik le; az esemény egy Intent (lásd. később) formájában érhető el.