ActionBar官方教程(10)ActionBar的下拉列表模式

Adding Drop-down Navigation

　　As another mode of navigation (or filtering) for your activity, the action bar offers a built in drop-down list (also known as a "spinner"). For example, the drop-down list can offer different modes by which content in the activity is sorted.

Figure 9. A drop-down navigation list in the action bar.

　　Using the drop-down list is useful when changing the content is important but not necessarily a frequent occurrence. In cases where switching the content is more frequent, you should use navigation tabsinstead.

　　The basic procedure to enable drop-down navigation is:

　　ActionBar开启下拉列表模式的基本步骤

Create a SpinnerAdapter that provides the list of selectable items for the drop-down and the layout to use when drawing each item in the list.
```
准备下拉list的adapter
```
Implement ActionBar.OnNavigationListener to define the behavior that occurs when the user selects an item from the list.
```
实现ActionBar.OnNavigationListener,处理下拉列表的item事件
```
During your activity's onCreate() method, enable the action bar's drop-down list by calling setNavigationMode(NAVIGATION_MODE_LIST).
```
设备ActionBar.setNavigationMode(NAVIGATION_MODE_LIST);设置ActionBar为下拉模式
```
Set the callback for the drop-down list with setListNavigationCallbacks(). For example:
```
注册SpinnerAdapter 和 ActionBar.OnNavigationListener
```
```
actionBar.setListNavigationCallbacks(mSpinnerAdapter, mNavigationCallback);
```
This method takes your SpinnerAdapter and ActionBar.OnNavigationListener.

　　This procedure is relatively short, but implementing the SpinnerAdapter and ActionBar.OnNavigationListener is where most of the work is done. There are many ways you can implement these to define the functionality for your drop-down navigation and implementing various types of SpinnerAdapter is beyond the scope of this document (you should refer to the SpinnerAdapter class reference for more information). However, below is an example for a SpinnerAdapter and ActionBar.OnNavigationListener to get you started (click the title to reveal the sample).

Example SpinnerAdapter and OnNavigationListener

　　SpinnerAdapter is an adapter that provides data for a spinner widget, such as the drop-down list in the action bar. SpinnerAdapter is an interface that you can implement, but Android includes some useful implementations that you can extend, such as ArrayAdapter and SimpleCursorAdapter. For example, here's an easy way to create a SpinnerAdapter by using ArrayAdapter implementation, which uses a string array as the data source:

　　SpinnerAdapter mSpinnerAdapter = ArrayAdapter.createFromResource(this,
        R.array.action_list, android.R.layout.simple_spinner_dropdown_item);

　　The createFromResource() method takes three parameters: the application Context, the resource ID for the string array, and the layout to use for each list item.

A string array defined in a resource looks like this:

 <?xml version="1.0" encoding="utf-8"?>
 <resources>
     <string-array name="action_list">
         <item>Mercury</item>
         <item>Venus</item>
         <item>Earth</item>
     </string-array>
 </resources>

　　The ArrayAdapter returned by createFromResource() is complete and ready for you to pass it to setListNavigationCallbacks() (in step 4 from above). Before you do, though, you need to create the OnNavigationListener.

　　Your implementation of ActionBar.OnNavigationListener is where you handle fragment changes or other modifications to your activity when the user selects an item from the drop-down list. There's only one callback method to implement in the listener: onNavigationItemSelected().

　　The onNavigationItemSelected() method receives the position of the item in the list and a unique item ID provided by the SpinnerAdapter.

Here's an example that instantiates an anonymous implementation of OnNavigationListener, which inserts a Fragment into the layout container identified by R.id.fragment_container:

 mOnNavigationListener = new OnNavigationListener() {
   // Get the same strings provided for the drop-down's ArrayAdapter
   String[] strings = getResources().getStringArray(R.array.action_list);

   @Override
   public boolean onNavigationItemSelected(int position, long itemId) {
     // Create new fragment from our own Fragment class
     ListContentFragment newFragment = new ListContentFragment();
     FragmentTransaction ft = getSupportFragmentManager().beginTransaction();

     // Replace whatever is in the fragment container with this fragment
     // and give the fragment a tag name equal to the string at the position
     // selected
     ft.replace(R.id.fragment_container, newFragment, strings[position]);

     // Apply changes
     ft.commit();
     return true;
   }
 };

　　This instance of OnNavigationListener is complete and you can now callsetListNavigationCallbacks() (in step 4), passing the ArrayAdapter and this OnNavigationListener.

　　In this example, when the user selects an item from the drop-down list, a fragment is added to the layout (replacing the current fragment in the R.id.fragment_container view). The fragment added is given a tag that uniquely identifies it, which is the same string used to identify the fragment in the drop-down list.

Here's a look at the ListContentFragment class that defines each fragment in this example:

 public class ListContentFragment extends Fragment {
     private String mText;

     @Override
     public void onAttach(Activity activity) {
       // This is the first callback received; here we can set the text for
       // the fragment as defined by the tag specified during the fragment
       // transaction
       super.onAttach(activity);
       mText = getTag();
     }

     @Override
     public View onCreateView(LayoutInflater inflater, ViewGroup container,
             Bundle savedInstanceState) {
         // This is called to define the layout for the fragment;
         // we just create a TextView and set its text to be the fragment tag
         TextView text = new TextView(getActivity());
         text.setText(mText);
         return text;
     }
 }