FrameLayout的使用进阶

前提：创建两个Fragment(个人叫FirstFragment,SecondFragment)，由于本篇幅不是讲解如何使用Fragment，所以就不上详细创建步骤了。

效果图：

一、如何切换Fragment

①、了解FragmentManager

FragmentManager  fm = getSupportFragmentManager()；
作用：管理Fragment的显示，存储。

FragmentManger中有三个容器。

第一个用来存储，Fragment的View，并控制View的显示

第二个用来存储，Fragment本身。

第三个用来存储，Fragment的回退栈。（就是使用android的back键的时候，返回上一个Fragment）

②、了解FragmentTransaction的方法

FragmentTransaction transaction = fm.benginTransatcion();//开启一个事务

transaction.add() 

往FragmentManager中添加一个Fragment，并创建Fragment的View，添加到FrameLayout中显示。

注：用代码创建Fragment本身，并不会执行Fragment的生命周期，也就是

FirstFragment fragment = new FirstFragment();这时候是不会执行Fragment的生命周期。其生命周期是由Activity来控制的。所以后面说到的销毁Fragment，指的并不是销毁fragment实例也就是fragment == null，而是重新执行了Fragment的生命周期。（可以这么理解new FirstFragment()只是创造了身体，灵魂的创造需要依靠Activity）

transaction.remove() 
往FragmentManager中销毁一个Fragment，并销毁Fragment的View。如果被移除的Fragment没有添加到回退栈（回退栈后面会详细说），这个Fragment实例会完全被移出FragmentManger。否则只销毁Fragment的视图。(同detch())

transaction.replace()

使用另一个Fragment替换当前的，实际上就是remove()然后add()的合体。

（注：如果remove()的Fragment不存在，不会影响add操作。相当于执行了add()操作

如果replace()的Fragment与当前显示的Fragment相同，则不执行replace()操作）

transaction.hide()

隐藏当前的Fragment，仅仅是将View设为不可见，并不会销毁。

transaction.show():(Fragment必须存在于FragmentManager内，才能使用)

显示之前隐藏的Fragment。

detach()

移除Fragment的View,和remove()不同,此时fragment的状态依然由FragmentManager维护。

attach()

重建view视图，附加到UI上并显示。

transatcion.commit()//提交一个事务

③、三种实际中切换Fragment的方法

第一种：add()+remove() = replace()：销毁当前显示的Fragment，添加需要显示的Fragment。

缺点：Fragment会被重新创建，导致View重绘。View重绘的同时也表示用户之前在该View上做的操作都消失了。

优点：节省内存空间。

使用场景：不要求保留用户操作。（用户操作，比如说：ListView滑动到第5个item，但是由于View的重绘，又会回到第一个Item）

示例：

public class MainActivity extends AppCompatActivity {    private FirstFragment mFirstFragment;    private SecondFragment mSecondFragment;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        initWidget();    }    private void initWidget(){        //初始化Fragment        mFirstFragment = new FirstFragment();        mSecondFragment = new SecondFragment();        //首先显示FirstFragment        showFragment(mFirstFragment);    }    private void showFragment(Fragment fragment){        //直接replace()就可以了，不需要先add~~~        getSupportFragmentManager().beginTransaction()                .replace(R.id.main_frame,fragment)                .commit();    }    /**     *使用了ActionBar的menu     */    @Override    public boolean onCreateOptionsMenu(Menu menu) {        getMenuInflater().inflate(R.menu.switch_fragment,menu);        return super.onCreateOptionsMenu(menu);    }    @Override    public boolean onOptionsItemSelected(MenuItem item) {        switch (item.getItemId()){            case R.id.menu_first_fragment:                showFragment(mFirstFragment);                break;            case R.id.menu_second_fragment:                showFragment(mSecondFragment);                break;        }        return super.onOptionsItemSelected(item);    }}

第二种：show()+hide()：将Fragment视图隐藏之后在显示。

缺点：由于Fragment只是被隐藏了，并未被销毁，所以需要占用内存空间来保存。

优点：不用重新创建Fragment

使用场景；需要保留用户数据的情形。

示例：（与上面示例不同的部分）

 private void initWidget(){        //初始化Fragment        mFirstFragment = new FirstFragment();        mSecondFragment = new SecondFragment();        setUpFragment();    }    private void setUpFragment(){        //首先将所有的Fragment添加到FragmentManager中，并隐藏，只显示当前需要的Fragment        getSupportFragmentManager().beginTransaction()                .add(R.id.main_frame,mFirstFragment)                .add(R.id.main_frame,mSecondFragment)                .hide(mSecondFragment)                .commit();        //设定当前的Fragment,知道下一次hide那个Fragment        mCurrentFragment = mFirstFragment;    }    private void showFragment(Fragment fragment){        if (mCurrentFragment != fragment){            getSupportFragmentManager().beginTransaction()                    .hide(mCurrentFragment)                    .show(fragment)                    .commit();<pre name="code" class="java">        mCurrentFragment = fragment;//设定当前的Fragment

} }

第三种：attach()+detch()：保留Fragment（就是不会重复执行Fragment的生命周期），但删除Fragment的View（就是第一种的改良版）

使用场景：如果你的当前Activity一直存在，那么在不希望保留用户操作的时候，你可以优先使用detach

  private void initWidget(){        //初始化Fragment        mFirstFragment = new FirstFragment();        mSecondFragment = new SecondFragment();        setUpFragment();    }    private void setUpFragment(){        //首先将所有的Fragment添加到FragmentManager中，并删除View，只显示当前需要的Fragment        getSupportFragmentManager().beginTransaction()                .add(R.id.main_frame,mFirstFragment)                .add(R.id.main_frame,mSecondFragment)                .detach(mSecondFragment)                .commit();        //设定当前的Fragment,知道下一次hide那个Fragment        mCurrentFragment = mFirstFragment;    }    private void showFragment(Fragment fragment){        if (mCurrentFragment != fragment){            getSupportFragmentManager().beginTransaction()                    .detach(mCurrentFragment)                    .attach(fragment)                    .commit();            mCurrentFragment = fragment;//设定当前的Fragment        }    }

形式上跟第二种方法差不多~~~~，但是内容上却是第一种方法的改进

二、如何保证不发生Fragment重影

①、发生重影的原理：当将app缩小到后台，由于资源回收，系统会回收后台的资源（比如说Activity），并会调用onSaveInstanceState()保存当前状态。然后当app返回到前台的时候，系统会重建被被回收的资源。系统会将onSaveInstanceState()保存的Bundle对象传递给当前重建的Activity。就是onCreate(Bundle saveInstance)中的saveInstance参数。也会调用onRestoreInstanceState(Bundle saveInstance)来接收bundle对象。（详细请参考异常生命周期下的资源重建）

举例说明：

有ABC三个Fragment在FragmentManager中，且A正在显示在Activity上。然后将app切换到后台，Activity被回收了。FramgentManager就会调用onSaveInstanceState()方法保存ABC三个Fragment到Bundle中。再重新将app切换到前台，然后Activity进行。FragmentManager就会在onCreatre()前将ABC三个Fragment加入到FragmentManager中，并将A显示到Activity上。（未查过源码，有一种说法是在onAttach()方法中建立的。）然后Activity继续调用OnCreate()方法就如刚才的示例方法，再次调用setUpFragment()再次添加ABC到FragmentManager中，并将A显示。这就发生了重影。（）

②、解决办法（推荐使用第一种）

第一种：（如果FragmentManger已经存在要创建的Fragment，那么直接通过Tag从FragmentManager获取需要的Fragment实例）

  private static final String TAG_FIRST = "FirstFragment";    private static final String TAG_SECOND = "SecondFragment";    private FirstFragment mFirstFragment;    private SecondFragment mSecondFragment;    private Fragment mCurrentFragment;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        initWidget(savedInstanceState);    }    private void initWidget(Bundle savedInstanceState){        if(savedInstanceState ==null){            //初始化Fragment            mFirstFragment = new FirstFragment();            mSecondFragment = new SecondFragment();            setUpFragment();        }        else {            //由于FragmentManager已经存在了这些Fragment直接获取就可以了            mFirstFragment = (FirstFragment) getSupportFragmentManager()                    .findFragmentByTag(TAG_FIRST);            mSecondFragment = (SecondFragment) getSupportFragmentManager()                    .findFragmentByTag(TAG_SECOND);        }    }    private void setUpFragment(){        //第一步：为每个Fragment添加Tag        getSupportFragmentManager().beginTransaction()                .add(R.id.main_frame,mFirstFragment,TAG_FIRST)                .add(R.id.main_frame,mSecondFragment,TAG_SECOND)                .detach(mSecondFragment)                .commit();        //设定当前的Fragment,知道下一次hide那个Fragment        mCurrentFragment = mFirstFragment;    }

第二种：（阻止FragmentManager调用onSaveInstanceState()保存Fragment）

Activity 中的 onSaveInstanceState() 里面有一句super.onSaveInstanceState(outState);，Google 对于这句话的解释是 “Always call the superclass so it can save the view hierarchy state”，大概意思是“总是执行这句代码来调用父类去保存视图层的状态”。通过注释掉这句话，这样主 Activity 因为种种原因被回收的时候就不会保存之前的 fragment state，也可以成功解决重叠的问题。

三、Fragment与Activity的交互

①、Fragment中调用Activity的方法

错误的使用方法：

在MainActivity添加获取Data的方法

    /**     * 获取数据     */    public int getData(){        return 100;    }

在FirstFragment直接调用该方法

//在FirstFragment中    @Override    public void onActivityCreated(@Nullable Bundle savedInstanceState) {        super.onActivityCreated(savedInstanceState);        //直接调用Activity的方法        int data = ((MainActivity)getActivity()).getData();        Log.d("TAG",data+" ");    }

这样使用的缺点：该Fragment被MainActivity捆绑了。也就是说只能被MainActivity使用，不能被其他Activity使用了。如果有TestActivity使用FirstFragment，就会报错，因为((MainActivity)getActivity()).getData();这行代码不成立。

最佳实践：（通过使用监听器，实现Activity与Fragment之间的解耦）

public class FirstFragment extends Fragment {    private OnFirstFragmentListener mListener;        @Override    public void onAttach(Context context) {        super.onAttach(context);        //第二步：将Activity转换成监听器        try {            mListener = (OnFirstFragmentListener) getActivity();            Log.d("Tag",mListener.getData()+"");        }catch (ClassCastException e){            throw new ClassCastException("must implement OnFirstFragmentListener");        }    }    @Nullable    @Override    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {        View view = inflater.inflate(R.layout.fragment_first,container,false);        return view;    }    //第一步：创建监听器    public interface OnFirstFragmentListener{        int getData();    }}

之后Activity实现接口:

public class MainActivity extends AppCompatActivity implements FirstFragment.OnFirstFragmentListener {    public int getData(){        return 100;    }}

②、Activity调用Fragment

1、向Fragment传递初始化Fragment所必要的数据

需求：有时候我们需要根据Activity掌握的数据创建Fragment。（MainActivity传递文章的id给ArticleActivity，ArticleActivity又需要将id传递给ArticleFragment，然后让ArticleFragment通过加载数据）

最佳实践：（）

为Fragment设置创建Fragment的方法，并使用Bundle传递数据，使用getArgument获取数据。

public class FirstFragment extends Fragment{ <pre name="code" class="java">    private static final String ARGS_ID = "id";<pre name="code" class="java">

  @Override  public void onCreate(@Nullable Bundle savedInstanceState) {       super.onCreate(savedInstanceState);      //获取数据       Bundle bundle = getArguments();      int article_id = bundle.getInt(ARGS_ID);      Log.d("TAG",article_id+"");  } public static FirstFragment newInstance(int id) { Bundle args = new Bundle(); args.putInt(ARGS_ID,id); FirstFragment fragment = new FirstFragment(); fragment.setArguments(args); return fragment; }}

2、Activity与Fragment之间的交互

因为Activity掌握了Fragment的实例，所以直接通过调用Fragment的public方法就可以了。

③、Fragment与Fragment之间的交互

在Activity中，通过Fragment setTargetFragment(Fragment fragment,int flag);将需要进行交互的Fragment传递给当前Fragment。（int flag为传递的Fragment设定id）

例：

public class MainActivity extends AppCompatActivity{      @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main)        mFirstFragment = new FirstFragment();        mSecondFragment = new SecondFragment();<span style="white-space:pre"></span>//将SecondFragment的实例传递给FirstFragment        mFirstFragment.setTargetFragment(mSecondFragment,0);   }}

然后在FirstFragment中获取SecondFragment：

public class FirstFragment extends Fragment {   @Override    public void onActivityCreated(@Nullable Bundle savedInstanceState) {        super.onActivityCreated(savedInstanceState);        //首先判断获取的是哪个Fragment        switch (getTargetRequestCode()){            case 0:                SecondFragment secondFragment = (SecondFragment) getTargetFragment();                //...之后进行交互的操作                break;        }    }}

四、Fragment的回退栈

 回退栈的作用： 如果你将Fragment任务添加到回退栈，当用户点击后退按钮时，将看到上一次的保存的Fragment。一旦Fragment完全从后退栈中弹出，用户再次点击后退键，则退出当前Activity。

如何添加回退栈：addBackTo(String name);//name表示该Fragment在栈中的标识，不需要可以设置为null

代码：

    private void showFragment(Fragment fragment){        if (mCurrentFragment != fragment){            getSupportFragmentManager().beginTransaction()                    .detach(mCurrentFragment)                    .attach(fragment)                    .addToBackStack(null)//将当前framgent加入回退栈                    .commit();            mCurrentFragment = fragment;//设定当前的Fragment        }

效果：