Fragment总结（二）

四、Fragment与Activity通信

1.在Fragment中可以通过getActivity得到当前绑定的Activity的实例，然后进行操作

2.Handler、EventBus

public class MainActivity extends FragmentActivity{
      //声明一个Handler
      public Handler mHandler = new Handler(){
          @Override
           public void handleMessage(Message msg) {
                super.handleMessage(msg);
                 ...相应的处理代码
           }
     }
     ...相应的处理代码
}

public class MainFragment extends Fragment{
    //保存Activity传递的handler
    private Handler mHandler;
    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        //这个地方已经产生了耦合，若还有其他的activity，这个地方就得修改
        if(activity instance MainActivity){
            mHandler =  ((MainActivity)activity).mHandler;
        }
    }
           ...相应的处理代码
}

该方案存在的缺点：

Fragment对具体的Activity存在耦合，不利于Fragment复用

不利于维护，若想删除相应的Activity，Fragment也得改动

没法获取Activity的返回数据

EventBus使用类似，EventBus使用反射实现，性能会差一些

3.广播

用广播解决此问题有点大材小用了，广播的意图主要是用在一对多，接收广播者是未知的情况

广播性能肯定会差

传播数据有限制（必须得实现序列化接口才可以）

4.通信优化

因为要考虑Fragment的重复使用，所以必须降低Fragment与Activity的耦合，而且Fragment更不应该直接操作别的Fragment，毕竟Fragment操作应该由它的管理者Activity来决定。

FragmentOne.java文件

public class FragmentOne extends Fragment implements OnClickListener {

    private Button mBtn;

    //设置按钮点击的回调
    public interface FOneBtnClickListener {
        void onFOneBtnClick();
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_one, container, false);
        mBtn = (Button) view.findViewById(R.id.id_fragment_one_btn);
        mBtn.setOnClickListener(this);
        return view;
    }

    //交给宿主Activity处理，如果它希望处理
    @Override
    public void onClick(View v) {
        if (getActivity() instanceof FOneBtnClickListener) {
            ((FOneBtnClickListener) getActivity()).onFOneBtnClick();
        }
    }

}

可以看到，现在的FragmentOne不和任何Activity耦合，任何Activity都可以使用，并且我们声明了一个接口，来回调其点击事件，想要重写其点击事件的Activity实现此接口即可，可以看到我们在onClick中首先判断了当前绑定的Activity是否实现了该接口，如果实现了则调用。

FragmentTwo.java文件

public class FragmentTwo extends Fragment implements OnClickListener {

    private Button mBtn ;
    private FTwoBtnClickListener fTwoBtnClickListener ;

    public interface FTwoBtnClickListener {
        void onFTwoBtnClick();
    }

    //设置回调接口
    public void setfTwoBtnClickListener(FTwoBtnClickListener fTwoBtnClickListener) {
        this.fTwoBtnClickListener = fTwoBtnClickListener;
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_two, container, false);
        mBtn = (Button) view.findViewById(R.id.id_fragment_two_btn);
        mBtn.setOnClickListener(this);
        return view ;
    }

    @Override
    public void onClick(View v) {
        if(fTwoBtnClickListener != null) {
            fTwoBtnClickListener.onFTwoBtnClick();
        }
    }

}

与FragmentOne极其类似，但是我们提供了setListener这样的方法，意味着Activity不仅需要实现该接口，还必须显示调用mFTwo.setfTwoBtnClickListener(this)。

MainActivity.java文件

public class MainActivity extends Activity implements FOneBtnClickListener,
        FTwoBtnClickListener {

    private FragmentOne mFOne;
    private FragmentTwo mFTwo;
    private FragmentThree mFThree; //FragmentThree代码参考上一个例子中的代码

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

        mFOne = new FragmentOne();
        FragmentManager fm = getFragmentManager();
        FragmentTransaction tx = fm.beginTransaction();
        tx.add(R.id.id_content, mFOne, "ONE");
        tx.commit();
    }

    //FragmentOne 按钮点击时的回调
    @Override
    public void onFOneBtnClick() {
        if (mFTwo == null) {
            mFTwo = new FragmentTwo();
            mFTwo.setfTwoBtnClickListener(this);
        }
        FragmentManager fm = getFragmentManager();
        FragmentTransaction tx = fm.beginTransaction();
        tx.replace(R.id.id_content, mFTwo, "TWO");
        tx.addToBackStack(null);
        tx.commit();
    }

    //FragmentTwo按钮点击时的回调
    @Override
    public void onFTwoBtnClick() {
        if (mFThree == null) {
            mFThree = new FragmentThree();
        }
        FragmentManager fm = getFragmentManager();
        FragmentTransaction tx = fm.beginTransaction();
        tx.hide(mFTwo);
        tx.add(R.id.id_content, mFThree, "THREE");
        //tx.replace(R.id.id_content, fThree, "THREE");
        tx.addToBackStack(null);
        tx.commit();
    }

}

这种方案应该是既能达到复用，又能达到很好的可维护性，并且性能也是杠杠的。但是唯一的一个遗憾是假如项目很大了，Activity与Fragment的数量也会增加，这时候为每对Activity与Fragment交互定义交互接口就是一个很头疼的问题（ 包括为接口的命名，新定义的接口相应的Activity还得实现，相应的Fragment还得进行强制转换 ）。

五、卡顿

1.原因

首页的ViewPager有十几个Fragment，在快速切换的时候，容易产生卡顿现象

2.分析

当ViewPager切换到当前的Fragment时，Fragment会加载布局并显示内容，如果用户这时快速切换ViewPager，即Fragment需要加载UI内容，而又频繁地切换Fragment，就容易产生卡顿现象（类似在ListView快速滑动的同时加载图片容易卡顿）。

3.处理方案

1.Fragment轻量化

如果ViewPager加载的Fragment都比较轻量，适当精简Fragment的布局，可提高Fragment加载的速度，从而减缓卡顿现象。

2.防止Fragment被销毁

ViewPager在切换的时候，如果频繁销毁和加载Fragment，就容易产生卡顿现象，阻止Fragment的销毁可有效减缓卡顿现象。

(1) 在PagerAdapter里覆盖destroyItem方法可阻止销毁Fragment

@Override 
public void destroyItem(ViewGroup container, int position, Object object) {
    //super.destroyItem(container, position, object);                                                                                                                
}

(2) 通过PagerAdapter的setOffscreenPageLimit()方法可以设置保留几个Fragment，适当增大参数可防止Fragment频繁地被销毁和创建。

风险：在Fragment比较多的情况下，部分低端机型容易产生OOM问题。

3.Fragment内容延迟加载

(1) 描述

在切换到当前Fragment的时候，并不立刻去加载Fragment的内容，而是先加载一个简单的空布局，然后启动一个延时任务，延时时长为T，当用户在该Fragment停留时间超过T时，继续执行加载任务；而当用户切换到其他Fragment，停留时间低于T，则取消该延时任务。

(2) 具体操作

首先，设置延迟任务

private Runnable LOAD_DATA = new Runnable() {
    @Override 
    public void run() { 
        //在这里讲数据内容加载到Fragment上
    }
};

启动任务

@Override 
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    //初始化视图，这里最好先设置一个进度对话框，提示用户正在加载数据
    initView();
    //启动任务，这里设置500毫秒后开始加载数据 
    handler.postDelayed(LOAD_DATA,500);
    return view；
}

若用户切换到其他Fragment则取消任务

//判断Fragment是否可视的重载方法
@Override
public void setUserVisibleHint(boolean isVisibleToUser{
    super.setUserVisibleHint(isVisibleToUser); 
    if(!isVisibleToUser)
    mHandler.removeCallbacks(LOAD_DATA); 
}

(3) 注意

使用setUserVisibleHint判断用户是否切换到其他Fragment，这样的做法有个缺陷，因为会在ViewPager开始滑动的时候取消延时任务，而在滑动偏移量不足的情况下，ViewPager会继续回滚到当前Fragment，导致当前Fragment的加载任务被取消而又不会重新启动加载任务。

可以给ViewPager增加一个OnPageChangeListener，该监听器的onPageSelected(position)能监听ViewPager当前切换到哪个Fragment，在这里将其他Fragment的延迟加载任务取消掉。

六、运行时配置变化

在Activity的学习中我们都知道，当屏幕旋转时，是对屏幕上的视图进行了重新绘制。因为当屏幕发生旋转，Activity发生重新启动，默认的Activity中的Fragment也会跟着Activity重新创建，用脚趾头都明白，横屏和竖屏显示的不一样肯定是进行了重新绘制视图的操作。所以，不断的旋转就不断绘制，这是一种很耗费内存资源的操作，那么如何来进行优化？

如果重新启动你的Activity需要恢复大量的数据，重新建立网络连接，或者执行其他的密集型操作，这样因为配置发生变化而完全重新启动可能会是一个慢的用户体验。并且，使用系统提供的onSaveIntanceState()的回调中，使用Bundle来完全恢复你Activity的状态是可能是不现实的（Bundle不是设计用来携带大量数据的（例如bitmap），并且Bundle中的数据必须能够被序列化和反序列化），这样会消耗大量的内存和导致配置变化缓慢。在这样的情况下，当你的Activity因为配置发生改变而重启，你可以通过保持一个Fragment来缓解重新启动带来的负担。这个Fragment可以包含你想要保持的有状态的对象的引用。

当Android系统因为配置变化关闭你的Activity的时候，你的Activity中被标识保持的fragments不会被销毁。你可以在你的Activity中添加这样的fragements来保存有状态的对象。

在运行时配置发生变化时，在Fragment中保存有状态的对象
a) 继承Fragment，声明引用指向你的有状态的对象
b) 当Fragment创建时调用setRetainInstance(boolean)
c) 把Fragment实例添加到Activity中
d) 当Activity重新启动后，使用FragmentManager对Fragment进行恢复

//在fragment中进行设置
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //在配置变化的时候将这个fragment保存下来
    setRetainInstance(true);
}