The context menu is raised by a tap-and-hold action on the widget sporting the menu. By and large, context menus use the same guts as option menus. The two main
differences are how you populate the menu and how you are informed of menu choices. First, you need to indicate which widget(s) on your activity have context menus. To do this, call registerForContextMenu() from your activity, supplying the View that is the widget needing a context menu.
Next, you need to implement onCreateContextMenu(), which, among other things, is passed the View you supplied in registerForContextMenu(). You can use that to determine which menu to build, assuming your activity has more than one.
The onCreateContextMenu() method gets the ContextMenu itself, the View the context menu is associated with, and a ContextMenu.ContextMenuInfo, which tells you which item in the list the user did the tap-and-hold over, in case you want to customize the context menu based on that information. For example, you could toggle a checkable menu choice based on the current state of the item.
It is also important to note that onCreateContextMenu() is called for each time the context menu is requested. Unlike the options menu (which is built only once per activity), context menus are discarded after they are used or dismissed. Hence, you do not want to hold onto the supplied ContextMenu object; just rely on getting the chance to rebuild the menu to suit your activity’s needs on an on-demand basis based on user actions.
To find out when a context menu choice was chosen, implement
onContextItemSelected() on the activity. Note that you get only the MenuItem instance that was chosen in this callback. As a result, if your activity has two or more context menus, you may want to ensure they have unique menu item identifiers for all their choices, so you can distinguish between them in this callback. Also, you can call getMenuInfo() on the MenuItem to get the ContextMenu.ContextMenuInfo you received in
onCreateContextMenu(). Otherwise, this callback behaves the same as onOptionsItemSelected(), as described in the previous section.
Taking a Peek
In the sample project Menus/Menus, you will find an amended version of the ListView
sample (List) from Chapter 7 with an associated menu. Since the menus are defined in
Java code, the XML layout does not need to change from the one shown in that chapter. However, the Java code has a few new behaviors:
public class MenuDemo extends ListActivity { TextView selection;
String[] items={"lorem", "ipsum", "dolor", "sit", "amet", "consectetuer", "adipiscing", "elit", "morbi", "vel", "ligula", "vitae", "arcu", "aliquet", "mollis", "etiam", "vel", "erat", "placerat", "ante",
"porttitor", "sodales", "pellentesque", "augue", "purus"}; public static final int EIGHT_ID = Menu.FIRST+1;
public static final int SIXTEEN_ID = Menu.FIRST+2; public static final int TWENTY_FOUR_ID = Menu.FIRST+3; public static final int TWO_ID = Menu.FIRST+4;
public static final int THIRTY_TWO_ID = Menu.FIRST+5; public static final int FORTY_ID = Menu.FIRST+6; public static final int ONE_ID = Menu.FIRST+7; @Override
public void onCreate(Bundle icicle) { super.onCreate(icicle);
setContentView(R.layout.main);
setListAdapter(new ArrayAdapter<String>(this,
android.R.layout.simple_list_item_1, items)); selection=(TextView)findViewById(R.id.selection);
registerForContextMenu(getListView()); }
public void onListItemClick(ListView parent, View v, int position, long id) { selection.setText(items[position]);
}
@Override
public void onCreateContextMenu(ContextMenu menu, View v,
ContextMenu.ContextMenuInfo menuInfo) {
populateMenu(menu);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
populateMenu(menu);
return(super.onCreateOptionsMenu(menu)); }
@Override
public boolean onOptionsItemSelected(MenuItem item) { return(applyMenuChoice(item) ||
super.onOptionsItemSelected(item)); }
@Override
public boolean onContextItemSelected(MenuItem item) { return(applyMenuChoice(item) ||
super.onContextItemSelected(item)); }
private void populateMenu(Menu menu) {
menu.add(Menu.NONE, ONE_ID, Menu.NONE, "1 Pixel"); menu.add(Menu.NONE, TWO_ID, Menu.NONE, "2 Pixels"); menu.add(Menu.NONE, EIGHT_ID, Menu.NONE, "8 Pixels"); menu.add(Menu.NONE, SIXTEEN_ID, Menu.NONE, "16 Pixels"); menu.add(Menu.NONE, TWENTY_FOUR_ID, Menu.NONE, "24 Pixels"); menu.add(Menu.NONE, THIRTY_TWO_ID, Menu.NONE, "32 Pixels"); menu.add(Menu.NONE, FORTY_ID, Menu.NONE, "40 Pixels"); }
private boolean applyMenuChoice(MenuItem item) { switch (item.getItemId()) {
case ONE_ID: getListView().setDividerHeight(1); return(true); case EIGHT_ID: getListView().setDividerHeight(8); return(true); case SIXTEEN_ID: getListView().setDividerHeight(16); return(true); case TWENTY_FOUR_ID: getListView().setDividerHeight(24); return(true); case TWO_ID: getListView().setDividerHeight(2); return(true); case THIRTY_TWO_ID: getListView().setDividerHeight(32); return(true); case FORTY_ID: getListView().setDividerHeight(40); return(true); } return(false); } }
In onCreate(), we register our list widget as having a context menu, which we fill in via
our populateMenu() private method, by way of onCreateContextMenu().
We also implement the onCreateOptionsMenu() callback, indicating that our activity also
has an options menu. Once again, we delegate to populateMenu() to fill in the menu.
Our implementations of onOptionsItemSelected() (for options menu selections) and onContextItemSelected() (for context menu selections) both delegate to a private applyMenuChoice() method, plus chaining upward to the superclass if none of our menu
choices was the one selected by the user.
In populateMenu(), we add seven menu choices, each with a unique identifier. Being
lazy, we eschew the icons.
In applyMenuChoice(), we see if any of our menu choices were chosen. If so, we set the
list’s divider size to be the user-selected width.
Initially, the activity looks the same in the emulator as it did for ListDemo, as shown in
Figure 11–1.
Figure 11–1. The MenuDemo sample application, as initially launched
Figure 11–2. The same application, showing the options menu
Choosing the More button shows the remaining two menu choices, as shown in Figure 11–3.
Figure 11–3. The same application, showing the remaining menu choices
Choosing a height (say, 16 pixels) from the menu changes the divider height of the list to something garish, as shown in Figure 11–4.
Figure 11–4. The same application, made ugly
You can trigger the context menu, shown in Figure 11–5, by tapping and holding on any item in the list. Once again, choosing an option sets the divider height.