Hogyan olvassunk adatokat Android alkalmazásokban: Text fájlok és SQLite adatbázisok kezelése

Az Android alkalmazások fejlesztése során gyakran előfordul, hogy különböző forrásokból kell adatokat beolvasnunk. Két alapvető módja van annak, hogyan érhetünk el fájlokat az alkalmazásban: az egyik a raw mappán keresztüli hozzáférés, a másik pedig az assets mappa használata. Ebben a példában bemutatjuk, hogyan olvashatunk szöveges fájlokat mindkét helyről, és hogyan dolgozhatunk adatbázisokkal, például az SQLite adatbázissal.

Az első lépés az alkalmazásunk előkészítése. Hozzunk létre egy új Android projektet, amit nevezzünk el „ReadingResourceFiles”-nak. A projekthez válasszuk a „Phone & Tablet” beállítást, és az Activity típusát állítsuk „Empty Activity”-re.

Ezután szükséges, hogy két mappát hozzunk létre a projektben: res/raw és assets. A raw mappa egyszerűen létrehozható a res mappán belül. Ha jobb klikket végzünk a raw mappán, új fájlt hozhatunk létre, amit nevezzünk el raw_text.txt-nek. A fájlba bárminemű szöveget írhatunk, ami majd az alkalmazás futtatásakor megjelenik.

A következő lépés a kód hozzáadása, hogy olvasni tudjuk ezeket a fájlokat. Az alábbi metódus segítségével olvashatjuk be a fájlok tartalmát, amelyet InputStream segítségével adunk át:

java
Copy code
private String getText(InputStream inputStream) {

    StringBuilder stringBuilder = new StringBuilder();

    try {
        if (inputStream != null) {
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream);

            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

            String newLine = null;
            while ((newLine = bufferedReader.readLine()) != null) {
                stringBuilder.append(newLine + "\n");
            }
            inputStream.close();
        }
    } catch (java.io.IOException e) {
        e.printStackTrace();
    }
    return stringBuilder.toString();
}

Ezt a metódust felhasználhatjuk a raw és assets fájlok tartalmának beolvasására egyaránt. Az alábbi kódot a MainActivity osztályban található onCreate() metódusba illeszthetjük be:

java
Copy code
TextView textViewRaw = (TextView)findViewById(R.id.textViewRaw);
textViewRaw.setText(getText(this.getResources().openRawResource(R.raw.raw_text)));
TextView textViewAsset = (TextView)findViewById(R.id.textViewAsset);
try {
    textViewAsset.setText(getText(this.getAssets().open("asset_text.txt")));
} catch (IOException e) {
    e.printStackTrace();
}

A fenti kódban az első sor a raw mappából olvas, míg a második az assets mappából. Az eredmény ugyanaz, mivel mindkét esetben egy InputStream-et kapunk vissza, amelyet a getText() metódus olvas be.

Fontos megjegyezni, hogy az assets mappához való hozzáféréshez egy try/catch blokk szükséges, mivel az Android nem biztosít fordítási időben ellenőrzést ezen fájlok elérhetősége felett, míg a raw mappát az alkalmazás fordításakor már ellenőrzi.

A következő lépés a SQLite adatbázisok kezelése. Az Android platformon az SQLite használata elterjedt, és az adatbázisokkal való munka egyszerűsítésére az Android egy beépített osztályt biztosít: az SQLiteOpenHelper-t. Ezen osztály segítségével kezelhetjük az adatbázisunkat, végrehajthatjuk a CRUD (Create, Read, Update, Delete) műveleteket, és például egy egyszerű szótáradatbázist hozhatunk létre.

Az adatbázis létrehozásához először is létre kell hoznunk egy új Java osztályt, amely az SQLiteOpenHelper-t örökli. Ezen osztály fogja tartalmazni az adatbázis-kezelési műveletek logikáját, mint például a szavak beszúrását, lekérdezését, frissítését és törlését.

A CRUD műveletek alapvető függvényei a következőek:

• Create: insert()

• Read: query() és rawQuery()

• Update: update()

• Delete: delete()

Ez a megoldás lehetővé teszi, hogy szavakat adjunk hozzá, módosítsuk őket, vagy töröljük őket, mindezt egy egyszerű és hatékony módon.

Hogyan váltsunk aktivitást és adjunk át adatokat Android alkalmazásban?

Az Android fejlesztés egyik alapvető feladata az aktivitások közötti váltás kezelése, amely a felhasználói élmény folytonosságát és a funkciók komplexitását biztosítja. Az aktivitásváltás lényege, hogy egy alkalmazás több képernyőt, vagyis aktivitást használ, és ezek között dinamikusan léphetünk át. Ehhez az Android egy speciális eszközt biztosít, az intent objektumot, amely lehetővé teszi az aktivitások közötti kommunikációt és adatátvitelt.

Az aktivitásváltás legegyszerűbb módja, hogy létrehozunk egy második aktivitást (például SecondActivity néven), majd a fő aktivitásból egy gombnyomás eseményhez kapcsolódó függvényben példányosítjuk az intent objektumot. Ez az intent explicit módon megadja a célaktivitás osztályát, majd az indítást a startActivity() metódussal hajtjuk végre. Az aktivitás lezárása, és visszatérés az előző aktivitáshoz az aktuális aktivitás finish() metódusának meghívásával történik, amely az Android rendszer visszalépési verem mechanizmusát használja, így a legutóbb megnyitott aktivitás kerül ismét előtérbe.

Az intent nemcsak az aktivitások közötti váltás eszköze, hanem az adatátvitel fő csatornája is. Az adatot a putExtra() metódussal tudjuk az intenthez csatolni, amelyhez egy kulcs-érték párt rendelünk. Fontos megérteni, hogy a kulcsnak pontosan egyeznie kell a fogadó oldalon történő kicsomagoláskor, amelyet a getIntent().getStringExtra() vagy más, a tárolt adattípusnak megfelelő metódusokkal végzünk. Ez az adatátvitel akár egyszerű szöveges adatok, akár összetettebb, támogatott alap adattípusok küldésére is alkalmas.

Az aktivitások létrehozását az Android Studio megkönnyíti, mivel automatikusan kezeli az AndroidManifest.xml fájlban az aktivitások deklarálását, így a fejlesztő nem kell manuálisan beírja az aktivitásokat. Csak a fő aktivitás rendelkezik indító (MAIN, LAUNCHER) kategóriával, amely megmondja a rendszernek, hogy melyik aktivitást indítsa el először. A másodlagos aktivitások erre nem kapnak ilyen jelölést, mivel azok csak a program futása közben, explicit indítás hatására nyílnak meg.

A működés megértéséhez elengedhetetlen a visszalépési verem (back stack) fogalmának ismerete, amely az aktivitások hierarchikus, időrendi tárolását jelenti. Az aktivitás lezárásakor a rendszer az előző aktivitást hozza ismét előtérbe, ami a felhasználói navigáció természetes és megszokott módja.

Az adatátadás és aktivitásváltás mellett a fejlesztőknek számolniuk kell azzal is, hogy bizonyos esetekben szükség lehet az eredmény visszaadására, azaz a hívó aktivitás informálására arról, hogy a megnyitott aktivitás milyen eredményt produkált vagy milyen műveletet hajtott végre. Ezt a startActivityForResult() és a hozzá tartozó onActivityResult() mechanizmus biztosítja, amely azonban már egy komplexebb kezelést igényel, és így külön részletezést érdemel.

Az aktivitások közötti váltás és adatátadás alapelveinek elsajátítása kulcsfontosságú minden Android fejlesztő számára, mivel ez a művelet képezi az alkalmazás működésének gerincét. Ezen túl fontos, hogy az intent objektum használata során odafigyeljünk a megfelelő adatkulcsok egyezésére, az aktivitások megfelelő deklarálására a manifest fájlban, és a felhasználói navigáció természetes működésének megőrzésére.

Hogyan működik az Android kamerakezelés a TextureView és a Camera2 API segítségével?

Az Android kamerakezelésének egyik alapvető módja a Camera2 API használata, amely lehetővé teszi a fejlett képrögzítést és kameravezérlést. A TextureView az egyik leggyakoribb nézetkomponens, amelyet a kamera képének megjelenítésére használnak. A TextureView felülete (SurfaceTexture) fontos szerepet játszik a kameraképek megjelenítésében, és ennek életciklusát különféle eseménykezelők segítségével követjük nyomon.

A SurfaceTextureListener feladata az, hogy figyelje, mikor válik elérhetővé vagy változik a TextureView felülete. Amikor a felület elérhetővé válik, automatikusan megnyitjuk a kamerát az openCamera() metódussal. Ez a metódus a CameraManager segítségével azonosítja és elindítja az első kamerát a készüléken. A kameranyitás során lekérjük a kamera jellemzőit (CameraCharacteristics), különös tekintettel a StreamConfigurationMap-re, amely megadja a támogatott felbontásokat és konfigurációkat. Az első elérhető felbontást választva hozzuk létre a preview méretet.

Miután megnyílt a kamera, létrejön a CaptureSession, amely a kamera előnézeti folyamathoz szükséges. A CameraCaptureSession.StateCallback kezeli ennek az állapotát: sikeres konfiguráció esetén elindítjuk az előnézetet. Az előnézet elindításakor egy háttérszálon kezeljük a képkészítési kéréseket, biztosítva, hogy a fő UI szál nem blokkolódik. A CaptureRequest.Builder segítségével állítjuk be az automatikus vezérlést és hozzárendeljük a TextureView Surface-jét célfelületként.

A kép készítésének folyamata komplexebb. Először meghatározzuk a legnagyobb támogatott képfelbontást, majd egy ImageReader-t hozunk létre, amely fogadja és kezeli a JPEG formátumú képeket. Az ImageReader egy eseményfigyelőt (OnImageAvailableListener) tartalmaz, amelyben a képadatok byte-ok formájában kerülnek kiolvasásra és fájlba mentésre. A fájlnév időbélyeggel ellátott, hogy egyértelműen elkülöníthetőek legyenek a mentett képek. A képkészítés befejezése után visszatérünk az előnézet folytatásához.

A Camera2 API-val történő fejlesztés során fontos megérteni a szálkezelést és a kamerafolyamatok aszinkron jellegét. A háttérszálak létrehozása (HandlerThread) és megfelelő kezelése elengedhetetlen a folyamatos és zökkenőmentes működéshez, mivel a kamera műveletek hosszabb időt vehetnek igénybe, amely blokkolhatná a felhasználói felületet. A kamera konfigurációja, a CaptureRequest összeállítása és a CaptureSession kezelése gondos szinkronizációt igényel.

A képfájl mentése során figyelembe kell venni a jogosultságokat, valamint a külső tárhely elérhetőségét, hiszen az Android rendszerek egyre szigorúbb biztonsági korlátozásokat vezetnek be. Az alkalmazásnak megfelelő engedélyeket kell kérnie a tároláshoz, és kezelnie kell az esetleges kivételeket, hogy elkerülje a leállásokat vagy adatvesztést.

A működés megértése mellett lényeges az erőforrások felelősségteljes kezelése, az életciklusok követése, valamint a felhasználói élmény zavartalanságának biztosítása. Ezek nélkül a fejlesztett alkalmazás instabillá válhat, és nem fogja maximálisan kihasználni a modern Android kamerarendszer nyújtotta lehetőségeket.