Android中的Fragment类使用进阶

0、回顾
Fragment 代表 Activity 当中的一项操作或一部分用户界面。 一个 Activity 中的多个 Fragment 可以组合在一起，形成一个多部分拼接而成的用户界面组件，并可在多个 Activity 中复用。一个 Fragment 可被视为 Activity 中一个模块化的部分， 它拥有自己的生命周期，并接收自己的输入事件，在 Activity 运行过程中可以随时添加或移除它 （有点类似“子 Activity”，可在不同的 Activity 中重用）。

Fragment 必须嵌入某个 Activity 中，其生命周期直接受到宿主 Activity 生命周期的影响。 例如，当 Activity 被暂停（Paused）时，其内部所有的 Fragment 也都会暂停。 而当 Activity 被销毁时，它的 Fragment 也都会被销毁。 不过，在 Activity 运行期间（生命周期状态处于 恢复（Resumed） 状态时），每一个 Fragment 都可以被独立地操作，比如添加或移除。 在执行这些操作事务时，还可以将它们加入该 Activity 的回退栈（Back Stack）中 — Activity 回退栈的每个入口就是一条操作过的 Fragment 事务记录。 回退堆栈使得用户可以通过按下 回退（Back） 键来回退 Fragment 事务（后退一步）。

当把 Fragment 加入 Activity 布局（Layout） 后，它位于 Activity View 层次架构（Hierarchy）的某个 ViewGroup 里，且拥有自己的 View 布局定义。 通过在 Activity 的 Layout 文件中声明 <fragment> 元素，可以在 Layout 中添加一个 Fragment。 也可以用程序代码在已有的 ViewGroup 中添加一个 Fragment。 不过， Fragment 并不一定非要是 Activity 布局的一部分，它也可以没有自己的界面，而是用作 Activity 的非可视化工作组件。

1、概述
相信大家对Fragment的都不陌生，对于Fragment的使用，一方面Activity需要在布局中为Fragment安排位置，另一方面需要管理好Fragment的生命周期。Activity中有个FragmentManager，其内部维护fragment队列，以及fragment事务的回退栈。
一般情况下，我们在Activity里面会这么添加Fragment:

public class MainActivity extends FragmentActivity
{ 

  private ContentFragment mContentFragment ;  

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

    FragmentManager fm = getSupportFragmentManager();
    mContentFragment = (ContentFragment) fm.findFragmentById(R.id.id_fragment_container); 

    if(mContentFragment == null )
    {
      mContentFragment = new ContentFragment();
      fm.beginTransaction().add(R.id.id_fragment_container,mContentFragment).commit();
    } 

  } 

}

针对上面代码，问两个问题：
（1）为什么需要判null呢？
主要是因为，当Activity因为配置发生改变（屏幕旋转）或者内存不足被系统杀死，造成重新创建时，我们的fragment会被保存下来，但是会创建新的FragmentManager，新的FragmentManager会首先会去获取保存下来的fragment队列，重建fragment队列，从而恢复之前的状态。
（2）add(R.id.id_fragment_container,mContentFragment)中的布局的id有何作用？
一方面呢，是告知FragmentManager，此fragment的位置；另一方面是此fragment的唯一标识；就像我们上面通过fm.findFragmentById(R.id.id_fragment_container)查找~~
好了，简单回顾了一下基本用法，具体的还请参考上面的博客或者其他资料，接下来，介绍一些使用的意见~~

2、Fragment Arguments
下面描述一个简单的场景，比如我们某个按钮触发Activity跳转，需要通过Intent传递参数到目标Activity的Fragment中，那么此Fragment如何获取当前的Intent的值呢？
有哥们会说，这个简单？看我的代码（问题代码）：

public class ContentFragment extends Fragment
{ 

  private String mArgument ;
  public static final String ARGUMENT ="argument";
  @Override
  public void onCreate(Bundle savedInstanceState)
  {
    super.onCreate(savedInstanceState); 

    mArgument = getActivity().getIntent().getStringExtra(ARGUMENT); 

  }

我们直接在Fragment的onCreate中，拿到宿主Activty，宿主Activity中肯定能通过getIntent拿到Intent，然后通过get方法，随意拿参数~~
这么写，功能上是实现了，但是呢？存在一个大问题：我们用Fragment的一个很大的原因，就是为了复用。你这么写，相当于这个Fragment已经完全和当前这个宿主Activity绑定了，复用直接废了~~~所以呢？我们换种方式，推荐使用arguments来创建Fragment。

public class ContentFragment extends Fragment
{ 

  private String mArgument;
  public static final String ARGUMENT = "argument"; 

  @Override
  public void onCreate(Bundle savedInstanceState)
  {
    super.onCreate(savedInstanceState);
    // mArgument = getActivity().getIntent().getStringExtra(ARGUMENT);
    Bundle bundle = getArguments();
    if (bundle != null)
      mArgument = bundle.getString(ARGUMENT); 

  } 

  /**
   * 传入需要的参数，设置给arguments
   * @param argument
   * @return
   */
  public static ContentFragment newInstance(String argument)
  {
    Bundle bundle = new Bundle();
    bundle.putString(ARGUMENT, argument);
    ContentFragment contentFragment = new ContentFragment();
    contentFragment.setArguments(bundle);
    return contentFragment;
  }

给Fragment添加newInstance方法，将需要的参数传入，设置到bundle中，然后setArguments(bundle)，最后在onCreate中进行获取；
这样就完成了Fragment和Activity间的解耦。当然了这里需要注意：
setArguments方法必须在fragment创建以后，添加给Activity前完成。千万不要，首先调用了add，然后设置arguments。

3、Fragment的startActivityForResult
依旧是一个简单的场景：两个Fragment，一个展示文章列表的Fragment（叫做ListTitleFragment），一个显示详细信息的Fragment（叫做：ContentFragment），当然了，这两个Fragment都有其宿主Activity。
现在，我们点击列表Fragment中的列表项，传入相应的参数，去详细信息的Fragment展示详细的信息，在详细信息页面，用户可以进行点评，当用户点击back以后，我们以往点评结果显示在列表的Fragment对于的列表项中；
也就是说，我们点击跳转到对应Activity的Fragment中，并且希望它能够返回参数，那么我们肯定是使用Fragment.startActivityForResult ;
在Fragment中存在startActivityForResult（）以及onActivityResult（）方法，但是呢，没有setResult（）方法，用于设置返回的intent，这样我们就需要通过调用getActivity().setResult(ListTitleFragment.REQUEST_DETAIL, intent);。
详细代码：
ListTitleFragment

public class ListTitleFragment extends ListFragment
{ 

  public static final int REQUEST_DETAIL = 0x110;
  private List<String> mTitles = Arrays.asList("Hello", "World", "Android");
  private int mCurrentPos ;
  private ArrayAdapter<String> mAdapter ;  

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

  @Override
  public void onListItemClick(ListView l, View v, int position, long id)
  {
    mCurrentPos = position ;
    Intent intent = new Intent(getActivity(),ContentActivity.class);
    intent.putExtra(ContentFragment.ARGUMENT, mTitles.get(position));
    startActivityForResult(intent, REQUEST_DETAIL);
  } 

  @Override
  public void onActivityResult(int requestCode, int resultCode, Intent data)
  {
    Log.e("TAG", "onActivityResult");
    super.onActivityResult(requestCode, resultCode, data);
    if(requestCode == REQUEST_DETAIL)
    {
      mTitles.set(mCurrentPos, mTitles.get(mCurrentPos)+" -- "+data.getStringExtra(ContentFragment.RESPONSE));
      mAdapter.notifyDataSetChanged();
    }
  }
}

ContentFragment

public class ContentFragment extends Fragment
{ 

  private String mArgument;
  public static final String ARGUMENT = "argument";
  public static final String RESPONSE = "response"; 

  @Override
  public void onCreate(Bundle savedInstanceState)
  {
    super.onCreate(savedInstanceState);
    Bundle bundle = getArguments();
    if (bundle != null)
    {
      mArgument = bundle.getString(ARGUMENT);
      Intent intent = new Intent();
      intent.putExtra(RESPONSE, "good");
      getActivity().setResult(ListTitleFragment.REQUEST_DETAIL, intent);
    } 

  } 

  public static ContentFragment newInstance(String argument)
  {
    Bundle bundle = new Bundle();
    bundle.putString(ARGUMENT, argument);
    ContentFragment contentFragment = new ContentFragment();
    contentFragment.setArguments(bundle);
    return contentFragment;
  } 

  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
      Bundle savedInstanceState)
  {
    Random random = new Random();
    TextView tv = new TextView(getActivity());
    tv.setText(mArgument);
    tv.setGravity(Gravity.CENTER);
    tv.setBackgroundColor(Color.argb(random.nextInt(100),
        random.nextInt(255), random.nextInt(255), random.nextInt(255)));
    return tv;
  }
}

贴出了两个Fragment的代码，可以看到我们在ListTitleFragment.onListItemClick，使用startActivityForResult（）跳转到目标Activity，在目标Activity的Fragment（ContentFragment）中获取参数，然后调用getActivity().setResult(ListTitleFragment.REQUEST_DETAIL, intent);进行设置返回的数据；最后在ListTitleFragment.onActivityResult（）拿到返回的数据进行回显；
为大家以后在遇到类似问题时，提供了解决方案；也说明了一个问题：fragment能够从Activity中接收返回结果，但是其自设无法产生返回结果，只有Activity拥有返回结果。
接下来我要贴一下，这两个Fragment的宿主Activity:
ListTitleActivity

public class ListTitleActivity extends FragmentActivity
{ 

  private ListTitleFragment mListFragment; 

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

    FragmentManager fm = getSupportFragmentManager();
    mListFragment = (ListTitleFragment) fm.findFragmentById(R.id.id_fragment_container); 

    if(mListFragment == null )
    {
      mListFragment = new ListTitleFragment();
      fm.beginTransaction().add(R.id.id_fragment_container,mListFragment).commit();
    } 

  }
}

ContentActivity:

public class ContentActivity extends FragmentActivity
{ 

  private ContentFragment mContentFragment; 

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

    FragmentManager fm = getSupportFragmentManager();
    mContentFragment = (ContentFragment) fm.findFragmentById(R.id.id_fragment_container); 

    if(mContentFragment == null )
    {
      String title = getIntent().getStringExtra(ContentFragment.ARGUMENT);
      mContentFragment = ContentFragment.newInstance(title);
      fm.beginTransaction().add(R.id.id_fragment_container,mContentFragment).commit();
    } 

  }
}

有没有发现两个Activity中的代码极其的类似，且使用了同一个布局文件：
activity_single_fragment.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:id="@+id/id_fragment_container"
> 

</RelativeLayout>

为什么要贴这Acticity的代码呢？因为我们项目中，如果原则上使用Fragment，会发现大量类似的代码，那么我们就可以抽象一个Activity出来，托管我们的Single Fragment。

4、SingleFragmentActivity
于是抽象出来的Activity的代码为：

package com.example.demo_zhy_23_fragments; 

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentActivity;
import android.support.v4.app.FragmentManager; 

public abstract class SingleFragmentActivity extends FragmentActivity
{
  protected abstract Fragment createFragment(); 

  @Override
  protected void onCreate(Bundle savedInstanceState)
  { 

    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_single_fragment); 

    FragmentManager fm = getSupportFragmentManager();
    Fragment fragment =fm.findFragmentById(R.id.id_fragment_container); 

    if(fragment == null )
    {
      fragment = createFragment() ; 

      fm.beginTransaction().add(R.id.id_fragment_container,fragment).commit();
    }
  } 

}

那么，有了这个SingleFragmentActivity，我们的ContentActivity和ListTitleActivity也能大变身了~

package com.example.demo_zhy_23_fragments; 

import android.support.v4.app.Fragment; 

public class ContentActivity extends SingleFragmentActivity
{
  private ContentFragment mContentFragment; 

  @Override
  protected Fragment createFragment()
  {
    String title = getIntent().getStringExtra(ContentFragment.ARGUMENT); 

    mContentFragment = ContentFragment.newInstance(title);
    return mContentFragment;
  }
}

package com.example.demo_zhy_23_fragments; 

import android.support.v4.app.Fragment; 

public class ListTitleActivity extends SingleFragmentActivity
{
  private ListTitleFragment mListFragment; 

  @Override
  protected Fragment createFragment()
  {
    mListFragment = new ListTitleFragment();
    return mListFragment;
  }
}

是不是简洁很多，相信优先使用Fragment的项目，类似的Activity非常多，使用SingleFragmentActivity来简化你的代码吧~~
好了，此代码是来自文章开始推荐的书中的，再次推荐一下~~。

5、FragmentPagerAdapter与FragmentStatePagerAdapter
相信这两个PagerAdapter的子类，大家都不陌生吧~~自从Fragment问世，使用ViewPager再结合上面任何一个实例的制作APP主页的案例特别多~~~
那么这两个类有何区别呢？
主要区别就在与对于fragment是否销毁，下面细说：
（1）FragmentPagerAdapter：对于不再需要的fragment，选择调用detach方法，仅销毁视图，并不会销毁fragment实例。
（2）FragmentStatePagerAdapter：会销毁不再需要的fragment，当当前事务提交以后，会彻底的将fragmeng从当前Activity的FragmentManager中移除，state标明，销毁时，会将其onSaveInstanceState(Bundle outState)中的bundle信息保存下来，当用户切换回来，可以通过该bundle恢复生成新的fragment，也就是说，你可以在onSaveInstanceState(Bundle outState)方法中保存一些数据，在onCreate中进行恢复创建。
如上所说，使用FragmentStatePagerAdapter当然更省内存，但是销毁新建也是需要时间的。一般情况下，如果你是制作主页面，就3、4个Tab，那么可以选择使用FragmentPagerAdapter，如果你是用于ViewPager展示数量特别多的条目时，那么建议使用FragmentStatePagerAdapter。
篇幅原因，具体的案例就不写了，大家自行测试。

6、Fragment间的数据传递
上面3中，我们展示了，一般的两个Fragment间的数据传递。
那么还有一种比较特殊的情况，就是两个Fragment在同一个Activity中：例如，点击当前Fragment中按钮，弹出一个对话框（DialogFragment），在对话框中的操作需要返回给触发的Fragment中，那么如何数据传递呢？对于对话框的使用推荐：Android 官方推荐 : DialogFragment 创建对话框
我们继续修改我们的代码：现在是ListTitleFragment ， ContentFragment ， 添加一个对话框：EvaluateDialog，用户点击ContentFragment 内容时弹出一个评价列表，用户选择评价。
现在我们的关注点在于：ContentFragment中如何优雅的拿到EvaluateDialog中返回的评价：
记住我们在一个Activity中，那么肯定不是使用startActivityForResult；但是我们返回的数据，依然在onActivityResult中进行接收。
好了看代码：
ContentFragment

public class ContentFragment extends Fragment
{ 

  private String mArgument;
  public static final String ARGUMENT = "argument";
  public static final String RESPONSE = "response";
  public static final String EVALUATE_DIALOG = "evaluate_dialog";
  public static final int REQUEST_EVALUATE = 0X110; 

  //... 

  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
      Bundle savedInstanceState)
  {
    Random random = new Random();
    TextView tv = new TextView(getActivity());
    ViewGroup.LayoutParams params = new ViewGroup.LayoutParams(
        LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
    tv.setLayoutParams(params);
    tv.setText(mArgument);
    tv.setGravity(Gravity.CENTER);
    tv.setBackgroundColor(Color.argb(random.nextInt(100),
        random.nextInt(255), random.nextInt(255), random.nextInt(255)));
    // set click
    tv.setOnClickListener(new OnClickListener()
    { 

      @Override
      public void onClick(View v)
      {
        EvaluateDialog dialog = new EvaluateDialog();
        //注意setTargetFragment
        dialog.setTargetFragment(ContentFragment.this, REQUEST_EVALUATE);
        dialog.show(getFragmentManager(), EVALUATE_DIALOG);
      }
    });
    return tv;
  } 

  //接收返回回来的数据
  @Override
  public void onActivityResult(int requestCode, int resultCode, Intent data)
  {
    super.onActivityResult(requestCode, resultCode, data); 

    if (requestCode == REQUEST_EVALUATE)
    {
      String evaluate = data
          .getStringExtra(EvaluateDialog.RESPONSE_EVALUATE);
      Toast.makeText(getActivity(), evaluate, Toast.LENGTH_SHORT).show();
      Intent intent = new Intent();
      intent.putExtra(RESPONSE, evaluate);
      getActivity().setResult(Activity.REQUEST_OK, intent);
    } 

  }
}

删除了一些无关代码，注意看，我们在onCreateView中为textview添加了click事件，用于弹出我们的dialog，注意一行代码：
dialog.setTargetFragment(ContentFragment.this, REQUEST_EVALUATE);
我们调用了Fragment.setTargetFragment ，这个方法，一般就是用于当前fragment由别的fragment启动，在完成操作后返回数据的，符合我们的需求吧~~~注意，这句很重要。
接下来看EvaluateDialog代码：

package com.example.demo_zhy_23_fragments; 

import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.Intent;
import android.os.Bundle;
import android.support.v4.app.DialogFragment; 

public class EvaluateDialog extends DialogFragment
{
  private String[] mEvaluteVals = new String[] { "GOOD", "BAD", "NORMAL" };
  public static final String RESPONSE_EVALUATE = "response_evaluate"; 

  @Override
  public Dialog onCreateDialog(Bundle savedInstanceState)
  {
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); 

    builder.setTitle("Evaluate :").setItems(mEvaluteVals,
        new OnClickListener()
        {
          @Override
          public void onClick(DialogInterface dialog, int which)
          {
            setResult(which);
          }
        });
    return builder.create();
  } 

  // 设置返回数据
  protected void setResult(int which)
  {
    // 判断是否设置了targetFragment
    if (getTargetFragment() == null)
      return; 

    Intent intent = new Intent();
    intent.putExtra(RESPONSE_EVALUATE, mEvaluteVals[which]);
    getTargetFragment().onActivityResult(ContentFragment.REQUEST_EVALUATE,
        Activity.RESULT_OK, intent); 

  }
}

重点就是看点击后的setResult了，我们首先判断是否设置了targetFragment，如果设置了，意味我们要返回一些数据到targetFragment。
我们创建intent封装好需要传递数据，最后手动调用onActivityResult进行返回数据~~
最后我们在ContentFragment的onActivityResult接收即可。

ok，终于把这些tips贯穿到一起了，到此我们的Fragment的一些建议的用法就结束了~~~那么，最后提供下源码，也顺便贴个效果图：