Hogyan tároljunk adatokat Androidon?

A modern mobilalkalmazások egyik legfontosabb eleme, hogy képesek legyenek adatokat tárolni és kezelni. Az Android operációs rendszer számos lehetőséget biztosít ezen a téren, beleértve a preferenciák (SharedPreferences) és fájlok kezelését is. Ezen a területen alaposan megismerkedhetünk az adatok tárolásának különböző módszereivel, amelyek lehetővé teszik az alkalmazás számára, hogy felhasználói adatokat megőrizzünk, és azok újra felhasználhatók legyenek a következő indításkor.

A SharedPreferences használata az egyik legegyszerűbb módszer arra, hogy kis mennyiségű adatot tároljunk. A következőkben bemutatjuk, hogyan lehet egyszerű adatokat, például a felhasználó nevét tárolni és újra betölteni az alkalmazás újraindítása után.

Először is szükségünk van egy Activity osztályra, amely a tárolni kívánt adatokat tartalmazza. Például, ha a felhasználó nevét szeretnénk elmenteni, akkor a következő kódot adhatjuk hozzá az ActivityMain.java fájlhoz:

java
Copy code
private final String NAME="NAME";

private EditText mEditTextName;

Ezután a onCreate() metódusban beállíthatjuk, hogy hogyan töltsük be az adatokat:

java
Copy code
TextView textView = (TextView)findViewById(R.id.textView);
SharedPreferences sharedPreferences = getPreferences(MODE_PRIVATE);

String name = sharedPreferences.getString(NAME, null);

if (name == null) {
    textView.setText("Hello");
} else {
    textView.setText("Welcome back " + name + "!");
}
mEditTextName = (EditText)findViewById(R.id.editTextName);

Ezzel a kódrészlettel a program betölti a mentett adatokat, és megjeleníti őket a képernyőn. Ha a felhasználó neve nem lett még elmentve, a rendszer üdvözlő üzenetet jelenít meg.

A név mentésére az alábbi saveName() metódust használhatjuk:

java
Copy code
public void saveName(View view) {
    SharedPreferences.Editor editor = getPreferences(MODE_PRIVATE).edit();
    editor.putString(NAME, mEditTextName.getText().toString());
    editor.commit();
}

Ez a metódus az EditText-ben található szöveget tárolja el a SharedPreferences-ben. Ne felejtsük el, hogy a változtatásokat commit() hívással kell rögzíteni, különben nem kerülnek mentésre.

Amikor az alkalmazást futtatjuk egy eszközön vagy emulátoron, és újraindítjuk, az adatok automatikusan betöltődnek, és láthatjuk a nevünket a képernyőn.

Ha nagyobb és komplexebb adatokat kell tárolnunk, például fájlokat, akkor az Android lehetőséget biztosít a fájlkezelésre is. Az alábbiakban bemutatjuk, hogyan lehet szöveges fájlokat olvasni és írni az Android belső tárolójába.

A következő lépésekben létrehozunk egy új projektet, amelyben egy fájlba írjuk, majd onnan olvassuk a felhasználó által megadott szöveget.

Először is szükség van a main_activity.xml fájl módosítására, hogy tartalmazzon egy EditText-et és két gombot. Ezt követően a ActivityMain.java fájlban globálisan deklaráljuk a szükséges változókat:

java
Copy code
private final String FILENAME="testfile.txt";

EditText mEditText;

Ezután beállítjuk a megfelelő hivatkozásokat a onCreate() metódusban:

java
Copy code
mEditText = (EditText)findViewById(R.id.editText);

A fájlba írása az alábbi writeFile() metódussal történik:

java
Copy code
public void writeFile(View view) {

    try {
        FileOutputStream fileOutputStream = openFileOutput(FILENAME, Context.MODE_PRIVATE);
        fileOutputStream.write(mEditText.getText().toString().getBytes());
        fileOutputStream.close();
    } catch (java.io.IOException e) {
        e.printStackTrace();
    }
}

Ez a metódus az EditText szövegét írja a fájlba. A fájl írása során az openFileOutput() metódust használjuk, amely a fájl elérési útját és az írási módot is beállítja.

A fájl olvasása az alábbi readFile() metódus segítségével történik:

java
Copy code
public void readFile(View view) {

    StringBuilder stringBuilder = new StringBuilder();

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

            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

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

A fájl beolvasása több lépésből áll. Először is megnyitjuk a fájlt az openFileInput() segítségével, majd egy BufferedReader segítségével olvassuk a fájl sorait. Az így kapott szöveget hozzáadjuk egy StringBuilder objektumhoz, végül pedig visszaírjuk azt az EditText mezőbe.

Ez a módszer segít megérteni a fájlkezelés alapjait Androidon, beleértve a fájlok írását és olvasását a belső tárolóba.

Fontos, hogy az alkalmazás megfelelően kezelje a fájlokat, és biztosítsa a felhasználók adatainak biztonságát, különösen ha az alkalmazás nagyobb fájlokat vagy érzékeny adatokat kezel. Az alkalmazásoknak a rendszer erőforrásaival való takarékos gazdálkodás érdekében ügyelniük kell a cache fájlok és más ideiglenes fájlok kezelésére is. A cache fájlokat a rendszer automatikusan törölheti, ha az eszközön kevés a szabad hely.

Hogyan olvassunk szenzoradatokat Android alkalmazásban?

A modern okostelefonok és táblagépek rengeteg érzékelőt tartalmaznak, amelyek lehetővé teszik az eszközök számára, hogy a környezetükhöz alkalmazkodjanak. Az Android operációs rendszer lehetővé teszi az érzékelők adatainak egyszerű lekérését, kezelést és megjelenítést alkalmazásokban. Ebben a fejezetben bemutatjuk, hogyan dolgozhatunk az Android szenzorkeretrendszerével, hogy az érzékelők adatait beolvassuk és megjelenítsük egy alkalmazásban.

Az alapvető lépések a következők: először lekérjük az elérhető érzékelők listáját, majd megjelenítjük azokat egy ListView-ban. Az érzékelők típusaik alapján különböznek egymástól, de mindegyik ugyanazzal a keretrendszerrel működik, így a munkafolyamatok hasonlóak, függetlenül attól, hogy milyen típusú érzékelőről van szó.

java
Copy code
ListView listView = (ListView)findViewById(R.id.list);
List<String> sensorList = new ArrayList<>();
List<Sensor> sensors = ((SensorManager) getSystemService(Context.SENSOR_SERVICE)).getSensorList(Sensor.TYPE_ALL);
for (Sensor sensor : sensors) {
    sensorList.add(sensor.getName());
}
ListAdapter sensorAdapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1, sensorList);
listView.setAdapter(sensorAdapter);

Ez a kód lekéri az összes elérhető érzékelőt, és a nevüket hozzáadja egy listához, amelyet a ListView-ban jelenítünk meg. A getSensorList(Sensor.TYPE_ALL) metódus minden típusú érzékelőt visszaad, amelyek az Android rendszerében elérhetők.

Ezután, ha konkrét érzékelőt szeretnénk használni, például egy gyorsulásmérőt, akkor a következő módon módosíthatjuk a lekérdezést:

java
Copy code
List<Sensor> sensors = sensorManager.getSensorList(Sensor.TYPE_ACCELEROMETER);

Ha nem az összes érzékelőt szeretnénk listázni, hanem egy adott érzékelőt akarunk használni, például az alapértelmezett gyorsulásmérőt, akkor a következő kóddal ellenőrizhetjük annak elérhetőségét:

java
Copy code
if (sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null) {
    // Az érzékelő elérhető - tegyünk valamit
}

A következő lépések segítenek abban, hogy alkalmazásunk képes legyen olvasni a szenzoradatokat:

1. Nyissuk meg az activity_main.xml fájlt, és módosítsuk a meglévő TextView elemet, hogy képes legyen megjeleníteni a szenzor adatokat.

2. Az MainActivity.java fájlban deklaráljunk globális változókat, amelyek tárolják a SensorManager, a Sensor és a TextView objektumokat.

3. Hozzunk létre egy SensorEventListener osztályt, amely a következő módon néz ki:

java
Copy code
private SensorEventListener mSensorListener = new SensorEventListener() {
    @Override

    public void onSensorChanged(SensorEvent event) {

        mTextView.setText(String.valueOf(event.values[0]));
    }
    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
        // Nincs teendő
    }
};

4. A onResume() és onPause() metódusokban regisztráljuk és töröljük a szenzor eseményeket, hogy csökkentsük az akkumulátor fogyasztását.

java
Copy code
@Override

protected void onResume() {
    super.onResume();
    mSensorManager.registerListener(mSensorListener, mSensor, SensorManager.SENSOR_DELAY_NORMAL);
}
@Override
protected void onPause() {
    super.onPause();
    mSensorManager.unregisterListener(mSensorListener);
}

5. A onCreate() metódusban inicializáljuk az érzékelőt és a szükséges komponenseket:

java
Copy code
mTextView = (TextView)findViewById(R.id.textView);
mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);

Miután elkészítettük az alkalmazást, a valódi eszközeinkkel tesztelhetjük, és láthatjuk az érzékelő által szolgáltatott nyers adatokat.

A környezeti érzékelők kezelése viszonylag egyszerű, mivel csak egy adatot kell kezelniük. Azonban a pozicionáló érzékelők, mint a geomágneses mező és a közelségérzékelők, valamint a mozgás érzékelők, mint a gyorsulásmérő és a giroszkóp, több adatot is szolgáltathatnak, és ezeket megfelelően kell feldolgozni.