Android Support V4官方Demo概览（三）

本文介绍了Support V4包中DialogFragment、Fragment的Arguments、Fragment的上下文菜单、Fragment的自定义动画、Fragment数据的保存及恢复、Fragment横竖屏的不同布局的实现、ListFragment、创建菜单、嵌套的Tab、Fragment和ViewPager配合使用、Fragment中接收一个结果、Fragment横竖屏切换保持实例、Fragment栈、FragmentStatePagerAdapter及TabHost和ViewPager配合使用。

Alert Dialog

演示了怎样显示一个通过Fragment管理的AlertDialog。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
void showDialog() {
        DialogFragment newFragment = MyAlertDialogFragment.newInstance(
                R.string.alert_dialog_two_buttons_title);
        newFragment.show(getSupportFragmentManager(), "dialog");
    }

    public void doPositiveClick() {
        // Do stuff here.
        Log.i("FragmentAlertDialog", "Positive click!");
    }

    public void doNegativeClick() {
        // Do stuff here.
        Log.i("FragmentAlertDialog", "Negative click!");
    }



    public static class MyAlertDialogFragment extends DialogFragment {

        public static MyAlertDialogFragment newInstance(int title) {
            MyAlertDialogFragment frag = new MyAlertDialogFragment();
            Bundle args = new Bundle();
            args.putInt("title", title);
            frag.setArguments(args);
            return frag;
        }

        @Override
        public Dialog onCreateDialog(Bundle savedInstanceState) {
            int title = getArguments().getInt("title");

            return new AlertDialog.Builder(getActivity())
                    .setIcon(R.drawable.alert_dialog_icon)
                    .setTitle(title)
                    .setPositiveButton(R.string.alert_dialog_ok,
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int whichButton) {
                                ((FragmentAlertDialogSupport)getActivity()).doPositiveClick();
                            }
                        }
                    )
                    .setNegativeButton(R.string.alert_dialog_cancel,
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int whichButton) {
                                ((FragmentAlertDialogSupport)getActivity()).doNegativeClick();
                            }
                        }
                    )
                    .create();
        }
    }

Arguments

演示了一个可以通过Bundle参数和layout属性配置的Fragment。

通过Bundle传参

1
Fragment newFragment = MyFragment.newInstance("From Arguments");

通过layout属性配置

1
2
3
4
5
<fragment class="com.example.android.supportv4.app.FragmentArgumentsSupport$MyFragment"
                android:id="@+id/embedded"
                android:layout_width="0px" android:layout_height="wrap_content"
                android:layout_weight="1"
                android:label="@string/fragment_arguments_embedded" />

Fragment

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public static class MyFragment extends Fragment {
    CharSequence mLabel;

    /**
     * Create a new instance of MyFragment that will be initialized
     * with the given arguments.
     */
    static MyFragment newInstance(CharSequence label) {
        MyFragment f = new MyFragment();
        Bundle b = new Bundle();
        b.putCharSequence("label", label);
        f.setArguments(b);
        return f;
    }

    /**
     * Parse attributes during inflation from a view hierarchy into the
     * arguments we handle.
     */
    @Override public void onInflate(Activity activity, AttributeSet attrs,
            Bundle savedInstanceState) {
        super.onInflate(activity, attrs, savedInstanceState);

        TypedArray a = activity.obtainStyledAttributes(attrs,
                R.styleable.FragmentArguments);
        mLabel = a.getText(R.styleable.FragmentArguments_android_label);
        a.recycle();
    }

    /**
     * During creation, if arguments have been supplied to the fragment
     * then parse those out.
     */
    @Override public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Bundle args = getArguments();
        if (args != null) {
            CharSequence label = args.getCharSequence("label");
            if (label != null) {
                mLabel = label;
            }
        }
    }

    /**
     * Create the view for this fragment, using the arguments given to it.
     */
    @Override public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.hello_world, container, false);
        View tv = v.findViewById(R.id.text);
        ((TextView)tv).setText(mLabel != null ? mLabel : "(no label)");
        tv.setBackgroundDrawable(getResources().getDrawable(android.R.drawable.gallery_thumb));
        return v;
    }
}

Context Menu

演示了从Fragment中显示一个上下文菜单。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public static class ContextMenuFragment extends Fragment {

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        View root = inflater.inflate(R.layout.fragment_context_menu, container, false);
        registerForContextMenu(root.findViewById(R.id.long_press));
        return root;
    }

    @Override
    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
        super.onCreateContextMenu(menu, v, menuInfo);
        menu.add(Menu.NONE, R.id.a_item, Menu.NONE, "Menu A");
        menu.add(Menu.NONE, R.id.b_item, Menu.NONE, "Menu B");
    }

    @Override
    public boolean onContextItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.a_item:
                Log.i("ContextMenu", "Item 1a was chosen");
                return true;
            case R.id.b_item:
                Log.i("ContextMenu", "Item 1b was chosen");
                return true;
        }
        return super.onContextItemSelected(item);
    }
}

Custom Animation

给Fragment设置自定义动画。

1
2
3
4
5
6
7
8
9
10
11
12
13
// Instantiate a new fragment.
Fragment newFragment = CountingFragment.newInstance(mStackLevel);

// Add the fragment to the activity, pushing this transaction
// on to the back stack.
FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
ft.setCustomAnimations(R.anim.fragment_slide_left_enter,
        R.anim.fragment_slide_left_exit,
        R.anim.fragment_slide_right_enter,
        R.anim.fragment_slide_right_exit);
ft.replace(R.id.simple_fragment, newFragment);
ft.addToBackStack(null);
ft.commit();

Dialog

使用DialogFragment显示一个对话框。

Dialog or Activity

演示了同一个Fragment作为dialog显示和嵌入到activity中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
if (savedInstanceState == null) {
    // First-time init; create fragment to embed in activity.

    FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
    DialogFragment newFragment = MyDialogFragment.newInstance();
    ft.add(R.id.embedded, newFragment);
    ft.commit();

}


void showDialog() {
    // Create the fragment and show it as a dialog.
    DialogFragment newFragment = MyDialogFragment.newInstance();
    newFragment.show(getSupportFragmentManager(), "dialog");
}

public static class MyDialogFragment extends DialogFragment {
    static MyDialogFragment newInstance() {
        return new MyDialogFragment();
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.hello_world, container, false);
        View tv = v.findViewById(R.id.text);
        ((TextView)tv).setText("This is an instance of MyDialogFragment");
        return v;
    }
}

Hide and Show

演示了隐藏和显示fragment并且可以保存和恢复文本数据。第一种使用了Bundle进行数据的保存和恢复，第二种使用了View.setSaveEnabled进行数据的保存和恢复。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
void addShowHideListener(int buttonId, final Fragment fragment) {
    final Button button = (Button)findViewById(buttonId);
    button.setOnClickListener(new OnClickListener() {
        public void onClick(View v) {
            FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
            ft.setCustomAnimations(android.R.anim.fade_in,
                    android.R.anim.fade_out);
            if (fragment.isHidden()) {
                ft.show(fragment);
                button.setText("Hide");
            } else {
                ft.hide(fragment);
                button.setText("Show");
            }
            ft.commit();
        }
    });
}

public static class FirstFragment extends Fragment {
    TextView mTextView;

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.labeled_text_edit, container, false);
        View tv = v.findViewById(R.id.msg);
        ((TextView)tv).setText("The fragment saves and restores this text.");

        // Retrieve the text editor, and restore the last saved state if needed.
        mTextView = (TextView)v.findViewById(R.id.saved);
        if (savedInstanceState != null) {
            mTextView.setText(savedInstanceState.getCharSequence("text"));
        }
        return v;
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);

        // Remember the current text, to restore if we later restart.
        outState.putCharSequence("text", mTextView.getText());
    }
}

public static class SecondFragment extends Fragment {

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.labeled_text_edit, container, false);
        View tv = v.findViewById(R.id.msg);
        ((TextView)tv).setText("The TextView saves and restores this text.");

        // Retrieve the text editor and tell it to save and restore its state.
        // Note that you will often set this in the layout XML, but since
        // we are sharing our layout with the other fragment we will customize
        // it here.
        ((TextView)v.findViewById(R.id.saved)).setSaveEnabled(true);
        return v;
    }
}

Layout

演示了使用fragment实现不同的activity布局。这个例子提供了不同的布局（activity流）当运行在横屏时。

本例子提供了两个不同的布局：横屏和竖屏，竖屏中包含TitlesFragment，横屏中包含TitlesFragment和DetailsFragment。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
public class FragmentLayoutSupport extends FragmentActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);

      setContentView(R.layout.fragment_layout_support);
  }


  /**
   * This is a secondary activity, to show what the user has selected
   * when the screen is not large enough to show it all in one activity.
   */

  public static class DetailsActivity extends FragmentActivity {

      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);

          if (getResources().getConfiguration().orientation
                  == Configuration.ORIENTATION_LANDSCAPE) {
              // If the screen is now in landscape mode, we can show the
              // dialog in-line with the list so we don't need this activity.
              finish();
              return;
          }

          if (savedInstanceState == null) {
              // During initial setup, plug in the details fragment.
              DetailsFragment details = new DetailsFragment();
              details.setArguments(getIntent().getExtras());
              getSupportFragmentManager().beginTransaction().add(
                      android.R.id.content, details).commit();
          }
      }
  }


  /**
   * This is the "top-level" fragment, showing a list of items that the
   * user can pick.  Upon picking an item, it takes care of displaying the
   * data to the user as appropriate based on the currrent UI layout.
   */

  public static class TitlesFragment extends ListFragment {
      boolean mDualPane;
      int mCurCheckPosition = 0;

      @Override
      public void onActivityCreated(Bundle savedInstanceState) {
          super.onActivityCreated(savedInstanceState);

          // Populate list with our static array of titles.
          setListAdapter(new ArrayAdapter<String>(getActivity(),
                  R.layout.simple_list_item_checkable_1,
                  android.R.id.text1, Shakespeare.TITLES));

          // Check to see if we have a frame in which to embed the details
          // fragment directly in the containing UI.
          View detailsFrame = getActivity().findViewById(R.id.details);
          mDualPane = detailsFrame != null && detailsFrame.getVisibility() == View.VISIBLE;

          if (savedInstanceState != null) {
              // Restore last state for checked position.
              mCurCheckPosition = savedInstanceState.getInt("curChoice", 0);
          }

          if (mDualPane) {
              // In dual-pane mode, the list view highlights the selected item.
              getListView().setChoiceMode(ListView.CHOICE_MODE_SINGLE);
              // Make sure our UI is in the correct state.
              showDetails(mCurCheckPosition);
          }
      }

      @Override
      public void onSaveInstanceState(Bundle outState) {
          super.onSaveInstanceState(outState);
          outState.putInt("curChoice", mCurCheckPosition);
      }

      @Override
      public void onListItemClick(ListView l, View v, int position, long id) {
          showDetails(position);
      }

      /**
       * Helper function to show the details of a selected item, either by
       * displaying a fragment in-place in the current UI, or starting a
       * whole new activity in which it is displayed.
       */
      void showDetails(int index) {
          mCurCheckPosition = index;

          if (mDualPane) {
              // We can display everything in-place with fragments, so update
              // the list to highlight the selected item and show the data.
              getListView().setItemChecked(index, true);

              // Check what fragment is currently shown, replace if needed.
              DetailsFragment details = (DetailsFragment)
                      getFragmentManager().findFragmentById(R.id.details);
              if (details == null || details.getShownIndex() != index) {
                  // Make new fragment to show this selection.
                  details = DetailsFragment.newInstance(index);

                  // Execute a transaction, replacing any existing fragment
                  // with this one inside the frame.
                  getFragmentManager().beginTransaction()
                          .replace(R.id.details, details)
                          .setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
                          .commit();
              }

          } else {
              // Otherwise we need to launch a new activity to display
              // the dialog fragment with selected text.
              Intent intent = new Intent();
              intent.setClass(getActivity(), DetailsActivity.class);
              intent.putExtra("index", index);
              startActivity(intent);
          }
      }
  }


  /**
   * This is the secondary fragment, displaying the details of a particular
   * item.
   */

  public static class DetailsFragment extends Fragment {
      /**
       * Create a new instance of DetailsFragment, initialized to
       * show the text at 'index'.
       */
      public static DetailsFragment newInstance(int index) {
          DetailsFragment f = new DetailsFragment();

          // Supply index input as an argument.
          Bundle args = new Bundle();
          args.putInt("index", index);
          f.setArguments(args);

          return f;
      }

      public int getShownIndex() {
          return getArguments().getInt("index", 0);
      }

      @Override
      public View onCreateView(LayoutInflater inflater, ViewGroup container,
              Bundle savedInstanceState) {
          if (container == null) {
              // We have different layouts, and in one of them this
              // fragment's containing frame doesn't exist.  The fragment
              // may still be created from its saved state, but there is
              // no reason to try to create its view hierarchy because it
              // won't be displayed.  Note this is not needed -- we could
              // just run the code below, where we would create and return
              // the view hierarchy; it would just never be used.
              return null;
          }

          ScrollView scroller = new ScrollView(getActivity());
          TextView text = new TextView(getActivity());
          int padding = (int)TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
                  4, getActivity().getResources().getDisplayMetrics());
          text.setPadding(padding, padding, padding, padding);
          scroller.addView(text);
          text.setText(Shakespeare.DIALOGUE[getShownIndex()]);
          return scroller;
      }
  }
}

竖屏


横屏

List Array

演示了使用ListFragment从数组中显式一个items列表。和上面竖屏效果一样。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static class ArrayListFragment extends ListFragment {

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        setListAdapter(new ArrayAdapter<String>(getActivity(),
                android.R.layout.simple_list_item_1, Shakespeare.TITLES));
    }

    @Override
    public void onListItemClick(ListView l, View v, int position, long id) {
        Log.i("FragmentList", "Item clicked: " + id);
    }
}

演示了Fragment怎样加入到选项菜单中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

/**
 * A fragment that displays a menu.  This fragment happens to not
 * have a UI (it does not implement onCreateView), but it could also
 * have one if it wanted.
 */
public static class MenuFragment extends Fragment {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setHasOptionsMenu(true);
    }

    @Override
    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
        MenuItem item;
        item = menu.add("Menu 1a");
        MenuItemCompat.setShowAsAction(item, MenuItemCompat.SHOW_AS_ACTION_IF_ROOM);
        item = menu.add("Menu 1b");
        MenuItemCompat.setShowAsAction(item, MenuItemCompat.SHOW_AS_ACTION_IF_ROOM);
    }
}

/**
 * Second fragment with a menu.
 */
public static class Menu2Fragment extends Fragment {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setHasOptionsMenu(true);
    }

    @Override
    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
        MenuItem item;
        item = menu.add("Menu 2");
        MenuItemCompat.setShowAsAction(item, MenuItemCompat.SHOW_AS_ACTION_IF_ROOM);
    }
}

Nesting Tabs

演示了嵌套的Tab。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class FragmentNestingTabsSupport extends FragmentActivity {
    private FragmentTabHost mTabHost;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mTabHost = new FragmentTabHost(this);
        setContentView(mTabHost);
        mTabHost.setup(this, getSupportFragmentManager(), R.id.fragment1);

        mTabHost.addTab(mTabHost.newTabSpec("menus").setIndicator("Menus"),
                FragmentMenuFragmentSupport.class, null);
        mTabHost.addTab(mTabHost.newTabSpec("contacts").setIndicator("Contacts"),
                LoaderCursorSupport.CursorLoaderListFragment.class, null);
        mTabHost.addTab(mTabHost.newTabSpec("stack").setIndicator("Stack"),
                FragmentStackFragmentSupport.class, null);
        mTabHost.addTab(mTabHost.newTabSpec("tabs").setIndicator("Tabs"),
                FragmentTabsFragmentSupport.class, null);
    }
}

Pager

演示了Fragment和ViewPager配合使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

public class FragmentPagerSupport extends FragmentActivity {
    static final int NUM_ITEMS = 10;

    MyAdapter mAdapter;

    ViewPager mPager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.fragment_pager);

        mAdapter = new MyAdapter(getSupportFragmentManager());

        mPager = (ViewPager)findViewById(R.id.pager);
        mPager.setAdapter(mAdapter);

        // Watch for button clicks.
        Button button = (Button)findViewById(R.id.goto_first);
        button.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                mPager.setCurrentItem(0);
            }
        });
        button = (Button)findViewById(R.id.goto_last);
        button.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                mPager.setCurrentItem(NUM_ITEMS-1);
            }
        });
    }

    public static class MyAdapter extends FragmentPagerAdapter {
        public MyAdapter(FragmentManager fm) {
            super(fm);
        }

        @Override
        public int getCount() {
            return NUM_ITEMS;
        }

        @Override
        public Fragment getItem(int position) {
            return ArrayListFragment.newInstance(position);
        }
    }

    public static class ArrayListFragment extends ListFragment {
        int mNum;

        /**
         * Create a new instance of CountingFragment, providing "num"
         * as an argument.
         */
        static ArrayListFragment newInstance(int num) {
            ArrayListFragment f = new ArrayListFragment();

            // Supply num input as an argument.
            Bundle args = new Bundle();
            args.putInt("num", num);
            f.setArguments(args);

            return f;
        }

        /**
         * When creating, retrieve this instance's number from its arguments.
         */
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            mNum = getArguments() != null ? getArguments().getInt("num") : 1;
        }

        /**
         * The Fragment's UI is just a simple text view showing its
         * instance number.
         */
        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                Bundle savedInstanceState) {
            View v = inflater.inflate(R.layout.fragment_pager_list, container, false);
            View tv = v.findViewById(R.id.text);
            ((TextView)tv).setText("Fragment #" + mNum);
            return v;
        }

        @Override
        public void onActivityCreated(Bundle savedInstanceState) {
            super.onActivityCreated(savedInstanceState);
            setListAdapter(new ArrayAdapter<String>(getActivity(),
                    android.R.layout.simple_list_item_1, Cheeses.sCheeseStrings));
        }

        @Override
        public void onListItemClick(ListView l, View v, int position, long id) {
            Log.i("FragmentList", "Item clicked: " + id);
        }
    }
}

Receive Result

演示了在Fragment中接收一个结果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
public static class ReceiveResultFragment extends Fragment {
    // Definition of the one requestCode we use for receiving resuls.
    static final private int GET_CODE = 0;

    private TextView mResults;

    private OnClickListener mGetListener = new OnClickListener() {
        public void onClick(View v) {
            // Start the activity whose result we want to retrieve.  The
            // result will come back with request code GET_CODE.
            Intent intent = new Intent(getActivity(), SendResult.class);
            startActivityForResult(intent, GET_CODE);
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.receive_result, container, false);

        // Retrieve the TextView widget that will display results.
        mResults = (TextView)v.findViewById(R.id.results);

        // This allows us to later extend the text buffer.
        mResults.setText(mResults.getText(), TextView.BufferType.EDITABLE);

        // Watch for button clicks.
        Button getButton = (Button)v.findViewById(R.id.get);
        getButton.setOnClickListener(mGetListener);

        return v;
    }

    /**
     * This method is called when the sending activity has finished, with the
     * result it supplied.
     */
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        // You can use the requestCode to select between multiple child
        // activities you may have started.  Here there is only one thing
        // we launch.
        if (requestCode == GET_CODE) {

            // We will be adding to our text.
            Editable text = (Editable)mResults.getText();

            // This is a standard resultCode that is sent back if the
            // activity doesn't supply an explicit result.  It will also
            // be returned if the activity failed to launch.
            if (resultCode == RESULT_CANCELED) {
                text.append("(cancelled)");

            // Our protocol with the sending activity is that it will send
            // text in 'data' as its result.
            } else {
                text.append("(okay ");
                text.append(Integer.toString(resultCode));
                text.append(") ");
                if (data != null) {
                    text.append(data.getAction());
                }
            }

            text.append("\n");
        }
    }
}

Retain Instance

这个例子说明了当Activity需要重启时，例如，配置改变时，你可以怎样使用Fragment跨Activity实例方便地传播状态（例如线程）。这个要比使用Activity.onRetainNonConfiguratinInstance() API简单的多。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

/**
 * This is a fragment showing UI that will be updated from work done
 * in the retained fragment.
 */
public static class UiFragment extends Fragment {
    RetainedFragment mWorkFragment;

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.fragment_retain_instance, container, false);

        // Watch for button clicks.
        Button button = (Button)v.findViewById(R.id.restart);
        button.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                mWorkFragment.restart();
            }
        });

        return v;
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        FragmentManager fm = getFragmentManager();

        // Check to see if we have retained the worker fragment.
        mWorkFragment = (RetainedFragment)fm.findFragmentByTag("work");

        // If not retained (or first time running), we need to create it.
        if (mWorkFragment == null) {
            mWorkFragment = new RetainedFragment();
            // Tell it who it is working with.
            mWorkFragment.setTargetFragment(this, 0);
            fm.beginTransaction().add(mWorkFragment, "work").commit();
        }
    }

}

/**
 * This is the Fragment implementation that will be retained across
 * activity instances.  It represents some ongoing work, here a thread
 * we have that sits around incrementing a progress indicator.
 */
public static class RetainedFragment extends Fragment {
    ProgressBar mProgressBar;
    int mPosition;
    boolean mReady = false;
    boolean mQuiting = false;

    /**
     * This is the thread that will do our work.  It sits in a loop running
     * the progress up until it has reached the top, then stops and waits.
     */
    final Thread mThread = new Thread() {
        @Override
        public void run() {
            // We'll figure the real value out later.
            int max = 10000;

            // This thread runs almost forever.
            while (true) {

                // Update our shared state with the UI.
                synchronized (this) {
                    // Our thread is stopped if the UI is not ready
                    // or it has completed its work.
                    while (!mReady || mPosition >= max) {
                        if (mQuiting) {
                            return;
                        }
                        try {
                            wait();
                        } catch (InterruptedException e) {
                        }
                    }

                    // Now update the progress.  Note it is important that
                    // we touch the progress bar with the lock held, so it
                    // doesn't disappear on us.
                    mPosition++;
                    max = mProgressBar.getMax();
                    mProgressBar.setProgress(mPosition);
                }

                // Normally we would be doing some work, but put a kludge
                // here to pretend like we are.
                synchronized (this) {
                    try {
                        wait(50);
                    } catch (InterruptedException e) {
                    }
                }
            }
        }
    };

    /**
     * Fragment initialization.  We way we want to be retained and
     * start our thread.
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Tell the framework to try to keep this fragment around
        // during a configuration change.
        setRetainInstance(true);

        // Start up the worker thread.
        mThread.start();
    }

    /**
     * This is called when the Fragment's Activity is ready to go, after
     * its content view has been installed; it is called both after
     * the initial fragment creation and after the fragment is re-attached
     * to a new activity.
     */
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        // Retrieve the progress bar from the target's view hierarchy.
        mProgressBar = (ProgressBar)getTargetFragment().getView().findViewById(
                R.id.progress_horizontal);

        // We are ready for our thread to go.
        synchronized (mThread) {
            mReady = true;
            mThread.notify();
        }
    }

    /**
     * This is called when the fragment is going away.  It is NOT called
     * when the fragment is being propagated between activity instances.
     */
    @Override
    public void onDestroy() {
        // Make the thread go away.
        synchronized (mThread) {
            mReady = false;
            mQuiting = true;
            mThread.notify();
        }

        super.onDestroy();
    }

    /**
     * This is called right before the fragment is detached from its
     * current activity instance.
     */
    @Override
    public void onDetach() {
        // This fragment is being detached from its activity.  We need
        // to make sure its thread is not going to touch any activity
        // state after returning from this function.
        synchronized (mThread) {
            mProgressBar = null;
            mReady = false;
            mThread.notify();
        }

        super.onDetach();
    }

    /**
     * API for our UI to restart the progress thread.
     */
    public void restart() {
        synchronized (mThread) {
            mPosition = 0;
            mThread.notify();
        }
    }
}

Stack

演示了Fragment栈（Stack）的使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

public class FragmentStackSupport extends FragmentActivity {
    int mStackLevel = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.fragment_stack);

        // Watch for button clicks.
        Button button = (Button)findViewById(R.id.new_fragment);
        button.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                addFragmentToStack();
            }
        });
        button = (Button)findViewById(R.id.home);
        button.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                // If there is a back stack, pop it all.
                FragmentManager fm = getSupportFragmentManager();
                if (fm.getBackStackEntryCount() > 0) {
                    fm.popBackStack(fm.getBackStackEntryAt(0).getId(),
                            FragmentManager.POP_BACK_STACK_INCLUSIVE);
                }
            }
        });

        Button btn_pop_top = (Button) findViewById(R.id.delete_fragment);
        btn_pop_top.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                FragmentManager fm = getSupportFragmentManager();
                if (fm.getBackStackEntryCount() > 0) {
                    fm.popBackStack(fm.getBackStackEntryAt(fm.getBackStackEntryCount()-1).getId(),
                            FragmentManager.POP_BACK_STACK_INCLUSIVE);
                }
            }
        });


        if (savedInstanceState == null) {
            // Do first time initialization -- add initial fragment.
            Fragment newFragment = CountingFragment.newInstance(mStackLevel);
            FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
            ft.add(R.id.simple_fragment, newFragment).commit();
        } else {
            mStackLevel = savedInstanceState.getInt("level");
        }
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putInt("level", mStackLevel);
    }


    void addFragmentToStack() {
        mStackLevel++;

        // Instantiate a new fragment.
        Fragment newFragment = CountingFragment.newInstance(mStackLevel);

        // Add the fragment to the activity, pushing this transaction
        // on to the back stack.
        FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
        ft.replace(R.id.simple_fragment, newFragment);
        ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
        ft.addToBackStack(null);
        ft.commit();
    }



    public static class CountingFragment extends Fragment {
        int mNum;

        /**
         * Create a new instance of CountingFragment, providing "num"
         * as an argument.
         */
        static CountingFragment newInstance(int num) {
            CountingFragment f = new CountingFragment();

            // Supply num input as an argument.
            Bundle args = new Bundle();
            args.putInt("num", num);
            f.setArguments(args);

            return f;
        }

        /**
         * When creating, retrieve this instance's number from its arguments.
         */
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            mNum = getArguments() != null ? getArguments().getInt("num") : 1;
        }

        /**
         * The Fragment's UI is just a simple text view showing its
         * instance number.
         */
        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                Bundle savedInstanceState) {
            View v = inflater.inflate(R.layout.hello_world, container, false);
            View tv = v.findViewById(R.id.text);
            ((TextView)tv).setText("Fragment #" + mNum);
            tv.setBackgroundDrawable(getResources().getDrawable(android.R.drawable.gallery_thumb));
            return v;
        }
    }

}

State Pager

演示了记录Fragment状态的Pager，关键类为MyAdapter继承了FragmentStatePagerAdapter。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public static class MyAdapter extends FragmentStatePagerAdapter {
    public MyAdapter(FragmentManager fm) {
        super(fm);
    }

    @Override
    public int getCount() {
        return NUM_ITEMS;
    }

    @Override
    public Fragment getItem(int position) {
        return ArrayListFragment.newInstance(position);
    }
}

Tabs

演示了怎样使用FragmentTabHost实现TabHost的tabs之间的切换。

Tabs and Pager

演示了TabHost和ViewPager配合使用实现点击在tabs之间切换并且也允许用户在水平滑动切换tabs。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
/**
 * This is a helper class that implements the management of tabs and all
 * details of connecting a ViewPager with associated TabHost.  It relies on a
 * trick.  Normally a tab host has a simple API for supplying a View or
 * Intent that each tab will show.  This is not sufficient for switching
 * between pages.  So instead we make the content part of the tab host
 * 0dp high (it is not shown) and the TabsAdapter supplies its own dummy
 * view to show as the tab content.  It listens to changes in tabs, and takes
 * care of switch to the correct paged in the ViewPager whenever the selected
 * tab changes.
 */
public static class TabsAdapter extends FragmentPagerAdapter
        implements TabHost.OnTabChangeListener, ViewPager.OnPageChangeListener {
    private final Context mContext;
    private final TabHost mTabHost;
    private final ViewPager mViewPager;
    private final ArrayList<TabInfo> mTabs = new ArrayList<TabInfo>();

    static final class TabInfo {
        private final String tag;
        private final Class<?> clss;
        private final Bundle args;

        TabInfo(String _tag, Class<?> _class, Bundle _args) {
            tag = _tag;
            clss = _class;
            args = _args;
        }
    }

    static class DummyTabFactory implements TabHost.TabContentFactory {
        private final Context mContext;

        public DummyTabFactory(Context context) {
            mContext = context;
        }

        @Override
        public View createTabContent(String tag) {
            View v = new View(mContext);
            v.setMinimumWidth(0);
            v.setMinimumHeight(0);
            return v;
        }
    }

    public TabsAdapter(FragmentActivity activity, TabHost tabHost, ViewPager pager) {
        super(activity.getSupportFragmentManager());
        mContext = activity;
        mTabHost = tabHost;
        mViewPager = pager;
        mTabHost.setOnTabChangedListener(this);
        mViewPager.setAdapter(this);
        mViewPager.setOnPageChangeListener(this);
    }

    public void addTab(TabHost.TabSpec tabSpec, Class<?> clss, Bundle args) {
        tabSpec.setContent(new DummyTabFactory(mContext));
        String tag = tabSpec.getTag();

        TabInfo info = new TabInfo(tag, clss, args);
        mTabs.add(info);
        mTabHost.addTab(tabSpec);
        notifyDataSetChanged();
    }

    @Override
    public int getCount() {
        return mTabs.size();
    }

    @Override
    public Fragment getItem(int position) {
        TabInfo info = mTabs.get(position);
        return Fragment.instantiate(mContext, info.clss.getName(), info.args);
    }

    @Override
    public void onTabChanged(String tabId) {
        int position = mTabHost.getCurrentTab();
        mViewPager.setCurrentItem(position);
    }

    @Override
    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
    }

    @Override
    public void onPageSelected(int position) {
        // Unfortunately when TabHost changes the current tab, it kindly
        // also takes care of putting focus on it when not in touch mode.
        // The jerk.
        // This hack tries to prevent this from pulling focus out of our
        // ViewPager.
        TabWidget widget = mTabHost.getTabWidget();
        int oldFocusability = widget.getDescendantFocusability();
        widget.setDescendantFocusability(ViewGroup.FOCUS_BLOCK_DESCENDANTS);
        mTabHost.setCurrentTab(position);
        widget.setDescendantFocusability(oldFocusability);
    }

    @Override
    public void onPageScrollStateChanged(int state) {
    }
}

从Android SDK目录可找到源码，或从这里下载

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

Android开发工程师