ViewPager防止Fragment销毁以及取消Fragment的预加载

存在的问题

1. 默认情况下，ViewPager会根据setOffscreenPageLimit()方法设置的大小，自动预加载
2. 还是根据setOffscreenPageLimit()方法设置的大小，会去销毁fragment视图

下面的图说明情况

滑动fragment1，此时会预加载fragment2，滑动到fragment2会预加载fragment3，但是滑动到fragment3，此时会调用fragment1的destroyview方法，销毁视图。当重新滑动到fragment1才会重新调用fragment1的oncreateview方法。注意此时并不会销毁实例，不会调用ondestroy方法

这样就存在两个问题
1.pagerview频繁切换，导致fragment1.fragment3在频繁的调用destroyview和oncreateview方法，重新创建视图。这样也浪费了大量的资源，用户体验不佳，虽然内存消耗比较低
2.因为切换到fragment1的时候，同时预加载了fragment2，如果此时fragment2也有大量的耗时网络请求要做，如果应用对启动反应速度比较敏感，所以此时做了多余的工作。能否把这些耗时的工作延迟加载，也是个问题

解决方案

1.  防止频繁的销毁视图，setOffscreenPageLimit(2)/或者重写PagerAdaper的destroyItem方法为空即可

setOffscreenPageLimit(2)

//Set the number of pages that should be retained to either side of the current page in the view hierarchy in an idle state.Pages beyond this limit will be recreated from the adapter when needed.You should keep this limit low, especially if your pages have complex layouts. This setting defaults to 1.

大概意思就是说：

设置当前page左右两侧应该被保持的page数量，超过这个限制，page会被销毁重建（只是销毁视图），onDestroy-onCreateView,但不会执行onDestroy。尽量维持这个值小，特别是有复杂布局的时候，因为如果这个值很大，就会占用很多内存，如果只有3-4page的话，可以全部保持active，可以保持page切换的顺滑

这下很好理解了，默认情况下是1，所以当前fragment左右两侧，就会被保持1页pager，所以上述切换到fragment2并不会销毁任何视图，但是到fragment1，3会。这里注意这个值，是左右两侧能够维持的page，所以如果setOffscreenPageLimit(2)，那么就不会频繁的销毁了

destroyItem()

//super.destroyItem(Container, position, object);  注释掉调用父类方法即可

2.  取消预加载，可以fragment的setUserVisibleHint实现，具体实现参考代码示例

setUserVisibleHint

//Set a hint to the system about whether this fragment's UI is currently visible to the user. This hint defaults to true and is persistent across fragment instance state save and restore.An app may set this to false to indicate that the fragment's UI is scrolled out of visibility or is otherwise not directly visible to the user. This may be used by the system to prioritize operations such as fragment lifecycle updates or loader ordering behavior.

大概意思就是：fragment对用户可见，isVisibleToUser为true，不可见isVisibleToUser为false。对应于viewpager，当前pager，非当前pager

代码：

public abstract class BaseFragment extends Fragment {  
    /** Fragment当前状态是否可见 */  
    protected boolean isVisible;  
  
    //setUserVisibleHint  adapter中的每个fragment切换的时候都会被调用，如果是切换到当前页，那么isVisibleToUser==true，否则为false  
    @Override  
    public void setUserVisibleHint(boolean isVisibleToUser) {  
        super.setUserVisibleHint(isVisibleToUser);  
        if(isVisibleToUser) {  
            isVisible = true;  
            onVisible();  
        } else {  
            isVisible = false;  
            onInvisible();  
        }  
    }  
      
    /** 
     * 可见 
     */  
    protected void onVisible() {  
        lazyLoad();       
    }  
          
    /** 
     * 不可见 
     */  
    protected void onInvisible() {        
    }  
      
    /** 
     * 延迟加载 
     * 子类必须重写此方法 
     */  
    protected abstract void lazyLoad();  
}

　　

public class CustomListFragment extends BaseFragment {  
  
    private Context context;  
  
    private static final String FRAGMENT_INDEX = "fragment_index";  
    private final int FIRST_FRAGMENT = 0;  
    private final int SECOND_FRAGMENT = 1;  
    private final int THIRD_FRAGMENT = 2;  
  
    private TextView contentText;  
    private ProgressBar progressBar;  
  
    private int mCurIndex = -1;  
    /** 
     * 标志位，标志已经初始化完成 
     */  
    private boolean isPrepared;  
    /** 
     * 是否已被加载过一次，第二次就不再去请求数据了 
     */  
    private boolean mHasLoadedOnce;  
  
    /** 
     * 创建新实例 
     * 
     * @param index 
     * @return 
     */  
    public static CustomListFragment newInstance(int index) {  
        Bundle bundle = new Bundle();  
        bundle.putInt(FRAGMENT_INDEX, index);  
        CustomListFragment fragment = new CustomListFragment();  
        fragment.setArguments(bundle);  
        return fragment;  
    }  
  
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        context = getActivity();  
  
        Bundle bundle = getArguments();  
        if (bundle != null) {  
            mCurIndex = bundle.getInt(FRAGMENT_INDEX);  
        }  
    }  
  
    @Override  
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {  
        View view = inflater.inflate(R.layout.fragment, container, false);  
        contentText = (TextView) view.findViewById(R.id.content);  
        progressBar = (ProgressBar) view.findViewById(R.id.progressbar);  
        isPrepared = true;  
        lazyLoad();  
        return view;  
    }  
  
    @Override  
    protected void lazyLoad() {  
        if (!isPrepared || !isVisible || mHasLoadedOnce) {  
            return;  
        }  
        new AsyncTask<Void, Void, Boolean>() {  
            @Override  
            protected void onPreExecute() {  
                super.onPreExecute();  
                progressBar.setVisibility(View.VISIBLE);  
            }  
            @Override  
            protected Boolean doInBackground(Void... params) {  
                try {  
                    Thread.sleep(2000);  
                    //在这里添加调用接口获取数据的代码  
                    //doSomething()  
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
                return true;  
            }  
            @Override  
            protected void onPostExecute(Boolean isSuccess) {  
                if (isSuccess) {  
                    // 加载成功  
                    setView();  
                    mHasLoadedOnce = true;  
                } else {  
                    // 加载失败  
                }  
                progressBar.setVisibility(View.GONE);  
            }  
        }.execute();  
    }  
  
    private void setView() {  
        // 根据索引加载不同视图  
        switch (mCurIndex) {  
            case FIRST_FRAGMENT:  
                contentText.setText("第一个");  
                break;  
  
            case SECOND_FRAGMENT:  
                contentText.setText("第二个");  
                break;  
  
            case THIRD_FRAGMENT:  
                contentText.setText("第三个");  
                break;  
        }  
    }  
  
    @Override  
    public void onDestroyView() {  
        super.onDestroyView();  
        Log.d("LiaBin", "onDestroyView: curIndex=" + mCurIndex);  
    }  
  
    @Override  
    public void onDestroy() {  
        super.onDestroy();  
        Log.d("LiaBin", "onDestroy: curIndex=" + mCurIndex);  
    }  
}