Jak pracovat s daty v Android aplikacích: Ukládání a čtení souborů a preferencí

V dnešních mobilních aplikacích je uchovávání a načítání dat klíčovým prvkem, který ovlivňuje uživatelský zážitek. Ať už jde o uložení jména uživatele, nebo o uchovávání nastavení, proces práce s daty je v Androidu velmi flexibilní. Tento text se zaměřuje na metody práce s interním úložištěm a preferencemi, které Android nabízí.

Pro uchovávání jednoduchých hodnot, jako jsou uživatelská jména nebo nastavení aplikace, se v Androidu běžně využívají SharedPreferences. Tato metoda umožňuje aplikacím ukládat malé množství dat, které zůstávají i po restartu aplikace.

Prvním krokem při práci s SharedPreferences je otevření souboru, do kterého budeme zapisovat nebo z něj číst data. Tento soubor je specifický pro danou aplikaci a je přístupný pouze jí. Začneme přidáním globálních proměnných:

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

private EditText mEditTextName;

V metodě onCreate() pak uložíme referenci na komponenty uživatelského rozhraní, jako je TextView a EditText, a načteme uložené jméno, pokud existuje:

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);

Pokud uživatel již zadal své jméno, aplikace mu přivítá zpět. Pokud není žádné jméno uloženo, zobrazí se základní pozdrav.

Další klíčovou metodou je metoda saveName(), která zajistí, že zadané jméno bude uložené:

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

Tato metoda uloží jméno do preferencí. Je důležité si uvědomit, že bez použití metody commit() změny nebudou uloženy.

Pokud je potřeba ukládat data pro více uživatelů nebo v různých souborech, můžeme použít metodu getSharedPreferences(), která umožňuje vytvořit různé soubory pro různé typy preferencí.

Další možností pro práci s daty je využití interního úložiště. Pokud nám samotné SharedPreferences nestačí, můžeme pracovat s textovými nebo binárními soubory v interním úložišti. Tento proces zahrnuje čtení a zápis souborů, což je trochu složitější než práce s preferencemi, ale je to velmi užitečné pro uchovávání větších objemů dat.

Při práci s interním úložištěm začneme přidáním souboru, do kterého budeme zapisovat textová data. Nejprve si otevřeme XML soubor pro rozvržení uživatelského rozhraní a přidáme prvky, které potřebujeme:

xml
Copy code
<EditText android:id="@+id/editText" ... />

<Button android:onClick="writeFile" ... />

<Button android:onClick="readFile" ... />

V kódu ActivityMain.java deklarujeme globální proměnné a vytvoříme metody pro zápis a čtení souboru:

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

V metodě onCreate() inicializujeme EditText:

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

Pro zápis do souboru použijeme následující metodu writeFile():

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();
    }
}

Pro čtení z tohoto souboru použijeme metodu readFile():

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

Zde používáme FileOutputStream pro zápis a InputStream pro čtení. Při čtení využíváme BufferedReader, který nám umožňuje pohodlně načítat soubory po řádcích.

Je důležité také mít na paměti, že cache soubory mohou být automaticky vymazány systémem, pokud dojde k nedostatku místa. Cache je určena pro dočasné soubory, které nejsou klíčové pro fungování aplikace, například pro stažené obrázky nebo články. Tento prostor může být smazán jak systémem, tak uživatelem, ale poskytuje skvélé místo pro uchování dat, které je možné obnovit.

Jak pracovat s daty a optimalizovat přístup v Androidu pomocí SQLite a Loader API

Práce s databázemi v Androidu, a konkrétně s SQLite, je zásadní dovednost pro vývoj mobilních aplikací. SQLite poskytuje jednoduchý způsob, jak ukládat a spravovat data lokálně, ale s růstem aplikace přichází i potřeba efektivnějšího přístupu k těmto datům. Tento text se zaměřuje na základní, ale i pokročilé techniky, které vám umožní optimalizovat práci s daty, včetně migrace databází a používání Loader API pro zajištění plynulosti aplikace.

Při práci s databází SQLite, jak bylo zmíněno, je klíčovým momentem aktualizace její verze. Pokud měníte existující tabulku nebo přidáváte nové sloupce, je nutné správně migrovat data uživatele do nové struktury. Tato migrace je zásadní, protože není zaručeno, že uživatelé budou vždy upgradovat aplikaci v postupném pořadí. Například uživatel může přeskočit některé verze a přejít rovnou na verzi čtyři, což může způsobit problémy, pokud nejsou data správně migrována.

Jedním z největších problémů při práci s databázemi v Androidu je možná zpomalení aplikace, zejména pokud se dotazy na databázi provádějí na hlavním vlákně aplikace. To může způsobit, že aplikace bude reagovat pomalu, nebo dokonce přestane reagovat úplně, což uživateli zprostředkuje chybu „Application Not Responding“ (ANR). Tento problém může být vyřešen pomocí Loader API, které bylo zavedené v Androidu 3.0 a umožňuje provádět dotazy na databázi na pozadí, aniž by se negativně ovlivnila uživatelská zkušenost.

Loader API poskytuje dvě hlavní výhody: dotazy na databázi se automaticky provádějí na pozadí a výsledky dotazů se mohou automaticky aktualizovat, pokud používáte Content Provider jako zdroj dat. Tento přístup výrazně zlepšuje výkon aplikace a zabraňuje blokování hlavního vlákna.

Nejdříve jsme vytvořili vlastní adaptér, který nahrazuje standardní SimpleCursorAdapter. Tento adaptér DictionaryAdapter zajišťuje, že data z databáze jsou správně přiřazena k jednotlivým položkám v seznamu. K tomu jsme použili CursorAdapter, který umožňuje efektivní práci s kurzory. V tomto případě každý záznam v seznamu zobrazuje slovo z databáze.

Pokud používáte Loader API, neměli byste zapomenout na správnou implementaci metod pro obsluhu callbacků. V naší aplikaci to zahrnuje metody pro vytvoření loaderu, zpracování dokončeného načítání dat a resetování loaderu při jeho uvolnění. Důležitý je také způsob, jakým je obnoveno zobrazení dat po provedení změn v databázi, jako je přidání nebo odstranění záznamu.

Kromě efektivního používání Loader API je také kladeno důraz na správu uživatelských dat při změnách v databázové struktuře. Migrations, tedy migrační skripty, by měly být pečlivě navrženy tak, aby se zajistila kompatibilita mezi různými verzemi aplikace a uživatelská data byla vždy konzistentní. To zahrnuje nejen změny ve struktuře tabulek, ale i přidání nových funkcionalit, které mohou vyžadovat úpravu existujících dat.

Pokud aplikace zahrnuje komplexní operace, jako je filtrování nebo třídění dat, může být užitečné přidat další optimalizace, jako jsou indexy v databázi nebo cachování výsledků. Důležitý je rovněž design aplikace, který by měl uživatelskou zkušenost udržet co nejplynulejší i při práci s velkými objemy dat.

Jak správně používat asynchronní úkoly v Androidu, abyste předešli zablokování hlavního vlákna

Dlouhotrvající operace na hlavním vlákně mohou způsobit, že vaše aplikace bude působit pomalu nebo se dokonce úplně zasekne. Pokud aplikace neodpovídá déle než několik sekund, systém pravděpodobně zobrazí dialog „Aplikace neodpovídá“ (ANR), který nabídne možnost ukončení aplikace. Tento scénář je pro vývojáře velmi nechtěný, protože je jedním z hlavních důvodů, proč uživatelé aplikaci odinstalují. Android používá model s jedním vláknem, který je založen na dvou jednoduchých pravidlech:

1. Nezablokujte hlavní vlákno.

2. Všechny operace týkající se uživatelského rozhraní musí běžet na hlavním vlákně.

Když Android spustí vaši aplikaci, automaticky vytvoří hlavní (UI) vlákno, které je zodpovědné za všechny operace týkající se uživatelského rozhraní. Pravidlo „Nezablokujte hlavní vlákno“ znamená, že jakékoli dlouhotrvající nebo blokující úkoly musí běžet na pozadí, nikoliv na hlavním vlákně. To je důvod, proč by všechny síťové operace měly běžet mimo hlavní vlákno. Android nabízí několik možností, jak pracovat s pozadím:

• Activity.runOnUiThread()

• View.post()

• View.postDelayed()

• Handler

• AsyncTask

Zaměříme se na třídu AsyncTask, která je pro tento účel ideální. Její výhoda spočívá v tom, že se nemusíte starat o přímou práci s pozadím nebo vlákny, protože AsyncTask vše zajišťuje za vás.

Začínáme

xml
Copy code
<Button
    android:id="@+id/buttonStart"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Start Task"/>

V souboru MainActivity.java přidejte následující globální proměnnou pro tlačítko:

java
Copy code
Button mButtonStart;

Nyní vytvoříme třídu AsyncTask, která bude vykonávat úkol na pozadí:

java
Copy code
private class CountingTask extends AsyncTask<Integer, Void, Integer> {
    @Override
    protected Integer doInBackground(Integer... params) {
        int count = params[0];

        for (int x = 0; x <= count; x++) {

            // Dlouhotrvající operace
        }
        return count;
    }
    @Override
    protected void onPostExecute(Integer result) {
        super.onPostExecute(result);
        mButtonStart.setEnabled(true); // Po dokončení operace povolíme tlačítko
    }
}

Dále inicializujte tlačítko v metodě onCreate():

java
Copy code
mButtonStart = (Button) findViewById(R.id.buttonStart);

A přidejte metodu pro kliknutí na tlačítko:

java
Copy code
public void start(View view) {
    mButtonStart.setEnabled(false);
    new CountingTask().execute(10000000);
}

Nyní máte jednoduchou aplikaci, která spustí úkol na pozadí, když uživatel klikne na tlačítko.

Jak to funguje

Je důležité si uvědomit, že každá instance AsyncTask může být spuštěna pouze jednou. Pokus o opětovné spuštění AsyncTask pomocí execute() po jejím dokončení způsobí výjimku. Proto je třeba pro každý nový úkol vytvořit novou instanci AsyncTask.

Další aspekty práce s AsyncTask

Ačkoli AsyncTask poskytuje jednoduchý způsob, jak pracovat s asynchronními úkoly, existují situace, kdy je potřeba zvážit pokročilejší metody. Například pokud aplikace používá AsyncTask ve Fragmentu, je důležité mít na paměti, že AsyncTask může pokračovat v běhu i po změně orientace obrazovky (např. při otáčení zařízení), což může vést k nebezpečným situacím, kdy úkol reaguje na již zničený Activity. V těchto případech je lepší použít Loader nebo zajistit správnou správu životního cyklu aktivit a fragmentů.

Parametry v AsyncTask

Jednou z nejčastějších komplikací při používání AsyncTask jsou generické parametry, které jsou potřeba při definici třídy. Třída AsyncTask používá tři parametry:

• Params: Typ parametrů, které jsou předány do metody doInBackground().

• Progress: Typ parametrů pro aktualizace postupu.

• Result: Typ výsledků, které jsou vráceny metodou onPostExecute().

Pro každou instanci třídy AsyncTask je potřeba deklarovat typy těchto parametrů podle toho, jaký druh dat s nimi budete pracovat.

Zrušení úkolu

Pro efektivní použití AsyncTask je také důležité vzít v úvahu, že pokud aplikace provádí dlouhotrvající úkoly, měly by být navrženy tak, aby vždy správně reagovaly na změny stavu aplikace, jako je rotace obrazovky nebo její dočasné pozastavení. To může zahrnovat například využití Loader nebo správnou správu životního cyklu asynchronních úkolů, aby nedocházelo k jejich ztrátě nebo nečekaným chybám.

Jak integrovat Google Cloud Messaging (GCM) a Google sign-in do aplikace

Implementace Google Cloud Messaging (GCM) v aplikaci vyžaduje několik klíčových kroků, které zahrnují registraci aplikace u serveru GCM, příjem zpráv a odesílání tokenů na server. Před tím, než se rozhodneme pro konkrétní implementaci, je třeba si uvědomit, že většina kódu souvisejícího s GCM je již obsažena v Google API, což výrazně zjednodušuje proces implementace. Nicméně, stále existuje několik důležitých kroků, které je nutné správně nastavit, aby vše fungovalo hladce.

V první fázi je třeba vytvořit službu pro registraci s GCM serverem. Tato služba, například GCMRegistrationService, rozšiřuje třídu IntentService a zajišťuje získání tokenu, který je nutný pro komunikaci se serverem GCM. Tento token slouží k jednoznačné identifikaci zařízení, na které budou zprávy odesílány. Aby bylo možné zpracovat token na pozadí a neblokovat hlavní vlákno aplikace, používá se IntentService, který tento úkol provádí na pozadí.

Příklad kódu pro GCMRegistrationService:

java
Copy code
public class GCMRegistrationService extends IntentService {

    private final String SENT_TOKEN = "SENT_TOKEN";

    public GCMRegistrationService() {
        super("GCMRegistrationService");
    }
    @Override
    protected void onHandleIntent(Intent intent) {
        super.onCreate();

        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);

        try {
            InstanceID instanceID = InstanceID.getInstance(this);
            String token = instanceID.getToken(getString(R.string.gcm_defaultSenderId), 
                GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
            Log.i("GCMRegistrationService", "GCM Registration Token: " + token);
            sharedPreferences.edit().putBoolean(SENT_TOKEN, true).apply();
        } catch (Exception e) {
            sharedPreferences.edit().putBoolean(SENT_TOKEN, false).apply();
        }
    }
}

Další důležitou součástí implementace je třída GCMInstanceService, která zajišťuje obnovení tokenu, pokud je potřeba. Tato třída dědí od InstanceIDListenerService a spouští novou službu pro registraci při obnovení tokenu.

Příklad kódu pro GCMInstanceService:

java
Copy code
public class GCMInstanceService extends InstanceIDListenerService {

    @Override
    public void onTokenRefresh() {
        Intent intent = new Intent(this, GCMRegistrationService.class);
        startService(intent);
    }
}

Třída GCMService, která dědí od GcmListenerService, je odpovědná za zpracování příchozích zpráv. Když zařízení obdrží zprávu, volá se metoda onMessageReceived, která může následně zpracovat obsah zprávy.

Příklad kódu pro GCMService:

java
Copy code
public class GCMService extends GcmListenerService {
    @Override

    public void onMessageReceived(String from, Bundle data) {

        super.onMessageReceived(from, data);
        Log.i("GCMService", "onMessageReceived(): " + data.toString());
    }
}

Pokud jde o samotnou registraci aplikace u serveru GCM, je důležité si uvědomit, že samotný kód pro získání tokenu je poměrně jednoduchý, ale celkové nastavení aplikace včetně zajištění správného API a autentizace vyžaduje pečlivý přístup.

java
Copy code
String token = instanceID.getToken(getString(R.string.gcm_defaultSenderId), 
    GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);

Pro odesílání tokenu na server po jeho získání je nutné implementovat serverovou logiku, která umožní správu a distribuci těchto tokenů pro jednotlivé zařízení.

Pokud máte aplikaci připravenou na příjem zpráv, je důležité, aby vaše aplikace správně reagovala na volání onMessageReceived a vyhodnotila obsah zprávy. GCM sám o sobě pouze doručí zprávu, ale aplikace musí mít implementovány reakce na přijatá data.

java
Copy code
private boolean isGooglePlayServicesAvailable() {
    GoogleApiAvailability googleApiAvailability = GoogleApiAvailability.getInstance();

    int resultCode = googleApiAvailability.isGooglePlayServicesAvailable(this);

    if (resultCode != ConnectionResult.SUCCESS) {
        if (googleApiAvailability.isUserResolvableError(resultCode)) {
            googleApiAvailability.getErrorDialog(this, resultCode, PLAY_SERVICES_RESOLUTION_REQUEST).show();
        } else {
            Toast.makeText(MainActivity.this, "Unsupported Device", Toast.LENGTH_SHORT).show();
            finish();
        }
        return false;
    }
    return true;
}

Je důležité nezapomenout na ověření dostupnosti těchto služeb před registrací pro GCM:

java
Copy code
if (isGooglePlayServicesAvailable()) {
    Intent intent = new Intent(this, GCMRegistrationService.class);
    startService(intent);
}

Pokud byste chtěli jednoduše otestovat funkčnost aplikace, je k dispozici testovací aplikace GCM Tester, která vám umožní otestovat vaši implementaci přímo na zařízení nebo v emulátoru.

Implementace GCM a Google sign-in může na první pohled vypadat složitě, ale s využitím správných nástrojů a knihoven může být tento proces značně zjednodušen. Důležité je dbát na správné nastavení všech komponent, správné zpracování tokenů a správnou odpověď na příchozí zprávy.