Gambar 1. Menu opsi di Browser, pada Android 2.3.
Menu adalah komponen antarmuka pengguna yang lazim dalam banyak tipe aplikasi. Untuk menyediakan pengalaman pengguna yang sudah akrab dan konsisten, Anda harus menggunakan API {@link android.view.Menu} untuk menyajikan tindakan dan opsi lain dalam aktivitas kepada pengguna.
Mulai dengan Android 3.0 (API level 11), perangkat berbasis Android tidak perlu lagi menyediakan tombol Menu tersendiri. Dengan perubahan ini, aplikasi Android harus bermigrasi dari dependensi pada panel menu 6 item biasa, dan sebagai ganti menyediakan action-bar untuk menyajikan berbagai tindakan pengguna yang lazim.
Walaupun desain dan pengalaman pengguna untuk sebagian item menu telah berubah, semantik untuk mendefinisikan serangkaian tindakan dan opsi masih berdasarkan pada API {@link android.view.Menu}. Panduan ini menampilkan cara membuat tiga tipe dasar penyajian menu atau tindakan pada semua versi Android:
Jika Anda mengembangkan aplikasi untuk Android 2.3 atau yang lebih rendah, pengguna bisa menampilkan panel menu opsi dengan menekan tombol Menu.
Pada Android 3.0 dan yang lebih tinggi, item menu opsi disajikan melalui action-bar sebagai kombinasi item tindakan di layar dan opsi overflow. Mulai dengan Android 3.0, tombol Menu dihilangkan (sebagian perangkat tidak memilikinya), sehingga Anda harus bermigrasi ke penggunaan action-bar untuk menyediakan akses ke tindakan dan opsi lainnya.
Lihat bagian tentang Membuat Menu Opsi.
Saat mengembangkan aplikasi untuk Android 3.0 dan yang lebih tinggi, sebagai gantinya Anda harus menggunakan mode tindakan kontekstual untuk memungkinkan tindakan pada konten yang dipilih. Mode ini menampilkan item tindakan yang memengaruhi konten yang dipilih dalam baris di bagian atas layar dan memungkinkan pengguna memilih beberapa item sekaligus.
Lihat bagian tentang Membuat Menu Kontekstual.
Lihat bagian tentang Membuat Menu Popup.
Untuk semua tipe menu, Android menyediakan sebuah format XML standar untuk mendefinisikan item menu. Sebagai ganti membuat menu dalam kode aktivitas, Anda harus mendefinisikan menu dan semua itemnya dalam sumber daya menu XML. Anda kemudian bisa memekarkan sumber daya menu (memuatnya sebagai objek {@link android.view.Menu}) dalam aktivitas atau fragmen.
Menggunakan sumber daya menu adalah praktik yang baik karena beberapa alasan:
Untuk mendefinisikan menu, buatlah sebuah file XML dalam direktori res/menu/
proyek dan buat menu dengan elemen-elemen berikut:
<menu><menu> harus menjadi simpul akar untuk file dan bisa menampung salah satu atau beberapa dari elemen
<item> dan <group>.<item><menu> tersarang guna untuk membuat submenu.<group>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"
android:showAsAction="ifRoom"/>
<item android:id="@+id/help"
android:icon="@drawable/ic_help"
android:title="@string/help" />
</menu>
Elemen <item> mendukung beberapa atribut yang bisa Anda gunakan untuk mendefinisikan penampilan dan perilaku
item. Item menu di atas mencakup atribut berikut:
Ini adalah atribut-atribut terpenting yang harus Anda gunakan, namun banyak lagi yang tersedia. Untuk informasi tentang semua atribut yang didukung, lihat dokumen Sumber Daya Menu.
Anda bisa menambahkan submenu ke sebuah item di menu (kecuali submenu) apa saja dengan menambahkan elemen {@code <menu>} sebagai anak {@code <item>}. Submenu berguna saat aplikasi Anda memiliki banyak fungsi yang bisa ditata ke dalam topik-topik, seperti item dalam sebuah baris menu aplikasi PC (File, Edit, Lihat, dsb.). Misalnya:
<?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 dalam aktivitas, Anda perlu memekarkan sumber daya menu (mengonversi sumber daya XML menjadi objek yang bisa diprogram) dengan menggunakan {@link android.view.MenuInflater#inflate(int,Menu) MenuInflater.inflate()}. Di bagian berikut, Anda akan melihat cara memekarkan menu untuk tiap tipe menu.
Gambar 1. Menu opsi di Browser, pada Android 2.3.
Menu opsi adalah tempat Anda harus menyertakan tindakan dan opsi lain yang relevan dengan konteks aktivitas saat ini, seperti "Cari", "Tulis email", dan "Pengaturan".
Tempat item dalam menu opsi muncul di layar bergantung pada versi aplikasi yang Anda kembangkan:
Untuk informasi selengkapnya tentang item tindakan dan perilaku action-bar lainnya, lihat panduan Action-Bar.
Catatan: Sekalipun Anda tidak mengembangkan aplikasi untuk Android 3.0 atau yang lebih tinggi, Anda bisa membuat layout action-bar sendiri untuk mendapatkan efek serupa. Untuk contoh cara mendukung versi Android yang lebih lama dengan action-bar, lihat contoh Kompatibilitas Action-Bar .
Gambar 2. Action-bar dari aplikasi Honeycomb Gallery, yang menampilkan tab-tab navigasi dan item tindakan kamera (plus tombol kelebihan tindakan).
Anda bisa mendeklarasikan item untuk menu opsi dari subkelas {@link android.app.Activity} atau subkelas {@link android.app.Fragment}. Jika aktivitas maupun fragmen Anda mendeklarasikan item menu opsi, keduanya akan dikombinasikan dalam UI. Item aktivitas akan muncul lebih dahulu, diikuti oleh item tiap fragmen sesuai dengan urutan penambahan fragmen ke aktivitas. Jika perlu, Anda bisa menyusun ulang item menu dengan atribut {@code android:orderInCategory} dalam setiap {@code <item>} yang perlu Anda pindahkan.
Untuk menetapkan menu opsi suatu aktivitas, kesampingkan {@link android.app.Activity#onCreateOptionsMenu(Menu) onCreateOptionsMenu()} (fragmen-fragmen menyediakan callback {@link android.app.Fragment#onCreateOptionsMenu onCreateOptionsMenu()} sendiri). Dalam metode ini , Anda bisa memekarkan sumber daya menu (yang didefinisikan dalam XML) menjadi {@link android.view.Menu} yang disediakan dalam callback. Misalnya:
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = {@link android.app.Activity#getMenuInflater()};
inflater.inflate(R.menu.game_menu, menu);
return true;
}
Anda juga bisa menambahkan item menu dengan menggunakan {@link android.view.Menu#add(int,int,int,int) add()} dan mengambil item dengan {@link android.view.Menu#findItem findItem()} untuk merevisi propertinya dengan API {@link android.view.MenuItem}.
Jika Anda mengembangkan aplikasi untuk Android 2.3.x dan yang lebih rendah, sistem akan memanggil {@link android.app.Activity#onCreateOptionsMenu(Menu) onCreateOptionsMenu()} untuk membuat menu opsi bila pengguna membuka menu untuk pertama kali. Jika Anda mengembangkan aplikasi untuk Android 3.0 dan yang lebih tinggi, sistem akan memanggil {@link android.app.Activity#onCreateOptionsMenu(Menu) onCreateOptionsMenu()} saat memulai aktivitas, untuk menampilkan item menu pada action-bar.
Bila pengguna memilih item dari menu opsi (termasuk item tindakan dalam action-bar), sistem akan memanggil metode {@link android.app.Activity#onOptionsItemSelected(MenuItem) onOptionsItemSelected()} aktivitas Anda. Metode ini meneruskan {@link android.view.MenuItem} yang dipilih. Anda bisa mengidentifikasi item dengan memanggil {@link android.view.MenuItem#getItemId()}, yang menghasilkan ID unik untuk item menu itu (yang didefinisikan oleh atribut {@code android:id} dalam sumber daya menu atau dengan integer yang diberikan ke metode {@link android.view.Menu#add(int,int,int,int) add()}). Anda bisa mencocokkan ID ini dengan item menu yang diketahui untuk melakukan tindakan yang sesuai. Misalnya:
@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 {@code true}. Jika tidak menangani item menu , Anda harus memanggil implementasi superkelas {@link android.app.Activity#onOptionsItemSelected(MenuItem) onOptionsItemSelected()} (implementasi default menghasilkan false).
Jika aktivitas Anda menyertakan fragmen, sistem akan memanggil lebih dahulu {@link android.app.Activity#onOptionsItemSelected(MenuItem) onOptionsItemSelected()} untuk aktivitas, kemudian untuk setiap fragmen (sesuai dengan urutan penambahan fragmen) hingga satu fragmen mengembalikan {@code true} atau semua fragmen telah dipanggil.
Tip: Android 3.0 menambahkan kemampuan mendefinisikan perilaku on-click untuk item menu dalam XML, dengan menggunakan atribut {@code android:onClick}. Nilai atribut harus berupa nama metode yang didefinisikan aktivitas dengan menggunakan menu. Metode harus bersifat publik dan menerima satu parameter {@link android.view.MenuItem}—bila sistem memanggilnya, metode ini akan meneruskan item menu yang dipilih. Untuk informasi selengkapnya dan contoh, lihat dokumen Sumber Daya Menu.
Tip: Jika aplikasi Anda berisi banyak aktivitas dan sebagian menyediakan menu opsi yang sama, pertimbangkan untuk membuat aktivitas yang tidak mengimplementasikan apa-apa kecuali metode {@link android.app.Activity#onCreateOptionsMenu(Menu) onCreateOptionsMenu()} dan {@link android.app.Activity#onOptionsItemSelected(MenuItem) onOptionsItemSelected()}. Kemudian perluas kelas ini untuk setiap aktivitas yang harus menggunakan menu opsi yang sama. Dengan begini, Anda bisa mengelola satu set kode untuk menangani tindakan menu dan setiap kelas turunan mewarisi perilaku menu. Jika ingin menambahkan item menu ke salah satu aktivitas turunan, kesampingkan {@link android.app.Activity#onCreateOptionsMenu(Menu) onCreateOptionsMenu()} dalam aktivitas itu. Panggil {@code super.onCreateOptionsMenu(menu)} agar item menu asli dibuat, kemudian tambahkan item menu yang baru dengan {@link android.view.Menu#add(int,int,int,int) menu.add()}. Anda juga bisa mengesampingkan perilaku superkelas untuk setiap item menu.
Setelah sistem memanggil {@link android.app.Activity#onCreateOptionsMenu(Menu) onCreateOptionsMenu()}, sistem akan mempertahankan instance {@link android.view.Menu} yang Anda tempatkan dan tidak akan memanggil {@link android.app.Activity#onCreateOptionsMenu(Menu) onCreateOptionsMenu()} lagi kecuali menu diinvalidkan karena suatu alasan. Akan tetapi, Anda harus menggunakan {@link android.app.Activity#onCreateOptionsMenu(Menu) onCreateOptionsMenu()} hanya untuk membuat status menu awal dan tidak untuk membuat perubahan selama daur hidup aktivitas.
Jika Anda ingin mengubah menu opsi berdasarkan kejadian yang terjadi selama daur hidup aktivitas, Anda bisa melakukannya dalam metode {@link android.app.Activity#onPrepareOptionsMenu(Menu) onPrepareOptionsMenu()}. Metode ini meneruskan objek {@link android.view.Menu} sebagaimana adanya saat ini sehingga Anda bisa mengubahnya, seperti menambah, menghapus, atau menonaktifkan item. (Fragmen juga menyediakan callback {@link android.app.Fragment#onPrepareOptionsMenu onPrepareOptionsMenu()}.)
Pada Android 2.3.x dan yang lebih rendah, sistem akan memanggil {@link android.app.Activity#onPrepareOptionsMenu(Menu) onPrepareOptionsMenu()} setiap kali pengguna membuka menu opsi (menekan tombol Menu ).
Pada Android 3.0 dan yang lebih tinggi, menu opsi dianggap sebagai selalu terbuka saat item menu ditampilkan pada action-bar. Bila ada kejadian dan Anda ingin melakukan pembaruan menu, Anda harus memanggil {@link android.app.Activity#invalidateOptionsMenu invalidateOptionsMenu()} untuk meminta sistem memanggil {@link android.app.Activity#onPrepareOptionsMenu(Menu) onPrepareOptionsMenu()}.
Catatan: Anda tidak boleh mengubah item dalam menu opsi berdasarkan {@link android.view.View} yang saat ini difokus. Saat dalam mode sentuh (bila pengguna tidak sedang menggunakan trackball atau d-pad), tampilan tidak bisa mengambil fokus, sehingga Anda tidak boleh menggunakan fokus sebagai dasar untuk mengubah item dalam menu opsi. Jika Anda ingin menyediakan item menu yang peka konteks pada {@link android.view.View}, gunakan Menu Konteks.
Gambar 3. Cuplikan layar menu konteks mengambang (kiri) dan action-bar kontekstual (kanan).
Menu kontekstual menawarkan tindakan yang memengaruhi item atau bingkai konteks tertentu dalam UI. Anda bisa menyediakan menu konteks untuk setiap tampilan, tetapi menu ini paling sering digunakan untuk item pada {@link android.widget.ListView}, {@link android.widget.GridView}, atau kumpulan tampilan lainnya yang bisa digunakan pengguna untuk melakukan tindakan langsung pada setiap item.
Ada dua cara menyediakan tindakan kontekstual:
Catatan: Mode tindakan kontekstual tersedia pada Android 3.0 (API level 11) dan yang lebih tinggi dan merupakan teknik yang lebih disukai untuk menampilkan tindakan kontekstual bila tersedia. Jika aplikasi Anda mendukung versi yang lebih rendah daripada 3.0, maka Anda harus mundur ke menu konteks mengambang pada perangkat-perangkat itu.
Untuk menyediakan menu konteks mengambang:
Jika aktivitas Anda menggunakan {@link android.widget.ListView} atau {@link android.widget.GridView} dan Anda ingin setiap item untuk menyediakan menu konteks yang sama, daftarkan semua item ke menu konteks dengan meneruskan {@link android.widget.ListView} atau {@link android.widget.GridView} ke {@link android.app.Activity#registerForContextMenu(View) registerForContextMenu()}.
Bila tampilan yang terdaftar menerima kejadian klik-lama, sistem akan memanggil metode {@link android.view.View.OnCreateContextMenuListener#onCreateContextMenu onCreateContextMenu()} Anda. Inilah tempat Anda mendefinisikan item menu, biasanya dengan memekarkan sumber daya menu. Misalnya:
@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);
}
{@link android.view.MenuInflater} memungkinkan Anda untuk memekarkan menu konteks sumber daya menu. Parameter metode callback menyertakan {@link android.view.View} yang dipilih pengguna dan objek {@link android.view.ContextMenu.ContextMenuInfo} yang menyediakan informasi tambahan tentang item yang dipilih. Jika aktivitas Anda memiliki beberapa tampilan yang masing-masingnya menyediakan menu konteks berbeda, Anda bisa menggunakan parameter ini untuk menentukan menu konteks yang harus dimekarkan.
Bila pengguna memilih item menu, sistem akan memanggil metode ini sehingga Anda bisa melakukan tindakan yang sesuai. Misalnya:
@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);
}
}
Metode {@link android.view.MenuItem#getItemId()} melakukan query ID untuk item menu yang dipilih, yang harus Anda tetapkan ke setiap item menu dalam XML dengan menggunakan atribut {@code android:id}, seperti yang ditampilkan di bagian tentang Mendefinisikan Menu dalam XML.
Bila Anda berhasil menangani sebuah item menu, kembalikan {@code true}. Jika tidak menangani item menu, Anda harus meneruskan item menu ke implementasi superkelas. Jika aktivitas Anda menyertakan fragmen, aktivitas akan menerima callback ini lebih dahulu. Dengan memanggil superkelas bila tidak ditangani, sistem meneruskan kejadian ke metode callback di setiap fragmen, satu per satu (sesuai dengan urutan penambahan fragmen) hingga {@code true} atau {@code false} dikembalikan. (Implementasi default untuk {@link android.app.Activity} dan {@code android.app.Fragment} mengembalikan {@code false}, sehingga Anda harus selalu memanggil superkelas bila tidak ditangani.)
Mode tindakan kontekstual adalah implementasi sistem {@link android.view.ActionMode} yang memfokuskan interaksi pengguna pada upaya melakukan tindakan kontekstual. Bila seorang pengguna mengaktifkan mode ini dengan memilih item, action-bar kontekstual akan muncul di bagian atas layar untuk menampilkan tindakan yang bisa dilakukan pengguna pada item yang dipilih saat ini. Selagi mode ini diaktifkan, pengguna bisa memilih beberapa item (jika Anda mengizinkan), membatalkan pilihan item, dan melanjutkan penelusuran dalam aktivitas (sebanyak yang ingin Anda izinkan). Mode tindakan dinonaktifkan dan action-bar kontekstual menghilang bila pengguna membatalkan pilihan semua item, menekan tombol BACK, atau memilih tindakan Done di sisi kiri action-bar.
Catatan: Action-bar kontekstual tidak harus terkait dengan action-bar. Action-bar ini beroperasi secara independen, walaupun action-bar kontekstual secara visual mengambil alih posisi action-bar.
Jika Anda mengembangkan aplikasi untuk Android 3.0 (API level 11) atau yang lebih tinggi, Anda biasanya harus menggunakan mode tindakan kontekstual untuk menampilkan tindakan kontekstual, sebagai ganti menu konteks mengambang.
Untuk tampilan yang menyediakan tindakan kontekstual, Anda biasanya harus memanggil mode tindakan kontekstual pada salah satu dari dua kejadian (atau keduanya):
Cara aplikasi memanggil mode tindakan kontekstual dan mendefinisikan perilaku setiap tindakan bergantung pada desain Anda. Pada dasarnya ada dua desain:
Bagian berikut ini menjelaskan penyiapan yang diperlukan untuk setiap skenario.
Jika Anda ingin memanggil mode tindakan kontekstual hanya bila pengguna memilih tampilan tertentu, Anda harus:
Misalnya:
private ActionMode.Callback mActionModeCallback = new ActionMode.Callback() {
// Called when the action mode is created; startActionMode() was 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, but
// may 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) {
mActionMode = null;
}
};
Perhatikan bahwa kejadian callback ini hampir persis sama dengan callback untuk menu opsi, hanya saja setiap callback ini juga meneruskan objek {@link android.view.ActionMode} yang terkait dengan kejadian. Anda bisa menggunakan API {@link android.view.ActionMode} untuk membuat berbagai perubahan pada CAB, seperti merevisi judul dan subjudul dengan {@link android.view.ActionMode#setTitle setTitle()} dan {@link android.view.ActionMode#setSubtitle setSubtitle()} (berguna untuk menunjukkan jumlah item yang dipilih).
Juga perhatikan bahwa contoh di atas mengatur variabel {@code mActionMode} ke nol bila mode tindakan dimusnahkan. Dalam langkah berikutnya, Anda akan melihat cara variabel diinisialisasi dan kegunaan menyimpan variabel anggota dalam aktivitas atau fragmen.
someView.setOnLongClickListener(new View.OnLongClickListener() {
// Called when the user long-clicks on someView
public boolean onLongClick(View view) {
if (mActionMode != null) {
return false;
}
// Start the CAB using the ActionMode.Callback defined above
mActionMode = getActivity().startActionMode(mActionModeCallback);
view.setSelected(true);
return true;
}
});
Bila Anda memanggil {@link android.app.Activity#startActionMode startActionMode()}, sistem akan mengembalikan {@link android.view.ActionMode} yang dibuat. Dengan menyimpannya dalam variabel anggota, Anda bisa membuat perubahan ke action-bar kontekstual sebagai respons terhadap kejadian lainnya. Dalam contoh di atas, {@link android.view.ActionMode} digunakan untuk memastikan bahwa instance {@link android.view.ActionMode} tidak dibuat kembali jika sudah aktif, dengan memeriksa apakah anggota bernilai nol sebelum memulai mode tindakan.
Jika Anda memiliki sekumpulan item dalam {@link android.widget.ListView} atau {@link android.widget.GridView} (atau ekstensi {@link android.widget.AbsListView} lainnya) dan ingin mengizinkan pengguna melakukan tindakan batch, Anda harus:
Misalnya:
ListView listView = getListView();
listView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE_MODAL);
listView.setMultiChoiceModeListener(new MultiChoiceModeListener() {
@Override
public void onItemCheckedStateChanged(ActionMode mode, int position,
long id, boolean checked) {
// Here you can do something when items are selected/de-selected,
// such as update the title in the CAB
}
@Override
public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
// Respond to clicks on the actions in the CAB
switch (item.getItemId()) {
case R.id.menu_delete:
deleteSelectedItems();
mode.finish(); // Action picked, so close the CAB
return true;
default:
return false;
}
}
@Override
public boolean onCreateActionMode(ActionMode mode, Menu menu) {
// Inflate the menu for the CAB
MenuInflater inflater = mode.getMenuInflater();
inflater.inflate(R.menu.context, menu);
return true;
}
@Override
public void onDestroyActionMode(ActionMode mode) {
// Here you can make any necessary updates to the activity when
// the CAB is removed. By default, selected items are deselected/unchecked.
}
@Override
public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
// Here you can perform updates to the CAB due to
// an {@link android.view.ActionMode#invalidate} request
return false;
}
});
Demikian saja. Kini bila pengguna memilih item dengan klik-lama, sistem akan memanggil metode {@link android.widget.AbsListView.MultiChoiceModeListener#onCreateActionMode onCreateActionMode()} dan menampilkan action-bar kontekstual bersama tindakan yang ditetapkan. Saat action-bar kontekstual terlihat, pengguna bisa memilih item tambahan.
Dalam beberapa kasus di mana tindakan kontekstual menyediakan item tindakan umum, Anda mungkin ingin menambahkan kotak cek atau elemen UI serupa yang memungkinkan pengguna memilih item, karena pengguna mungkin tidak menemukan perilaku klik-lama. Bila pengguna memilih kotak cek itu, Anda bisa memanggil mode tindakan kontekstual dengan mengatur item daftar yang bersangkutan ke status diberi tanda cek dengan {@link android.widget.AbsListView#setItemChecked setItemChecked()}.
Gambar 4. Menu popup dalam aplikasi Gmail, dikaitkan pada tombol kelebihan di sudut kanan atas.
{@link android.widget.PopupMenu} adalah menu modal yang dikaitkan pada {@link android.view.View}. Menu ini muncul di bawah tampilan jangkar jika ada ruang, atau di atas tampilan jika tidak ada. Menu ini berguna untuk:
Catatan: Ini tidak sama dengan menu konteks, yang umumnya untuk tindakan yang memengaruhi konten yang dipilih. Untuk tindakan yang memengaruhi konten yang dipilih, gunakan mode tindakan kontekstual atau menu konteks mengambang.
Catatan: {@link android.widget.PopupMenu} tersedia dengan API level 11 dan yang lebih tinggi.
Jika Anda mendefinisikan menu dalam XML, berikut ini adalah cara Anda menampilkan menu popup:
Misalnya, berikut ini adalah tombol dengan atribut {@link android.R.attr#onClick android:onClick} yang menampilkan menu popup:
<ImageButton
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:src="@drawable/ic_overflow_holo_dark"
android:contentDescription="@string/descr_overflow_button"
android:onClick="showPopup" />
Aktivitas nanti bisa menampilkan menu popup seperti ini:
public void showPopup(View v) {
PopupMenu popup = new PopupMenu(this, v);
MenuInflater inflater = popup.getMenuInflater();
inflater.inflate(R.menu.actions, popup.getMenu());
popup.show();
}
Dalam API level 14 dan yang lebih tinggi, Anda bisa menggabungkan dua baris yang memekarkan menu dengan {@link android.widget.PopupMenu#inflate PopupMenu.inflate()}.
Menu akan menghilang bila pengguna memilih item atau menyentuh di luar area menu. Anda bisa mendengarkan kejadian menghilangkan dengan menggunakan {@link android.widget.PopupMenu.OnDismissListener}.
Untuk melakukan suatu tindakan bila pengguna memilih item menu, Anda harus mengimplementasikan antarmuka {@link android.widget.PopupMenu.OnMenuItemClickListener} dan mendaftarkannya pada {@link android.widget.PopupMenu} dengan memanggil {@link android.widget.PopupMenu#setOnMenuItemClickListener setOnMenuItemclickListener()}. Bila pengguna memilih item, sistem akan memanggil callback {@link android.widget.PopupMenu.OnMenuItemClickListener#onMenuItemClick onMenuItemClick()} dalam antarmuka Anda.
Misalnya:
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;
}
}
Grup menu adalah sekumpulan item menu yang sama-sama memiliki ciri (trait) tertentu. Dengan grup, Anda bisa:
Anda bisa membuat grup dengan menyarangkan elemen-elemen {@code <item>} dalam elemen {@code <group>} dalam sumber daya menu atau dengan menetapkan ID grup dengan metode {@link android.view.Menu#add(int,int,int,int) add()}.
Berikut ini adalah contoh sumber daya menu yang berisi 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 berada dalam grup akan muncul pada level yang sama dengan item pertama—ketiga item dalam menu adalah bersaudara. Akan tetapi, Anda bisa memodifikasi ciri kedua item dalam grup dengan mengacu ID grup dan menggunakan metode yang tercantum di atas. Sistem juga tidak akan memisahkan item yang telah dikelompokkan. Misalnya, jika Anda mendeklarasikan {@code android:showAsAction="ifRoom"} untuk tiap item, item tersebut akan muncul dalam action-bar atau dalam kelebihan tindakan.
Gambar 5. Cuplikan layar submenu dengan item yang bisa diberi tanda cek.
Menu bisa digunakan sebagai antarmuka untuk mengaktifkan dan menonaktifkan opsi, menggunakan kotak cek untuk opsi mandiri, atau tombol radio untuk grup opsi yang saling eksklusif. Gambar 5 menampilkan submenu dengan item yang bisa diberi tanda cek dengan tombol radio.
Catatan: Item menu dalam Icon Menu (dari menu opsi) tidak bisa menampilkan kotak cek atau tombol radio. Jika Anda memilih untuk membuat item dalam Icon Menu yang bisa diberi tanda cek, Anda harus menandai status diberi tanda cek secara manual dengan menukar ikon dan/atau teks tiap kali statusnya berubah.
Anda bisa mendefinisikan perilaku yang bisa diberi tanda cek untuk tiap item menu dengan menggunakan atribut {@code android:checkable} dalam elemen {@code <item>}, atau untuk seluruh grup dengan atribut {@code android:checkableBehavior} dalam elemen {@code <group>}. Misalnya , semua item dalam grup menu ini bisa diberi tanda cek dengan tombol radio:
<?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 {@code android:checkableBehavior} menerima:
Anda bisa menerapkan status diberi tanda cek default pada suatu item dengan menggunakan atribut {@code android:checked} dalam elemen {@code <item>} dan mengubahnya dalam kode dengan metode {@link android.view.MenuItem#setChecked(boolean) setChecked()}.
Bila item yang bisa diberi tanda cek dipilih, sistem akan memanggil metode callback setiap item yang dipilih (seperti {@link android.app.Activity#onOptionsItemSelected(MenuItem) onOptionsItemSelected()}). Di sinilah Anda harus mengatur status kotak cek itu, karena kotak cek atau tombol radio tidak mengubah statusnya secara otomatis. Anda bisa melakukan query status saat ini suatu item (seperti sebelum pengguna memilihnya) dengan {@link android.view.MenuItem#isChecked()} kemudian mengatur status diberi tanda cek dengan {@link android.view.MenuItem#setChecked(boolean) setChecked()}. Misalnya:
@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 diberi tanda cek dengan cara ini, maka status item (kotak cek atau tombol radio) yang terlihat tidak akan berubah bila pengguna memilihnya. Bila Anda telah mengatur status, aktivitas akan menjaga status diberi tanda cek suatu item sehingga bila nanti pengguna membuka menu, status diberi tanda cek yang Anda atur akan terlihat.
Catatan: Item menu yang bisa diberi tanda cek dimaksudkan untuk digunakan hanya atas dasar per sesi dan tidak disimpan setelah aplikasi dimusnahkan. Jika Anda memiliki pengaturan aplikasi yang ingin disimpan untuk pengguna, Anda harus menyimpan data dengan menggunakan Shared Preferences.
Kadang-kadang Anda ingin supaya item menu menjalankan aktivitas dengan menggunakan {@link android.content.Intent} (baik aktivitas berada dalam aplikasi Anda maupun di aplikasi lain). Bila Anda mengetahui intent yang ingin digunakan dan memiliki item menu tertentu yang harus memulai intent, Anda bisa mengeksekusi intent dengan {@link android.app.Activity#startActivity(Intent) startActivity()} selama metode callback bila-item-dipilih yang sesuai (seperti callback {@link android.app.Activity#onOptionsItemSelected(MenuItem) onOptionsItemSelected()}).
Akan tetapi, jika Anda tidak yakin apakah perangkat pengguna berisi aplikasi yang menangani intent, maka menambahkan item menu yang memanggilnya bisa mengakibatkan item menu tidak berfungsi, karena intent tidak bisa diterjemahkan menjadi aktivitas. Untuk mengatasi hal ini, Android memungkinkan Anda menambahkan item menu secara dinamis ke menu bila Android menemukan aktivitas pada perangkat yang menangani intent Anda.
Untuk menambahkan item menu berdasarkan aktivitas tersedia yang menerima intent:
Jika tidak ada aplikasi terinstal yang memenuhi intent, maka tidak ada item menu yang ditambahkan.
Catatan: {@link android.content.Intent#CATEGORY_SELECTED_ALTERNATIVE} digunakan untuk menangani elemen yang saat ini dipilih pada layar. Jadi, metode hanya digunakan saat membuat Menu dalam {@link android.app.Activity#onCreateContextMenu(ContextMenu,View,ContextMenuInfo) onCreateContextMenu()}.
Misalnya:
@Override
public boolean onCreateOptionsMenu(Menu menu){
super.onCreateOptionsMenu(menu);
// Create an Intent that describes the requirements to fulfill, to be included
// in our 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 applications.
menu.addIntentOptions(
R.id.intent_group, // Menu group to which new items will be 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 our requirements
0, // Additional flags to control items (none)
null); // Array of MenuItems that correlate to specific items (none)
return true;
}
Untuk setiap aktivitas yang diketahui menyediakan filter intent yang cocok dengan intent yang didefinisikan, item menu
akan ditambahkan, menggunakan nilai dalam filter intent android:label sebagai
judul item menu dan ikon aplikasi sebagai ikon item menu. Metode
{@link android.view.Menu#addIntentOptions(int,int,int,ComponentName,Intent[],Intent,int,MenuItem[])
addIntentOptions()} mengembalikan jumlah item menu yang ditambahkan.
Catatan: Bila Anda memanggil {@link android.view.Menu#addIntentOptions(int,int,int,ComponentName,Intent[],Intent,int,MenuItem[]) addIntentOptions()}, metode ini akan mengesampingkan setiap dan semua item menu menurut grup menu yang ditetapkan dalam argumen pertama.
Anda juga bisa menawarkan layanan aktivitas Anda pada aplikasi lainnya, sehingga aplikasi Anda bisa disertakan dalam menu aplikasi lain (membalik peran yang dijelaskan di atas).
Agar bisa dimasukkan dalam menu aplikasi lain, Anda perlu mendefinisikan filter intent seperti biasa, tetapi pastikan menyertakan nilai-nilai {@link android.content.Intent#CATEGORY_ALTERNATIVE} dan/atau {@link android.content.Intent#CATEGORY_SELECTED_ALTERNATIVE} untuk kategori filter intent. Misalnya:
<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 penulisan filter intent dalam dokumen Intent dan Filter Intent.
Untuk contoh aplikasi yang menggunakan teknik ini, lihat contoh kode Note Pad.