Hogyan készítsünk és kezeljünk menüket Android alkalmazásban?

A Chrome menü szekcióját ábrázoló képernyőfotó egyik legszembetűnőbb jellemzője, hogy a menü kinézete a képernyő méretétől függően változik. Alapértelmezés szerint a menüelemek az "Overflow" menübe kerülnek — ez az a menü, amelyet akkor láthatunk, amikor rákattintunk a három pontra a jobb oldali szélen. A menük jellemzően XML fájlokban jönnek létre (mint sok más Android erőforrás), és a res/menu könyvtárban tárolódnak, de kódban is létrehozhatók. A menü erőforrás létrehozásához használjuk a következő elemet:

xml
Copy code
<menu>

    <item
        android:id="@+id/menu_settings"
        android:title="@string/settings"
        android:icon="@drawable/ic_settings"
        android:showAsAction="ifRoom|withText"/>
</menu>

A menüelemek leggyakoribb attribútumai a következők:

• id: Ez a standard erőforrás-azonosító.

• title: A megjelenítendő szöveg.

• icon: Ez egy rajzolható erőforrás.

• showAsAction: Ez a következő módon van kifejtve.

• enabled: Alapértelmezetten engedélyezett.

A showAsAction attribútum részletesebb vizsgálata segíthet jobban megérteni, hogyan jelenjenek meg a menüelemek. Az alábbi lehetőségek közül választhatunk:

• ifRoom: A menüelem csak akkor kerül az Action Bar-ra, ha van elég hely.

• withText: Mind a cím, mind az ikon megjelenítésére utal.

• never: A menüelem soha nem jelenik meg az Action Bar-ban; mindig az Overflow menüben lesz látható.

• always: A menüelem mindig az Action Bar-ban fog megjelenni (kisebb hely miatt érdemes takarékosan használni).

A lehetőségek kombinálhatók, például showAsAction="ifRoom|withText" formában. Miután megértettük a menü erőforrásokat, következhet a szabványos Options menü létrehozása és aktiválása.

A menü alapvető működéséhez két alapvető lépést kell követni:

1. A menü definiálása XML-ben.

2. A menü "inflálása" az Activity létrehozásakor.

A menü címét ne keménykódoljuk közvetlenül az XML-ben, hanem definiáljuk azt a strings.xml fájlban, ahonnan azt azonosítóval hivatkozhatjuk. Ha például egy "Beállítások" menüt hozunk létre, akkor azt úgy állíthatjuk be, hogy soha ne jelenjen meg az Action Bar-ban a következő beállítással: showAsAction="never". A menü betöltése az Activity létrehozásakor történik a következő módon:

java
Copy code
@Override

public boolean onCreateOptionsMenu(Menu menu) {
    getMenuInflater().inflate(R.menu.menu_main, menu);
    return true;
}

Amikor a program futtatása után rákattintunk a menü Overflow gombra, a "Beállítások" menüpontot láthatjuk, de ekkor még nem történik semmi. A menüpontok válaszadását az onOptionsItemSelected() callback funkcióval érhetjük el. Például egy egyszerű Toast üzenetet jeleníthetünk meg:

java
Copy code
@Override

public boolean onOptionsItemSelected(MenuItem item) {
    if (item.getItemId() == R.id.menu_settings) {
        Toast.makeText(this, "Settings", Toast.LENGTH_LONG).show();
    } else {
        return super.onContextItemSelected(item);
    }
    return true;
}

Így már működő menüvel rendelkezünk. A callback kezeléséhez mindig vissza kell térni true értékkel, ha már kezeltük az eseményt, egyébként pedig az ősosztály megfelelő metódusát kell meghívni.

Ha nem egy Toast üzenetet szeretnénk megjeleníteni, hanem egy új Activity-t szeretnénk indítani, akkor használhatjuk az Intent objektumot, és meghívhatjuk az startActivity() metódust.

A menüpontok csoportosításával tovább finomíthatjuk a menü kezelését. Android lehetőséget ad a menüpontok láthatóságának, engedélyezésének, és jelölhetőségének kezelésére is. A csoportosítás során az alábbi metódusok állnak rendelkezésre:

• setGroupVisible(): Az összes elem láthatóságának kezelése.

• setGroupEnabled(): Az összes elem engedélyezésének vagy tiltásának kezelése.

• setGroupCheckable(): Az összes elem jelölhetőségének kezelése.

Ezek a csoportosítási lehetőségek segítenek a menüpontok logikai rendszerezésében, miközben biztosítják, hogy a csoportok tagjai egy helyen jelenjenek meg, akár az Action Bar-ban, akár az Overflow menüben.

Endtext

Hogyan működik a Kontextuális Mód, és hogyan használhatjuk Android alkalmazásokban

A Kontextuális Mód általában hosszú nyomással aktiválódik. Ennek implementálása során a következő lépéseket kell követnünk, hogy megfelelően beállítsuk az alkalmazásunkban: egy hosszú kattintás eseményfigyelőt hozunk létre az onCreate() metódusban, majd a startActionMode() segítségével elindítjuk a Kontextuális Módot és átadunk egy ActionMode visszahívást az események kezelésére. Az alábbiakban részletesebben bemutatjuk a megvalósításhoz szükséges lépéseket.

Először két új string erőforrást kell létrehoznunk. Ehhez megnyitjuk a strings.xml fájlt, és hozzáadjuk a következőket:

• Cast

• Print

Miután létrehoztuk a stringeket, most már létrehozhatjuk a menüt is, egy új fájlt készítve a res/menu könyvtárban, amit context_menu.xml néven mentünk el. Az alábbi XML kódot használjuk az új menü létrehozásához.

Ezután hozzá kell adnunk egy ImageView-t az activity_main.xml fájlhoz, amely az esemény elindításához szükséges. Az XML kód a következőképpen néz ki:

xml
Copy code
<ImageView
    android:id="@+id/imageView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:src="@drawable/sample_image" />

java
Copy code
ActionMode mActionMode;

Ezután létrehozzuk az ActionMode visszahívást, amit átadunk a startActionMode() metódusnak. Ehhez a következő kódot illesztjük be a MainActivity osztályba a korábbi kód alá:

java
Copy code
private ActionMode.Callback mActionModeCallback = new ActionMode.Callback() {

    @Override
    public boolean onCreateActionMode(ActionMode mode, Menu menu) {
        mode.getMenuInflater().inflate(R.menu.context_menu, menu);
        return true;
    }
    @Override

    public boolean onPrepareActionMode(ActionMode mode, Menu menu) {

        return false;
    }
    @Override
    public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
        switch (item.getItemId()) {
            case R.id.menu_cast:
                Toast.makeText(MainActivity.this, "Cast", Toast.LENGTH_SHORT).show();
                mode.finish();
                return true;
            case R.id.menu_print:
                Toast.makeText(MainActivity.this, "Print", Toast.LENGTH_SHORT).show();
                mode.finish();
                return true;
            default:
                return false;
        }
    }
    @Override

    public void onDestroyActionMode(ActionMode mode) {

        mActionMode = null;
    }
};

Miután létrehoztuk az ActionMode visszahívást, egyszerűen csak meg kell hívnunk a startActionMode() metódust a Kontextuális Mód elindításához. Ehhez adjuk hozzá az alábbi kódot az onCreate() metódushoz, hogy beállítsuk a hosszú kattintás eseményfigyelőt:

java
Copy code
ImageView imageView = (ImageView)findViewById(R.id.imageView);

imageView.setOnLongClickListener(new View.OnLongClickListener() {
    public boolean onLongClick(View view) {
        if (mActionMode != null) return false;
        mActionMode = startActionMode(mActionModeCallback);
        return true;
    }
});

Most már elindíthatjuk az alkalmazást egy eszközön vagy emulátoron, hogy lássuk a Kontextuális Akciós Sáv (CAB) működését.

A működés megértéséhez fontos figyelembe venni, hogy a Contextual Mode kétféle módot támogat: egyedi nézet módot, amelyet az előző lépésben bemutattunk, és többszörös kijelölési módot (batch mode). A batch mode az, ahol a Kontextuális Mód felülmúlja a régi stílusú Kontextuális Menüt, mivel lehetővé teszi több elem kiválasztását. Ha például e-mail alkalmazást, például a Gmailt vagy fájlkezelőt használsz, akkor biztosan találkoztál már a Kontextuális Móddal, amikor több elemet választasz ki.

A Kontextuális Mód aktiválása során a rendszer az onCreateActionMode() visszahívást hívja meg, amely betölti a menüt és megjeleníti azt a Kontextuális Akciós Sávon. Az alkalmazás felhasználója ezután az eszköz vissza gombjával vagy a menüelemek egyikének kiválasztásával zárhatja le a sávot.

A Kontextuális Mód rend

Hogyan használjuk a különböző érintőképernyő és szenzor funkciókat Android alkalmazásokban?

A modern mobiltelefonok és táblagépek számos fejlett funkcióval rendelkeznek, amelyek a felhasználói élmény javítását szolgálják. Két kiemelkedő terület az érintőképernyős gesztusok, valamint a beépített szenzorok használata. Az Android operációs rendszer támogatja ezeket a lehetőségeket, és könnyen integrálhatók az alkalmazásokba különböző eszközként, widgetként vagy direkt API hívásokkal.

A ScaleGestureDetector például az egyik legegyszerűbb eszköz, amellyel a felhasználók által végzett kétujjas nagyítást (pinch-to-zoom) figyelhetjük meg és kezelhetjük. A onScale() visszahívási metódus segítségével kinyerhetjük az aktuális skálázási tényezőt, amelyet egy ImageView komponenshez rendelhetünk hozzá, hogy vizuálisan jelenítsük meg a képen a változást. Fontos, hogy a skálázás túlzott mértékű elkerülésére, mint például a végtelen nagyítás vagy kicsinyítés, egy egyszerű határértéket alkalmazzunk:

java
Copy code
mScaleFactor = Math.max(0.1f, Math.min(mScaleFactor, 10.0f));

Ez a kód biztosítja, hogy a skálázás ne legyen sem túl kicsi, sem túl nagy. Ezen kívül a ScaleGestureDetector segítségével a gesztusok és a tényleges nagyítás mértéke is könnyen kezelhetővé válik, így a felhasználói élmény teljes mértékben dinamikussá válik.

A Swipe-to-Refresh gesztus egy másik gyakori interakciós forma, amely lehetővé teszi a felhasználóknak, hogy lefelé húzzák a képernyőt a tartalom frissítéséhez. Az Android ezen funkciót már integrálta egy egyszerű widgetbe, a SwipeRefreshLayout-ba, amely segít egyszerűsíteni ezt a folyamatot, különösen listanézeteknél. A következő kód segítségével a felhasználó által indított frissítési művelet figyelhető és kezelhető:

java
Copy code
mSwipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
    @Override
    public void onRefresh() {
        refreshList();
    }
});

A szenzorok kezelése szintén fontos része lehet a mobilalkalmazásoknak. Az Android rendszer széles körű támogatást nyújt a beépített hardverszenzorok számára, például gyorsulásmérők, fényérzékelők vagy giroszkópok. A SensorManager és a SensorEventListener osztályok segítségével az alkalmazások képesek érzékelni a felhasználói mozgásokat, környezeti adatokat vagy eszközhöz kapcsolódó egyéb információkat.

A szenzorok használatának integrálása az Android alkalmazásba egyszerű, és többféle módon történhet. Először is, ha egy alkalmazás például iránytűt használ, akkor azt a AndroidManifest.xml fájlban szükséges deklarálni, hogy az adott szenzor rendelkezésre álljon. Az alábbi példa azt mutatja, hogyan lehet jelezni, hogy az alkalmazásnak szüksége van egy iránytűre:

xml
Copy code
<uses-feature android:name="android.hardware.sensor.compass" android:required="true"/>

Ezen kívül fontos tudni, hogy minden szenzort az Android rendszer három fő kategóriába sorol: mozgásérzékelők, környezeti érzékelők és helyzetérzékelők. A különböző típusú szenzorok más-más alkalmazásokhoz illeszkednek, és az őket kezelő kódok is eltérhetnek. Például a TYPE_ACCELEROMETER érzékelő segítségével mérhetjük a készülék gyorsulását, míg a TYPE_LIGHT érzékelővel a környezeti fényerősséget figyelhetjük meg.

Mivel a szenzorok elérhetősége és típusa eszközként eltérhet az egyes Android készülékek között, két lehetőségünk van a szenzorok kezelésére: egyfelől deklarálhatjuk, hogy az alkalmazásunk számára szükséges szenzorok rendelkezésre állnak, másfelől futásidőben is ellenőrizhetjük, hogy a készülék rendelkezik-e a kívánt szenzorral. A következő kód segítségével például lekérhetjük az eszköz szenzorainak listáját:

java
Copy code
SensorManager sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);

List<Sensor> sensorList = sensorManager.getSensorList(Sensor.TYPE_ALL);

Ez lehetővé teszi, hogy az alkalmazásunk dinamikusan alkalmazkodjon a különböző eszközökhöz, és csak azokat a szenzorokat használja, amelyek valóban elérhetők.

A fenti információk biztosítják a megfelelő alapokat az érintőképernyős gesztusok és szenzorok kezeléséhez Android alkalmazásokban. Azonban fontos megjegyezni, hogy a szenzorok használatakor az alkalmazás teljesítményére és akkumulátorhasználatára is figyelmet kell fordítani. A túlzott szenzorhasználat lelassíthatja az alkalmazás működését és gyorsabban merítheti az akkumulátort, ezért mindig érdemes optimalizálni a szenzorok lekérdezését és használatát.

Hogyan kezeljük a nagy képeket Android alkalmazásokban, hogy elkerüljük a memóriahiányt?

A képek kezelése Android alkalmazásokban gyakran okozhat memória problémákat, mivel az eszközök rendelkezésre álló memóriája gyakran nem elegendő a nagy felbontású képek megfelelő kezelésére. Ha nem fordítunk kellő figyelmet a képek betöltésére és optimalizálására, akkor könnyen előfordulhat, hogy alkalmazásunk memóriahiány miatt összeomlik, különösen akkor, ha nagy felbontású képeket próbálunk betölteni, például a telefon kamerájával készített fényképeket. A megfelelő memóriahasználat biztosítása érdekében elengedhetetlen, hogy képeinket megfelelően skálázzuk, hogy azok illeszkedjenek az alkalmazásunk által használt felbontásokhoz, miközben elkerüljük a túlzott memóriafogyasztást.

A BitmapFactory.Options osztály inSampleSize tulajdonsága lehetőséget ad arra, hogy csökkentsük a képek felbontását, miközben megőrizzük azok vizuális minőségét. Ennek segítségével, ahelyett, hogy a teljes képet töltenénk be, ami túl sok memóriát fogyaszt, kisebb, például 1/2-es, 1/4-es vagy 1/8-as mintát tölthetünk be. Az alábbi kódrészletben bemutatjuk, hogyan lehet egy képet skálázni, hogy elkerüljük a memóriahibákat:

java
Copy code
public Bitmap loadSampledResource(int imageID, int targetHeight, int targetWidth) {
    final BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeResource(getResources(), imageID, options);

    final int originalHeight = options.outHeight;

    final int originalWidth = options.outWidth;
    int inSampleSize = 1;

    while ((originalHeight / (inSampleSize * 2)) > targetHeight && (originalWidth / (inSampleSize * 2)) > targetWidth) {

        inSampleSize *= 2;
    }
    options.inSampleSize = inSampleSize;
    options.inJustDecodeBounds = false;
    return BitmapFactory.decodeResource(getResources(), imageID, options);
}

Ebben a példában a loadSampledResource metódus először meghatározza az eredeti kép dimenzióit anélkül, hogy betöltené a teljes képet a memóriába, majd kiszámítja, hogy hány képpontot kell eltávolítani a képből, hogy az a kívánt célnak megfelelően kicsi legyen. Miután meghatározta a mintavételi méretet, a program ténylegesen betölti a képet a kiszámított mérettel.

Ez a megoldás különösen hasznos, amikor az alkalmazásunk nagy méretű képeket használ, például a háttérképeket, profilképeket vagy nagy felbontású fényképeket. Ezen kívül érdemes figyelembe venni, hogy a képek betöltése és feldolgozása hosszú ideig is eltarthat, különösen ha nagy felbontású képekkel dolgozunk. Ez a művelet könnyen blokkolhatja a felhasználói felületet (UI), ami azt jelenti, hogy az alkalmazás nem reagálhat a felhasználói interakciókra, és előfordulhat, hogy az Android rendszer megjeleníti az „Alkalmazás nem válaszol” (ANR) hibaüzenetet. Az ilyen problémák elkerülése érdekében célszerű a képfeldolgozást háttérszálon végezni, például az AsyncTask segítségével, hogy a felhasználói felület továbbra is érzékeny maradjon.

Továbbá fontos megérteni, hogy a képek méretének meghatározása nem csupán a memória csökkentésére szolgál. Ha az alkalmazásunk egy meghatározott képméretet igényel, akkor a képet méretezhetjük közvetlenül a Bitmap osztály segítségével, vagy az XML-ben beállíthatjuk a kívánt dimenziókat. Ezen kívül számos más könyvtár is elérhető a képek gyors és hatékony kezelésére, mint például a Picasso vagy az Android Universal Image Loader, amelyek segíthetnek a képek gyors letöltésében, gyorsítótárazásában és megjelenítésében.