Menambahkan menu

Mencoba cara Compose
Jetpack Compose adalah toolkit UI yang direkomendasikan untuk Android. Pelajari cara menambahkan komponen di Compose.
TopAppBar →

Menu adalah komponen antarmuka pengguna yang umum di banyak jenis aplikasi. Kepada memberikan pengalaman pengguna yang akrab dan konsisten, gunakan Menu API untuk menampilkan tindakan pengguna dan opsi lain dalam aktivitas Anda.

Gambar yang menunjukkan contoh menu tambahan
Gambar 1. Menu yang dipicu oleh ketukan ikon, yang muncul di bawah ikon menu tambahan.

Dokumen ini menunjukkan cara membuat tiga tipe dasar dari menu atau presentasi tindakan di semua versi Android:

Menu opsi dan panel aplikasi
Menu opsi adalah kumpulan utama item menu untuk aktivitas Anda. Di sinilah Anda menempatkan tindakan yang memiliki dampak global pada Anda, seperti "Penelusuran", "Tulis email", dan "Settings".

Lihat menu Buat opsi bagian.

Menu konteks dan mode tindakan kontekstual
Menu konteks adalah menu mengambang yang muncul saat pengguna melakukan sentuhan & berpegang pada suatu elemen. Ini menyediakan tindakan yang memengaruhi konten atau bingkai konteks yang dipilih.

Mode tindakan kontekstual menampilkan item tindakan yang memengaruhi konten yang dipilih pada sebuah bilah di bagian atas layar dan memungkinkan pengguna memilih beberapa item.

Lihat Membuat menu kontekstual bagian.

Menu pop-up
Menu pop-up menampilkan daftar vertikal item yang ditambatkan ke yang memanggil menu. Cocok untuk menyediakan banyak tindakan yang terkait dengan konten tertentu atau memberikan opsi untuk bagian kedua atas suatu perintah. Tindakan di menu pop-up tidak langsung memengaruhi konten yang sesuai—untuk itulah tindakan kontekstual. Sebaliknya, menu pop-up adalah untuk tindakan tambahan yang terkait dengan region konten aktivitas Anda.

Lihat bagian Membuat menu pop-up.

Menentukan menu dalam XML

Untuk semua jenis menu, Android menyediakan format XML standar untuk mendefinisikan menu item. Alih-alih membangun menu dalam kode aktivitas Anda, definisikan menu dan semua itemnya dalam XML resource menu. Anda dapat lalu meng-inflate resource menu—memuatnya sebagai Menu —dalam aktivitas atau fragmen Anda.

Menggunakan resource menu adalah praktik yang baik karena alasan berikut:

  • Memvisualisasikan struktur menu dalam XML menjadi lebih mudah.
  • Fungsi ini memisahkan konten untuk menu dari perilaku aplikasi pada kode sumber.
  • Memungkinkan Anda membuat konfigurasi menu alternatif untuk berbagai platform versi, ukuran layar, dan konfigurasi lainnya dengan memanfaatkan resource aplikasi Google Workspace for Education.

Untuk mendefinisikan menu, buat sebuah file XML di dalam direktori Direktori res/menu/ dan buat menu dengan elemen:

<menu>
Mendefinisikan Menu, yang merupakan sebuah container item menu. J Elemen <menu> harus menjadi node root untuk file, dan elemen tersebut dapat menampung satu atau beberapa <item> dan <group> yang kurang penting.
<item>
Membuat MenuItem, yang mewakili satu item dalam menu. Elemen ini dapat berisi lapisan <menu> untuk membuat submenu.
<group>
Penampung opsional yang tidak terlihat untuk <item> yang kurang penting. Ini memungkinkan Anda mengategorikan item menu sehingga mereka berbagi properti, seperti sebagai status aktif dan visibilitas. Untuk informasi selengkapnya, lihat Bagian Buat grup menu.

Berikut ini adalah contoh menu bernama game_menu.xml:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/new_game"
          android:icon="@drawable/ic_new_game"
          android:title="@string/new_game"
          app:showAsAction="ifRoom"/>
    <item android:id="@+id/help"
          android:icon="@drawable/ic_help"
          android:title="@string/help" />
</menu>

Elemen <item> mendukung beberapa atribut yang dapat Anda gunakan untuk mendefinisikan penampilan dan perilaku item. Item dalam menu sebelumnya menyertakan atribut berikut:

android:id
ID resource yang unik untuk item, yang memungkinkan aplikasi mengenali item saat pengguna memilihnya.
android:icon
Acuan ke drawable untuk digunakan sebagai ikon item.
android:title
Acuan ke string untuk digunakan sebagai judul item.
android:showAsAction
Spesifikasi waktu dan cara item ini muncul sebagai item tindakan di panel aplikasi.

Ini adalah atribut-atribut terpenting yang Anda gunakan, tetapi masih banyak lagi yang tersedia. Untuk informasi tentang semua atribut yang didukung, lihat Resource menu dokumentasi tambahan.

Anda dapat menambahkan submenu ke item di menu mana pun dengan menambahkan Elemen <menu> sebagai turunan dari <item>. Submenu berguna saat aplikasi Anda memiliki banyak fungsi yang dapat diatur ke dalam topik, seperti item di panel menu aplikasi PC—seperti File, Edit, dan View. Lihat contoh berikut:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/file"
          android:title="@string/file" >
        <!-- "file" submenu -->
        <menu>
            <item android:id="@+id/create_new"
                  android:title="@string/create_new" />
            <item android:id="@+id/open"
                  android:title="@string/open" />
        </menu>
    </item>
</menu>

Untuk menggunakan menu di aktivitas Anda, _inflate_ sumber daya menu, konversi resource XML menjadi objek yang dapat diprogram menggunakan MenuInflater.inflate(). Bagian berikut menunjukkan cara meng-inflate menu untuk setiap jenis menu.

Membuat menu opsi

Menu opsi, seperti yang ditunjukkan pada gambar 1, adalah tempat Anda menyertakan tindakan dan opsi lain yang relevan dengan konteks aktivitas saat ini, seperti "Penelusuran", "Tulis email", dan "Settings".

Gambar yang menampilkan panel aplikasi untuk aplikasi Google Spreadsheet
Gambar 2. Aplikasi Google Spreadsheet, yang menampilkan beberapa tombol, termasuk tombol tambahan tindakan.

Anda dapat mendeklarasikan item untuk menu opsi dari Activity atau subclass Fragment subclass Keras. Jika aktivitas maupun fragmen Anda mendeklarasikan item untuk menu opsi, item tersebut digabungkan dalam UI. Item aktivitas muncul pertama, diikuti oleh item dari setiap fragmen, sesuai dengan urutan fragmen ditambahkan ke aktivitas. Jika perlu, Anda bisa menyusun ulang item menu dengan atribut android:orderInCategory di setiap <item> yang harus Anda pindahkan.

Untuk menetapkan menu opsi suatu aktivitas, ganti onCreateOptionsMenu(). Fragmen menyediakan onCreateOptionsMenu() . Dalam metode ini, Anda bisa meng-inflate sumber daya menu, ditentukan dalam XML, ke dalam Menu yang disediakan di . Hal ini ditunjukkan dalam contoh berikut:

Kotlin

override fun onCreateOptionsMenu(menu: Menu): Boolean {
    val inflater: MenuInflater = menuInflater
    inflater.inflate(R.menu.game_menu, menu)
    return true
}

Java

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.game_menu, menu);
    return true;
}

Anda juga dapat menambahkan item menu menggunakan add() dan mengambil item dengan findItem() merevisi propertinya dengan MenuItem API.

Menangani peristiwa klik

Saat pengguna memilih item dari menu opsi, termasuk item tindakan dalam bilah aplikasi, sistem memanggil metode onOptionsItemSelected() . Metode ini meneruskan MenuItem yang dipilih. Anda dapat mengidentifikasi item dengan memanggil getItemId(), yang mengembalikan ID unik untuk item menu, yang ditentukan oleh Atribut android:id dalam resource menu atau dengan bilangan bulat yang diberikan ke metode add(). Anda dapat mencocokkan ID ini dengan menu yang dikenal item untuk melakukan tindakan yang sesuai.

Kotlin

override fun onOptionsItemSelected(item: MenuItem): Boolean {
    // Handle item selection.
    return when (item.itemId) {
        R.id.new_game -> {
            newGame()
            true
        }
        R.id.help -> {
            showHelp()
            true
        }
        else -> super.onOptionsItemSelected(item)
    }
}

Java

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    // Handle item selection.
    switch (item.getItemId()) {
        case R.id.new_game:
            newGame();
            return true;
        case R.id.help:
            showHelp();
            return true;
        default:
            return super.onOptionsItemSelected(item);
    }
}

Bila Anda berhasil menangani sebuah item menu, kembalikan true. Jika Anda tidak menangani item menu, panggil implementasi superclass onOptionsItemSelected(). Implementasi default menampilkan {i>false<i}.

Jika aktivitas Anda menyertakan fragmen, sistem akan memanggilnya terlebih dahulu onOptionsItemSelected() untuk aktivitas, kemudian untuk setiap fragmen sesuai urutan penambahan fragmen, hingga yang satu menampilkan true atau semua fragmen dipanggil.

Mengubah item menu saat runtime

Setelah memanggil onCreateOptionsMenu(), sistem akan mempertahankan instance Menu yang Anda isi dan tidak memanggil onCreateOptionsMenu() lagi kecuali jika menu dibatalkan. Namun, gunakan onCreateOptionsMenu() hanya untuk membuat menu awal dan tidak membuat perubahan selama siklus proses aktivitas.

Jika Anda ingin mengubah menu opsi berdasarkan peristiwa yang terjadi selama siklus proses aktivitas, Anda dapat melakukannya dalam onPrepareOptionsMenu() . Metode ini meneruskan objek Menu seperti yang saat ini sehingga Anda dapat mengubahnya, seperti dengan menambah, menghapus, atau menonaktifkan item. Fragmen juga menyediakan onPrepareOptionsMenu() .

Menu opsi dianggap selalu terbuka ketika item menu disajikan di panel aplikasi. Ketika suatu peristiwa terjadi dan Anda ingin melakukan pembaruan menu, panggil invalidateOptionsMenu() untuk meminta agar sistem memanggil onPrepareOptionsMenu().

Membuat menu kontekstual

Gambar yang menampilkan menu konteks mengambang
Gambar 3. Menu konteks mengambang.

Menu kontekstual menawarkan tindakan yang memengaruhi item atau konteks tertentu {i>frame<i} di UI. Anda dapat menyediakan menu konteks untuk tampilan apa pun, tetapi yang paling umum sering digunakan untuk item dalam RecylerView atau kumpulan tampilan lainnya yang dapat digunakan pengguna untuk melakukan tindakan langsung pada setiap yang bermanfaat.

Ada dua cara menyediakan tindakan kontekstual:

  • Dalam menu konteks mengambang. Menu muncul sebagai daftar item menu mengambang, mirip dengan dialog, saat pengguna melakukan sentuhan & mempertahankan tampilan yang mendeklarasikan dukungan untuk konteks Google Spreadsheet. Pengguna bisa melakukan tindakan kontekstual pada satu item untuk setiap kalinya.
  • Dalam mode tindakan kontekstual. Mode ini adalah sistem implementasi ActionMode yang menampilkan panel tindakan kontekstual, atau CAB, di bagian atas layar dengan item tindakan yang mempengaruhi item yang dipilih. Jika mode ini aktif, pengguna dapat melakukan tindakan pada beberapa item sekaligus, jika aplikasi apa pun mendukungnya.

Catatan: Menu konteks tidak mendukung pintasan item dan ikon item.

Membuat menu konteks mengambang

Untuk menyediakan menu konteks mengambang, lakukan hal berikut:

  1. Daftarkan View yang dikaitkan dengan menu konteks menelepon registerForContextMenu() dan meneruskan View ke sini.

    Jika aktivitas Anda menggunakan RecyclerView dan Anda menginginkan setiap untuk menyediakan menu konteks yang sama, mendaftarkan semua item untuk konteks dengan meneruskan RecyclerView ke registerForContextMenu().

  2. Implementasikan onCreateContextMenu() di Activity atau Fragment Anda.

    Saat tampilan yang terdaftar menerima sentuhan & peristiwa tahan, sistem akan memanggil metode onCreateContextMenu() Anda. Di sinilah Anda menentukan item menu, biasanya dengan meng-inflate sumber daya menu, seperti dalam contoh:

    Kotlin

        override fun onCreateContextMenu(menu: ContextMenu, v: View,
                            menuInfo: ContextMenu.ContextMenuInfo) {
        super.onCreateContextMenu(menu, v, menuInfo)
        val inflater: MenuInflater = menuInflater
        inflater.inflate(R.menu.context_menu, menu)
    }

    Java

        @Override
    public void onCreateContextMenu(ContextMenu menu, View v,
                                    ContextMenuInfo menuInfo) {
        super.onCreateContextMenu(menu, v, menuInfo);
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.context_menu, menu);
    }

    MenuInflater memungkinkan Anda meng-inflate menu konteks dari resource menu. Metode callback parameter mencakup View yang dipilih pengguna dan ContextMenu.ContextMenuInfo yang memberikan informasi tambahan tentang item yang dipilih. Jika aktivitas Anda memiliki beberapa tampilan yang masing-masing menyediakan menu konteks berbeda, Anda dapat menggunakan parameter ini untuk menentukan menu konteks mana yang meng-inflate.

  3. Terapkan onContextItemSelected(), seperti yang ditunjukkan dalam contoh berikut. Saat pengguna memilih item menu, sistem memanggil metode ini sehingga Anda dapat melakukan tindakan yang sesuai.

    Kotlin

        override fun onContextItemSelected(item: MenuItem): Boolean {
        val info = item.menuInfo as AdapterView.AdapterContextMenuInfo
        return when (item.itemId) {
            R.id.edit -> {
                editNote(info.id)
                true
            }
            R.id.delete -> {
                deleteNote(info.id)
                true
            }
            else -> super.onContextItemSelected(item)
        }
    }

    Java

        @Override
    public boolean onContextItemSelected(MenuItem item) {
        AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo();
        switch (item.getItemId()) {
            case R.id.edit:
                editNote(info.id);
                return true;
            case R.id.delete:
                deleteNote(info.id);
                return true;
            default:
                return super.onContextItemSelected(item);
        }
    }

    getItemId() kueri ID untuk item menu yang dipilih, yang Anda tetapkan untuk di XML menggunakan atribut android:id, seperti yang ditunjukkan pada Menentukan menu di XML.

    Bila Anda berhasil menangani sebuah item menu, kembalikan true. Jika Anda tidak menangani item menu, teruskan item menu ke superclass terlepas dari implementasi layanan. Jika aktivitas Anda menyertakan fragmen, aktivitas akan menerima callback ini terlebih dahulu. Dengan memanggil superclass ketika tidak tertangani, sistem meneruskan peristiwa ke masing-masing metode callback di setiap fragmen, satu per waktu, dengan urutan penambahan setiap fragmen, hingga true atau false ditampilkan. Implementasi default untuk Activity dan android.app.Fragment ditampilkan false, jadi selalu panggil superclass saat tidak ditangani.

Menggunakan mode tindakan kontekstual

Mode tindakan kontekstual adalah implementasi sistem dari ActionMode yang memfokuskan interaksi pengguna untuk menghasilkan tindakan kontekstual. Saat pengguna mengaktifkan mode ini dengan memilih item, panel tindakan kontekstual muncul di bagian atas layar untuk menampilkan tindakan yang dapat dilakukan pengguna pada item yang dipilih. Saat mode ini diaktifkan, pengguna bisa memilih beberapa item, jika aplikasi Anda mendukungnya, dan bisa membatalkan pilihan item dan terus menavigasi dalam aktivitas. Mode tindakan dinonaktifkan dan {i>action bar<i} kontekstual menghilang ketika pengguna membatalkan pilihan semua item, mengetuk tombol Kembali, atau mengetuk tindakan Selesai di sisi kiri .

Untuk tampilan yang menyediakan tindakan kontekstual, Anda biasanya memanggil properti mode tindakan jika salah satu atau kedua peristiwa berikut terjadi:

  • Pengguna melakukan sentuhan & mempertahankan tampilan.
  • Pengguna memilih kotak centang atau komponen UI yang serupa dalam tampilan.

Cara aplikasi Anda memanggil mode aksi kontekstual dan mendefinisikan perilaku untuk setiap tindakan tergantung pada desain Anda. Ada dua desain:

  • Untuk tindakan kontekstual pada tampilan sembarang dan tersendiri.
  • Untuk tindakan kontekstual batch pada grup item dalam RecyclerView, yang memungkinkan pengguna memilih beberapa item dan melakukan tindakan pada mereka semua.

Bagian berikut ini menjelaskan penyiapan yang diperlukan untuk setiap skenario.

Mengaktifkan mode tindakan kontekstual untuk tampilan individual

Jika Anda ingin memanggil mode aksi kontekstual hanya bila pengguna memilih tampilan tertentu, lakukan hal berikut:

  1. Terapkan antarmuka ActionMode.Callback seperti yang ditunjukkan dalam contoh berikut. Dalam metode callback-nya, Anda bisa menetapkan tindakan untuk bilah aksi kontekstual, merespons kejadian klik pada item aksi, dan menangani peristiwa siklus proses lainnya untuk mode tindakan.

    Kotlin

        private val actionModeCallback = object : ActionMode.Callback {
        // Called when the action mode is created. startActionMode() is called.
        override fun onCreateActionMode(mode: ActionMode, menu: Menu): Boolean {
            // Inflate a menu resource providing context menu items.
            val inflater: MenuInflater = mode.menuInflater
            inflater.inflate(R.menu.context_menu, menu)
            return true
        }

        // Called each time the action mode is shown. Always called after
        // onCreateActionMode, and might be called multiple times if the mode
        // is invalidated.
        override fun onPrepareActionMode(mode: ActionMode, menu: Menu): Boolean {
            return false // Return false if nothing is done
        }

        // Called when the user selects a contextual menu item.
        override fun onActionItemClicked(mode: ActionMode, item: MenuItem): Boolean {
            return when (item.itemId) {
                R.id.menu_share -> {
                    shareCurrentItem()
                    mode.finish() // Action picked, so close the CAB.
                    true
                }
                else -> false
            }
        }

        // Called when the user exits the action mode.
        override fun onDestroyActionMode(mode: ActionMode) {
            actionMode = null
        }
    }

    Java

        private ActionMode.Callback actionModeCallback = new ActionMode.Callback() {

        // Called when the action mode is created. startActionMode() is called.
        @Override
        public boolean onCreateActionMode(ActionMode mode, Menu menu) {
            // Inflate a menu resource providing context menu items.
            MenuInflater inflater = mode.getMenuInflater();
            inflater.inflate(R.menu.context_menu, menu);
            return true;
        }

        // Called each time the action mode is shown. Always called after
        // onCreateActionMode, and might be called multiple times if the mode
        // is invalidated.
        @Override
        public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
            return false; // Return false if nothing is done.
        }

        // Called when the user selects a contextual menu item.
        @Override
        public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
           switch (item.getItemId()) {
                case R.id.menu_share:
                    shareCurrentItem();
                    mode.finish(); // Action picked, so close the CAB.
                    return true;
                default:
                    return false;
            }
        }

        // Called when the user exits the action mode.
        @Override
        public void onDestroyActionMode(ActionMode mode) {
            actionMode = null;
        }
    };

    Callback peristiwa ini hampir sama persis dengan callback untuk menu opsi, kecuali masing-masing juga meneruskan objek ActionMode yang terkait dengan peristiwa tersebut. Anda dapat menggunakan ActionMode API untuk membuat berbagai perubahan pada CAB, seperti merevisi judul dan sub judul dengan setTitle() dan setSubtitle(), yang berguna untuk menunjukkan berapa banyak item yang dipilih.

    Contoh sebelumnya menetapkan variabel actionMode ke null saat mode tindakan dihancurkan. Pada langkah berikutnya, lihat bagaimana ia diinisialisasi dan bagaimana cara menyimpan variabel anggota dalam aktivitas Anda atau fragmen dapat berguna.

  2. Telepon startActionMode() kapan Anda ingin menampilkan bilah, seperti saat pengguna menyentuh & mempertahankan tampilan.

    Kotlin

        someView.setOnLongClickListener { view ->
        // Called when the user performs a touch & hold on someView.
        when (actionMode) {
            null -> {
                // Start the CAB using the ActionMode.Callback defined earlier.
                actionMode = activity?.startActionMode(actionModeCallback)
                view.isSelected = true
                true
            }
            else -> false
        }
    }

    Java

        someView.setOnLongClickListener(new View.OnLongClickListener() {
        // Called when the user performs a touch & hold on someView.
        public boolean onLongClick(View view) {
            if (actionMode != null) {
                return false;
            }

            // Start the CAB using the ActionMode.Callback defined earlier.
            actionMode = getActivity().startActionMode(actionModeCallback);
            view.setSelected(true);
            return true;
        }
    });

    Saat Anda memanggil startActionMode(), sistem akan menampilkan metode ActionMode dibuat. Dengan menyimpannya dalam variabel anggota, Anda bisa membuat perubahan pada bilah aksi kontekstual sebagai respons terhadap kejadian lainnya. Dalam contoh sebelumnya, ActionMode digunakan untuk memastikan bahwa instance ActionMode tidak dibuat ulang jika sudah dibuat aktif, dengan memeriksa apakah anggota bernilai null sebelum memulai tindakan mode.

Membuat menu pop-up

Gambar yang menampilkan menu pop-up di aplikasi Gmail, yang ditautkan ke tombol tambahan di kanan atas.
Gambar 4. Menu pop-up dalam aplikasi Gmail, yang ditambatkan ke tombol tambahan di pojok kanan atas.

PopupMenu adalah menu modal yang ditambatkan ke View. Tombol muncul di bawah anchor lihat jika ada ruang, atau di atas tampilan jika tidak ada. Model ini berguna untuk berikut ini:

  • Menyediakan menu bergaya tambahan untuk tindakan yang berkaitan dengan konten tertentu, seperti header email Gmail, yang ditunjukkan pada gambar 4.
  • Menyediakan bagian kedua dari kalimat perintah, seperti tombol yang ditandai Add yang menghasilkan menu pop-up dengan opsi Add yang berbeda lainnya.
  • Menyediakan menu yang mirip dengan Spinner yang tidak mempertahankan pemilihan persisten.

Jika Anda mendefinisikan menu dalam XML, berikut cara menampilkan menu pop-up:

  1. Buat instance PopupMenu dengan konstruktornya, yang menggunakan aplikasi saat ini Context dan View tempat menu ditambatkan.
  2. Gunakan MenuInflater untuk meng-inflate resource menu Anda ke dalam Objek Menu yang ditampilkan oleh PopupMenu.getMenu().
  3. Panggil PopupMenu.show().

Misalnya, berikut ini tombol yang menampilkan menu pop-up:

<ImageButton
    android:id="@+id/dropdown_menu"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:contentDescription="@string/descr_overflow_button"
    android:src="@drawable/arrow_drop_down" />

Aktivitas nanti dapat menampilkan menu pop-up seperti ini:

Kotlin

findViewById<ImageButton>(R.id.dropdown_menu).setOnClickListener {
    val popup = PopupMenu(this, it)
    val inflater: MenuInflater = popup.menuInflater
    inflater.inflate(R.menu.actions, popup.menu)
    popup.show()
}

Java

findViewById(R.id.dropdown_menu).setOnClickListener(v -> {
    PopupMenu popup = new PopupMenu(this, v);
    popup.getMenuInflater().inflate(R.menu.actions, popup.getMenu());
    popup.show();
});

Menu ditutup jika pengguna memilih item atau mengetuk di luar menu area tersebut. Anda dapat memproses peristiwa tutup menggunakan PopupMenu.OnDismissListener.

Menangani peristiwa klik

Untuk melakukan tindakan saat pengguna memilih item menu, implementasikan metode PopupMenu.OnMenuItemClickListener dan daftarkan ke PopupMenu Anda dengan memanggil setOnMenuItemclickListener(). Bila pengguna memilih item, sistem akan memanggil metode onMenuItemClick() di antarmuka Anda.

Hal ini ditunjukkan dalam contoh berikut:

Kotlin

fun showMenu(v: View) {
    PopupMenu(this, v).apply {
        // MainActivity implements OnMenuItemClickListener.
        setOnMenuItemClickListener(this@MainActivity)
        inflate(R.menu.actions)
        show()
    }
}

override fun onMenuItemClick(item: MenuItem): Boolean {
    return when (item.itemId) {
        R.id.archive -> {
            archive(item)
            true
        }
        R.id.delete -> {
            delete(item)
            true
        }
        else -> false
    }
}

Java

public void showMenu(View v) {
    PopupMenu popup = new PopupMenu(this, v);

    // This activity implements OnMenuItemClickListener.
    popup.setOnMenuItemClickListener(this);
    popup.inflate(R.menu.actions);
    popup.show();
}

@Override
public boolean onMenuItemClick(MenuItem item) {
    switch (item.getItemId()) {
        case R.id.archive:
            archive(item);
            return true;
        case R.id.delete:
            delete(item);
            return true;
        default:
            return false;
    }
}

Membuat grup menu

Grup menu adalah sekumpulan item menu yang sama-sama memiliki ciri (trait) tertentu. Dengan , Anda dapat melakukan hal berikut:

Anda dapat membuat grup dengan menyarangkan elemen <item> di dalam elemen <group> di resource menu Anda atau dengan menentukan ID grup dengan add() .

Berikut adalah contoh resource menu yang menyertakan sebuah grup:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/menu_save"
          android:icon="@drawable/menu_save"
          android:title="@string/menu_save" />
    <!-- menu group -->
    <group android:id="@+id/group_delete">
        <item android:id="@+id/menu_archive"
              android:title="@string/menu_archive" />
        <item android:id="@+id/menu_delete"
              android:title="@string/menu_delete" />
    </group>
</menu>

Item yang ada dalam grup muncul pada level yang sama dengan item pertama item—ketiga item dalam menu adalah bersaudara. Namun, Anda dapat memodifikasi ciri kedua item dalam grup dengan mengacu pada ID grup dan menggunakan metode sebelumnya. Sistem juga tidak pernah memisahkan item yang dikelompokkan. Sebagai misalnya, jika Anda mendeklarasikan android:showAsAction="ifRoom" untuk setiap yang muncul di panel tindakan atau di kolom tindakan tambahan.

Menggunakan item menu yang dapat dicentang

Gambar 5. Submenu dengan item yang dapat dicentang.

Menu dapat berguna sebagai antarmuka untuk mengaktifkan dan menonaktifkan opsi, menggunakan kotak centang untuk opsi mandiri, atau tombol pilihan untuk grup yang dan opsi eksklusif. Gambar 5 menunjukkan submenu dengan item yang dapat dicentang tombol pilihan.

Anda bisa mendefinisikan perilaku yang bisa dicentang untuk setiap item menu menggunakan Atribut android:checkable di <item> elemen tambahan, atau untuk seluruh grup dengan android:checkableBehavior di elemen <group>. Misalnya, semua item di grup menu ini dapat dicentang dengan tombol pilihan:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <group android:checkableBehavior="single">
        <item android:id="@+id/red"
              android:title="@string/red" />
        <item android:id="@+id/blue"
              android:title="@string/blue" />
    </group>
</menu>

Atribut android:checkableBehavior menerima salah satu berikut ini:

single
Hanya satu item dari grup ini yang dapat diperiksa, sehingga menghasilkan radio tombol.
all
Semua item bisa dicentang, sehingga ada kotak centang.
none
Tidak ada item yang dapat dicentang.

Anda dapat menerapkan status dicentang default ke item menggunakan Atribut android:checked di elemen <item> dan mengubahnya dalam kode dengan setChecked() .

Jika item yang dapat dicentang dipilih, sistem akan memanggil item yang sesuai metode callback yang dipilih item, seperti onOptionsItemSelected(). Di sinilah Anda menetapkan status kotak centang, karena kotak centang atau radio tombol ini tidak mengubah statusnya secara otomatis. Anda dapat mengkueri status saat ini item—seperti sebelum pengguna memilihnya—dengan isChecked() lalu tetapkan status yang dicentang dengan setChecked(). Hal ini ditunjukkan di contoh berikut:

Kotlin

override fun onOptionsItemSelected(item: MenuItem): Boolean {
    return when (item.itemId) {
        R.id.vibrate, R.id.dont_vibrate -> {
            item.isChecked = !item.isChecked
            true
        }
        else -> super.onOptionsItemSelected(item)
    }
}

Java

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
        case R.id.vibrate:
        case R.id.dont_vibrate:
            if (item.isChecked()) item.setChecked(false);
            else item.setChecked(true);
            return true;
        default:
            return super.onOptionsItemSelected(item);
    }
}

Jika Anda tidak mengatur status yang dicentang dengan cara ini, maka status yang terlihat dari kotak centang atau tombol pilihan tidak berubah ketika pengguna memilihnya. Kapan Anda melakukan mengatur status, aktivitas akan mempertahankan status yang dicentang dari item sehingga ketika nanti pengguna membuka menu, status yang dicentang akan terlihat.

Menambahkan item menu berdasarkan intent

Terkadang Anda ingin item menu meluncurkan aktivitas menggunakan Intent, apakah itu aktivitas di aplikasi Anda atau aplikasi lain. Jika Anda mengetahui intent yang ingin Anda gunakan dan memiliki item menu tertentu yang memulai intent, Anda bisa mengeksekusi intent dengan startActivity() selama metode callback saat-item-dipilih sesuai, seperti Callback onOptionsItemSelected().

Tetapi, jika Anda tidak yakin bahwa perangkat pengguna berisi aplikasi yang menangani intent, lalu menambahkan item menu yang memanggilnya dapat menghasilkan item menu yang tidak berfungsi, karena intent mungkin tidak menyelesaikan suatu aktivitas. Untuk mengatasi hal ini, Android memungkinkan Anda menambahkan item menu secara dinamis ke menu saat Android menemukan aktivitas di perangkat yang menangani intent Anda.

Untuk menambahkan item menu berdasarkan aktivitas tersedia yang menerima intent, lakukan hal berikut:

  1. Menentukan intent dengan kategori CATEGORY_ALTERNATIVE atau CATEGORY_SELECTED_ALTERNATIVE, atau keduanya, ditambah persyaratan lainnya.
  2. Telepon Menu.addIntentOptions(). Android kemudian menelusuri aplikasi apa pun yang dapat menjalankan intent tersebut akan menambahkannya ke menu Anda.

Jika tidak ada aplikasi terinstal yang memenuhi intent, maka tidak ada menu item ditambahkan.

Hal ini ditunjukkan dalam contoh berikut:

Kotlin

override fun onCreateOptionsMenu(menu: Menu): Boolean {
    super.onCreateOptionsMenu(menu)

    // Create an Intent that describes the requirements to fulfill, to be
    // included in the menu. The offering app must include a category value
    // of Intent.CATEGORY_ALTERNATIVE.
    val intent = Intent(null, dataUri).apply {
        addCategory(Intent.CATEGORY_ALTERNATIVE)
    }

    // Search and populate the menu with acceptable offering apps.
    menu.addIntentOptions(
            R.id.intent_group,  // Menu group to which new items are added.
            0,                  // Unique item ID (none).
            0,                  // Order for the items (none).
            this.componentName, // The current activity name.
            null,               // Specific items to place first (none).
            intent,             // Intent created above that describes the requirements.
            0,                  // Additional flags to control items (none).
            null)               // Array of MenuItems that correlate to specific items (none).

    return true
}

Java

@Override
public boolean onCreateOptionsMenu(Menu menu){
    super.onCreateOptionsMenu(menu);

    // Create an Intent that describes the requirements to fulfill, to be
    // included in the menu. The offering app must include a category value
    // of Intent.CATEGORY_ALTERNATIVE.
    Intent intent = new Intent(null, dataUri);
    intent.addCategory(Intent.CATEGORY_ALTERNATIVE);

    // Search and populate the menu with acceptable offering apps.
    menu.addIntentOptions(
         R.id.intent_group,         // Menu group to which new items are added.
         0,                         // Unique item ID (none).
         0,                         // Order for the items (none).
         this.getComponentName(),   // The current activity name.
         null,                      // Specific items to place first (none).
         intent,                    // Intent created above that describes the requirements.
         0,                         // Additional flags to control items (none).
         null);                     // Array of MenuItems that correlate to specific items (none).

    return true;
}

Untuk setiap aktivitas yang ditemukan menyediakan filter intent yang cocok dengan intent item menu ditambahkan, dengan menggunakan nilai dalam filter intent android:label sebagai judul item menu dan ikon aplikasi sebagai menu ikon item. Metode addIntentOptions() akan menampilkan jumlah item menu yang ditambahkan.

Biarkan aktivitas Anda ditambahkan ke menu lain

Anda dapat menawarkan layanan aktivitas Anda ke aplikasi lain agar aplikasi dapat termasuk dalam menu orang lain—membalikkan peran yang dijelaskan sebelumnya.

Agar dimasukkan dalam menu aplikasi lain, tentukan filter intent seperti biasa, tetapi menyertakan CATEGORY_ALTERNATIVE atau Nilai CATEGORY_SELECTED_ALTERNATIVE, atau keduanya, untuk intent kategori filter. Hal ini ditunjukkan dalam contoh berikut:

<intent-filter label="@string/resize_image">
    ...
    <category android:name="android.intent.category.ALTERNATIVE" />
    <category android:name="android.intent.category.SELECTED_ALTERNATIVE" />
    ...
</intent-filter>

Baca selengkapnya tentang menulis filter intent di Intent dan intent filter.