Jak efektivně komunikovat mezi fragmenty v Android aplikaci?

Vytvoření aplikace s více fragmenty je běžnou praxí v moderních aplikacích pro Android, kde se využívají různé vzory pro správu rozložení obrazovky, zejména při práci s vertikálním a horizontálním režimem. Tento přístup je obzvláště užitečný, když je třeba zajistit, aby aplikace správně reagovala na změnu orientace obrazovky a uživatelské interakce s různými částmi aplikace. Následující text podrobně vysvětluje, jak komunikovat mezi fragmenty pomocí jednoduchého, ale efektivního vzoru.

Vytvoření fragmentů a zajištění jejich komunikace

Pro začátek je třeba vytvořit dva hlavní fragmenty: MasterFragment, který bude obsahovat seznam položek, a DetailFragment, který bude zobrazovat detaily o vybrané položce. Master Fragment bude rozšiřovat třídu ListFragment, což znamená, že nebude potřebovat vlastní layout, ale využije standardní seznam položek.

Příklad kódu pro implementaci posluchače v MasterFragment:

java
Copy code
public interface OnMasterSelectedListener {

    public void onItemSelected(String countryName);

}

Dále je třeba implementovat metodu pro nastavení tohoto posluchače:

java
Copy code
private OnMasterSelectedListener mOnMasterSelectedListener = null;

public void setOnMasterSelectedListener(OnMasterSelectedListener listener) {

    mOnMasterSelectedListener = listener;
}

V metodě onViewCreated() se nastaví seznam položek a bude přidán posluchač pro výběr položky, který spustí metodu posluchače, jakmile je položka vybrána:

java
Copy code
public void onViewCreated(View view, Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);

    String[] countries = new String[]{"China", "France", "Germany", "India", "Russia", "United Kingdom", "United States"};

    ListAdapter countryAdapter = new ArrayAdapter(getActivity(), android.R.layout.simple_list_item_1, countries);
    setListAdapter(countryAdapter);
    getListView().setChoiceMode(ListView.CHOICE_MODE_SINGLE);
    getListView().setOnItemClickListener(new AdapterView.OnItemClickListener() {
        @Override

        public void onItemClick(AdapterView parent, View view, int position, long id) {

            if (mOnMasterSelectedListener != null) {
                mOnMasterSelectedListener.onItemSelected(((TextView) view).getText().toString());
            }
        }
    });
}

DetailFragment a zobrazení podrobností

Po implementaci MasterFragment přichází na řadu DetailFragment, který se stará o zobrazení detailů vybrané položky. Tento fragment rozšiřuje třídu Fragment a má svůj vlastní layout, který bude naplněn daty předanými z MasterFragment. V tomto případě se používá klíč KEY_COUNTRY_NAME, který obsahuje název vybrané země.

java
Copy code
public static String KEY_COUNTRY_NAME = "KEY_COUNTRY_NAME";

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    return inflater.inflate(R.layout.fragment_detail, container, false);
}
public void onViewCreated(View view, Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    Bundle bundle = getArguments();
    if (bundle != null && bundle.containsKey(KEY_COUNTRY_NAME)) {
        showSelectedCountry(bundle.getString(KEY_COUNTRY_NAME));
    }
}

public void showSelectedCountry(String countryName) {

    ((TextView) getView().findViewById(R.id.textViewCountryName)).setText(countryName);
}

Orientace obrazovky a výměna fragmentů

Aplikace musí správně reagovat na změnu orientace obrazovky. K tomu slouží přepínání mezi vertikálním (portrait) a horizontálním (landscape) režimem. Pro vertikální režim aplikace vymění fragmenty, takže MasterFragment a DetailFragment se budou zobrazovat na samostatných obrazovkách. V horizontálním režimu budou oba fragmenty zobrazeny vedle sebe.

java
Copy code
boolean dualPane;

Následuje kód, který se postará o načítání správného fragmentu na základě orientace:

java
Copy code
protected void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    MasterFragment masterFragment = null;
    FrameLayout frameLayout = (FrameLayout) findViewById(R.id.frameLayout);
    if (frameLayout != null) {
        dualPane = false;
        FragmentTransaction fragmentTransaction = getSupportFragmentManager().beginTransaction();
        masterFragment = (MasterFragment) getSupportFragmentManager().findFragmentByTag("MASTER");
        if (masterFragment == null) {
            masterFragment = new MasterFragment();
            fragmentTransaction.add(R.id.frameLayout, masterFragment, "MASTER");
        }
    }
}

Další kroky pro vývoj

Aplikace musí také obsahovat správně nakonfigurovaný layout pro vertikální i horizontální orientaci. Pro tento účel je potřeba vytvořit různé layout soubory pro každý režim: res/layout pro vertikální orientaci a res/layout-land pro horizontální orientaci.

Kromě toho je důležité při práci s více fragmenty nezapomenout na správnou synchronizaci mezi fragmenty a hostitelskou aktivitou. Komunikace mezi fragmenty musí být efektivní a přehledná, aby se zajistila plynulá interakce uživatele s aplikací.

Tento přístup nejen zjednodušuje vývoj aplikace, ale také zajišťuje její flexibilitu a přizpůsobivost na různé typy zařízení a orientace obrazovky.

Jak fungují aktivity v Androidu a jak je efektivně využít?

Ve světě vývoje pro Android jsou aktivity základními stavebními bloky aplikací. Třída Activity poskytuje rozhraní mezi aplikací a obrazovkou zařízení. V podstatě jde o to, že každá obrazovka (nebo část obrazovky) v aplikaci je definována jako aktivita. Aplikace mohou mít jednu nebo více aktivit, které spolu mohou komunikovat, přičemž každá aktivita má svůj vlastní životní cyklus. V tomto textu se podíváme na to, jak aktivity deklarovat, spouštět, jak přecházet mezi nimi a jak přenášet data.

V Androidu jsou aktivity deklarovány v souboru AndroidManifest.xml. Tento soubor informuje systém o aktivitách, které aplikace využívá, a jak je lze volat. Většina aplikací bude mít minimálně jednu aktivitu, která je zobrazená na domovské obrazovce jako ikona a slouží jako hlavní vstupní bod do aplikace. V některých případech, zejména u aplikací bez uživatelského rozhraní, se aktivita vůbec nemusí použít, například v případě aplikací běžících na pozadí.

Jak deklarovat aktivitu

Každá aktivita musí být deklarována v manifestu aplikace, což je nezbytný krok pro její správnou registraci v systému. Tento krok je jednoduchý: ve manifestu je třeba přidat odpovídající položku pro každou aktivitu, která bude součástí aplikace. Tento krok zajistí, že systém Android bude vědět, jak tuto aktivitu spustit a jak s ní interagovat. Například v případě aplikace, která má hlavní obrazovku, bude deklarace vypadat následovně:

xml
Copy code
<activity android:name=".MainActivity">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

Tato deklarace říká systému, že MainActivity je hlavní aktivitou, která by měla být spuštěna při otevření aplikace.

Spouštění aktivit a předávání dat

Předávání dat mezi aktivitami se obvykle provádí prostřednictvím "extras" připojených k intentu. Například:

java
Copy code
Intent intent = new Intent(this, SecondActivity.class);
intent.putExtra("KEY", "Some data");
startActivity(intent);

V druhé aktivitě pak můžete získat tato data takto:

java
Copy code
String data = getIntent().getStringExtra("KEY");

Tímto způsobem lze snadno předávat textové hodnoty, čísla, nebo i složitější objekty, které jsou serializovány.

Životní cyklus aktivit

Jedním z klíčových aspektů práce s aktivitami je pochopení jejich životního cyklu. Každá aktivita v Androidu prochází několika fázemi: onCreate(), onStart(), onResume(), onPause(), onStop(), onRestart() a onDestroy(). Tyto metody umožňují aplikacím reagovat na změny stavu, jako je například přechod do pozadí nebo znovuobnovení po přerušení. Pochopení těchto fází je nezbytné pro správu paměti a správnou interakci s uživatelským rozhraním.

Příklad implementace životního cyklu:

java
Copy code
@Override

protected void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
}
@Override
protected void onResume() {
    super.onResume();
    // Aktivita je opět na popředí
}
@Override
protected void onPause() {
    super.onPause();
    // Aktivita je na pozadí
}

Správné použití životního cyklu aktivit je základem pro správné řízení prostředků a plynulý chod aplikace.

Ukládání a obnovení dat

Při práci s aktivitami je důležité mít na paměti, jak správně zacházet s daty, zejména pokud jde o uložení stavu aktivity. Pokud uživatel přejde na jinou aktivitu nebo pokud je aplikace přerušena (například voláním jiné aplikace), může být nutné zachovat stav aktivity. Tento stav lze uložit pomocí metody onSaveInstanceState() a obnovit v metodě onRestoreInstanceState(). Takový mechanismus je nezbytný pro aplikace, které musí udržovat kontinuální uživatelský zážitek.

Příklad:

java
Copy code
@Override

public void onSaveInstanceState(Bundle outState) {

    super.onSaveInstanceState(outState);
    outState.putString("key", "value");
}
@Override
public void onRestoreInstanceState(Bundle savedInstanceState) {
    super.onRestoreInstanceState(savedInstanceState);

    String value = savedInstanceState.getString("key");

}

Tento mechanismus umožňuje aplikacím efektivně reagovat na různé scénáře a zajistit, aby uživatel nikdy neztratil svou práci nebo pokrok.

Důležitost správného řízení aktivit

Pro vývojáře Android aplikací je nezbytné nejen pochopit, jak správně deklarovat, spouštět a předávat data mezi aktivitami, ale i jak optimalizovat výkon a paměťovou náročnost. Využití životního cyklu aktivit a jejich efektivní správa může výrazně ovlivnit celkový zážitek uživatele. Správné zacházení s aktivitami umožňuje zajistit plynulý chod aplikace a minimalizovat spotřebu zdrojů.

Tento text poskytuje základy pro práci s aktivitami, ale existuje mnoho pokročilých technik, které mohou být pro specifické aplikace nezbytné. Porozumění tomu, jak aktivity fungují v širším kontextu aplikace, je klíčem k efektivnímu vývoji aplikací pro Android.

Jak správně zpracovávat dotyky a gesta na obrazovce v aplikacích pro Android

Základní interakce s uživatelem, jako jsou kliknutí nebo dlouhý stisk, lze snadno implementovat pomocí posluchačů událostí (event listeners). Většina těchto interakcí je definována na úrovni View komponenty, jako jsou tlačítka, textová pole nebo obrázky. V tomto případě použijeme tlačítko jako příklad, ale podobné postupy lze aplikovat i na jiné komponenty.

Představme si následující kód v souboru activity_main.xml, kde tlačítko nahrazuje výchozí textovou komponentu:

xml
Copy code
<Button

    android:id="@+id/button"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Klikni mě!" />

Dále, v souboru MainActivity.java, přidáme kód pro detekci kliknutí a dlouhého stisknutí:

java
Copy code
Button button = (Button) findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Toast.makeText(MainActivity.this, "Kliknutí", Toast.LENGTH_SHORT).show();
    }
});
button.setOnLongClickListener(new View.OnLongClickListener() {
    @Override
    public boolean onLongClick(View v) {
        Toast.makeText(MainActivity.this, "Dlouhý stisk", Toast.LENGTH_SHORT).show();
        return true;
    }
});

Tento kód nastavuje posluchače pro klasické kliknutí a dlouhý stisk, přičemž je zajištěno, že uživatel obdrží odpovídající zpětnou vazbu (v tomto případě pomocí Toast zpráv).

Pokud bychom se chtěli zaměřit na rozpoznávání gest, proces se stává o něco složitější. Rozpoznání gest obvykle zahrnuje dvě fáze: sběr dat o pohybech uživatele a jejich analýzu, která určuje, zda daný pohyb odpovídá určitému gestu. Android poskytuje třídu GestureDetector, která nám tuto analýzu výrazně zjednodušuje. Pomocí této třídy můžeme rozpoznat několik běžných gest, jako jsou:

• onDown()

• onFling()

• onLongPress()

• onScroll()

• onDoubleTap()

• onSingleTapConfirmed()

Vytvoření aplikace pro rozpoznávání jednoho či dvojitého kliknutí, například, by vypadalo následovně:

Nejdříve definujeme globální proměnnou pro GestureDetectorCompat:

java
Copy code
private GestureDetectorCompat mGestureDetector;

Následně vytvoříme třídu pro posluchače gest, která bude reagovat na jednotlivá gesta:

java
Copy code
private class GestureListener extends GestureDetector.SimpleOnGestureListener {
    @Override

    public boolean onSingleTapConfirmed(MotionEvent e) {

        Toast.makeText(MainActivity.this, "Jednoduché kliknutí", Toast.LENGTH_SHORT).show();
        return super.onSingleTapConfirmed(e);
    }
    @Override
    public boolean onDoubleTap(MotionEvent e) {
        Toast.makeText(MainActivity.this, "Dvojité kliknutí", Toast.LENGTH_SHORT).show();
        return super.onDoubleTap(e);
    }
}

Tuto třídu poté použijeme v metodě onTouchEvent():

java
Copy code
@Override
public boolean onTouchEvent(MotionEvent event) {
    mGestureDetector.onTouchEvent(event);
    return super.onTouchEvent(event);
}

A nakonec v metodě onCreate() inicializujeme GestureDetectorCompat:

java
Copy code
mGestureDetector = new GestureDetectorCompat(this, new GestureListener());

Tímto způsobem bude aplikace schopná rozpoznat základní gesta, jako jsou jednoduché a dvojité kliknutí.

Pro rozpoznávání více dotykových gest, jako je například gesto pinch-to-zoom (špetka pro zvětšení), Android poskytuje třídu ScaleGestureDetector. Pomocí této třídy lze snadno implementovat gesto pro zoomování pomocí dvou prstů. V následujícím příkladu použijeme ScaleGestureDetector k implementaci zoomování obrázku:

Nejdříve definujeme potřebné proměnné:

java
Copy code
private ScaleGestureDetector mScaleGestureDetector;

private float mScaleFactor = 1.0f;
private ImageView mImageView;

Poté přidáme detekci gesta do metody onTouchEvent():

java
Copy code
@Override

public boolean onTouchEvent(MotionEvent motionEvent) {
    mScaleGestureDetector.onTouchEvent(motionEvent);
    return true;
}

A konečně implementujeme třídu pro detekci změny měřítka (zoomování):

java
Copy code
private class ScaleListener extends ScaleGestureDetector.SimpleOnScaleGestureListener {

    @Override
    public boolean onScale(ScaleGestureDetector scaleGestureDetector) {
        mScaleFactor *= scaleGestureDetector.getScaleFactor();
        mImageView.setScaleX(mScaleFactor);
        mImageView.setScaleY(mScaleFactor);
        return true;
    }
}

Tímto způsobem uživatel může použít gesto pinch-to-zoom k zvětšení nebo zmenšení obrázku na obrazovce.

Pochopení způsobu, jakým Android zpracovává dotykové události a gesta, je klíčové pro vytváření interaktivních a intuitivních aplikací. Ačkoli zde byly zmíněny pouze základní příklady, Android poskytuje mnoho dalších možností, jak reagovat na složitější gesta a interakce, jako je víceprstová gesta nebo kombinace různých pohybů na obrazovce. Pomocí kombinace posluchačů událostí a pokročilých nástrojů, jako je GestureDetector, lze vytvořit aplikace, které budou nejen funkční, ale také uživatelsky přívětivé a responzivní.

Jak ručně zrušit požadavky ve Volley

Pokud jste ještě neprošli předchozím návodem, kde se učíte, jak začít pracovat s Volley pro internetové požadavky, doporučujeme projít kroky 1–5 a přidat modul Volley do své aplikace. Poté budete připraveni pokračovat v implementaci funkce pro zrušení požadavků.

Začneme tím, že vytvoříme nový projekt v Android Studiu, který pojmenujeme CancelVolleyRequest. Zvolíme výchozí nastavení pro "Phone & Tablet" a jako typ aktivity vybereme "Empty Activity". Tímto způsobem připravíme základní strukturu pro naši aplikaci.

Jakmile máte projekt připravený a Volley správně přidaný, pokračujte těmito kroky:

1. Otevřete soubor activity_main.xml a nahraďte stávající TextView následujícím XML kódem. Tento prvek bude sloužit pro zobrazení výsledku požadavku nebo chyby.

2. V souboru MainActivity.java přidejte následující globální proměnnou:

   java
   Copy code
   RequestQueue mRequestQueue;
   

3. Upravte metodu onCreate() tak, aby inicializovala RequestQueue:

   java
   Copy code
   mRequestQueue = Volley.newRequestQueue(this);
   
   

4. Vytvořte metodu sendRequest(), která bude odesílat HTTP požadavek. Tento kód je podobný předchozímu příkladu, ale s několika změnami:

   java
   Copy code
   public void sendRequest(View view) {
   
       final TextView textView = (TextView) findViewById(R.id.textView);
   
       String url = "https://www.packtpub.com/";
   
       StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
   
           new Response.Listener<String>() {
               @Override
               public void onResponse(String response) {
                   textView.setText(response.substring(0, 500));
               }
           },
           new Response.ErrorListener() {
               @Override
   
               public void onErrorResponse(VolleyError error) {
   
                   textView.setText("onErrorResponse(): " + error.getMessage());
               }
           });
       stringRequest.setTag(this); // Nastavení tagu pro zrušení požadavku
       mRequestQueue.add(stringRequest);
       finish(); // Uzavření aktivity po odeslání požadavku
   }
   

5. Přidejte metodu close() pro tlačítko, které umožní uzavřít aktivitu:

   java
   Copy code
   public void close(View view){
       finish();
   }
   

6. Nezapomeňte přidat přepsání metody onStop(), která zaručí zrušení všech požadavků při zastavení aktivity:

   java
   Copy code
   @Override
   
   protected void onStop() {
       super.onStop();
       mRequestQueue.cancelAll(this); // Zrušení všech požadavků s tímto tagem
   }
   

Jakmile tyto kroky dokončíte, můžete aplikaci spustit na zařízení nebo emulátoru. Po stisknutí tlačítka sendRequest se odešle HTTP požadavek, a pokud je aktivita zastavena nebo uzavřena, požadavky budou zrušeny.

Proč je zrušení požadavků tak důležité? Použití metody cancelAll() na RequestQueue s příslušným tagem zaručuje, že všechny požadavky spojené s daným tagem budou zrušeny. V tomto příkladu je tagem samotná aktivita (pomocí this), ale můžete použít libovolný objekt jako tag pro lepší organizaci požadavků. Tento přístup nejenže usnadňuje správu požadavků, ale také zajišťuje, že po zrušení požadavků už nebudeme dostávat odpovědi na tyto zrušené požadavky.

Zrušení požadavků ve Volley také slouží jako příklad pro defensivní programování. Tím, že zaručujeme, že všechny požadavky budou zrušeny, nemusíme přidávat kód pro kontrolu, zda je aktivita stále platná. Knihovna Volley sama zajišťuje, že po zrušení požadavku už neobdržíme žádnou odpověď. Tento přístup je klíčový pro stabilitu aplikace a pro zamezení nechtěného zpracování dat, která již nejsou relevantní.

Pokud potřebujete pracovat s různými formáty odpovědí, jako je JSON, Volley poskytuje pohodlné metody, jak pracovat s JsonObjectRequest nebo JsonArrayRequest, které usnadňují zpracování dat. Předchozí kapitola popisuje, jak posílat požadavky na JSON webové služby, ale princip zrušení požadavků zde platí stejně.

Další důležitou součástí je pochopení, že efektivní správa síťových požadavků zajišťuje nejen vyšší výkon aplikace, ale i lepší uživatelský zážitek, protože aplikace se vyhne čekání na nevyžádané odpovědi a nebude zbytečně vyčerpávat prostředky zařízení.

Jak Android ukládá a obnovuje stav aktivit: Práce se stavy a přetrvávající data

Jedním z hlavních nástrojů pro správu stavu je metoda onSaveInstanceState(), která je volána při změně stavu aktivity, například při otočení zařízení. Tato metoda poskytuje způsoby, jak uložit data, která mohou být ztracena při změně orientace nebo přerušení aplikace. Tato data jsou obvykle uložena do objektu Bundle, který obsahuje dvojice jméno/hodnota. Jakmile je stav obnoven, používá se metoda onRestoreInstanceState(), která umožňuje aplikaci získat uložené hodnoty.

Je důležité vědoma si toho, že ne všechny komponenty Androidu automaticky ukládají a obnovují svůj stav. Například komponenta TextView neuchovává svůj stav automaticky. Pokud chceme zajistit, že konkrétní komponenty budou uloženy, musíme jim přiřadit unikátní identifikátor (android:id), což umožní systému uchovávat jejich hodnoty při změnách.

Dále je důležité rozlišovat mezi metodami onSaveInstanceState() a onCreate(). Zatímco onRestoreInstanceState() je určena primárně k obnově stavu po jeho uložení, k tomu může být využita i metoda onCreate(). Když obnovujeme stav v metodě onCreate(), je nutné si být vědomi, že savedInstanceState může být null při prvotním spuštění aplikace. Pokud data v této metodě nejsou k dispozici, je nutné zajistit, že zpracování probíhá pouze v případě, že existují platné hodnoty.

Abychom použili SharedPreferences, přidáme metodu onPause(), která zajistí uložení dat, než aktivita přestane běžet. V metodě onPause() se použije objekt SharedPreferences.Editor, který umožňuje zapisovat hodnoty do souboru preferencí. Data se uloží pomocí metody commit(), což je nezbytný krok pro zajištění trvalého uložení hodnot.

Další variantou pro správu preferencí je metoda getSharedPreferences(), která umožňuje spravovat více souborů s preferencemi. Tento přístup je výhodný, když potřebujeme rozlišit mezi různými typy údajů nebo konfigurací aplikace, které mají být uchovávány odděleně. Parametr name umožňuje specifikovat název souboru, zatímco mode určuje přístupová práva (např. MODE_PRIVATE pro soukromý přístup).

Kromě samotného ukládání a obnovování stavu aktivit je třeba mít na paměti i celkový životní cyklus aktivity. Android je operační systém, který velmi efektivně spravuje využívání systémových prostředků, zejména paměti. To znamená, že aktivita může být odstraněna z paměti, pokud systém potřebuje uvolnit místo pro jiné úkoly. Proto je nezbytné porozumět různým fázím životního cyklu aktivity, které jsou uvedeny v metodách jako onStart(), onResume(), onPause(), onStop() a onDestroy().

Každá z těchto metod reprezentuje určitou fázi života aktivity. Například metoda onStart() se volá, když aktivita začíná interagovat s uživatelem, a metoda onPause() se aktivuje, když aplikace přechází na pozadí nebo jiná aktivita přichází do popředí. Pokud aplikace není v popředí, ale stále běží na pozadí, je v pauzovaném stavu (paused). Když je aplikace zcela ukončena, je volána metoda onDestroy().

Pokud správně implementujeme životní cyklus a metody pro správu stavu aktivit, umožníme uživatelům mít plynulý a bezproblémový zážitek z aplikace, i když dochází k přerušení činnosti nebo přechodu mezi různými obrazovkami.