1 Fragment 介绍
Fragment作为Android最基本，最重要的基础概念之一，在开发中经常会和他打交道。Fragment，简称碎片，是Android 3.0（API 11）提出的（Android 3.0系统只针对平板电脑，且闭源，那时候针对手机和针对平板是两套源代码，后来Android 4.0时整合了手机和平板的源码，因此市面上很难看到Android 3.0系统。），为了兼容低版本，support-v4库中也开发了一套Fragment API，最低兼容Android 1.6。
过去support-v4库是一个jar包，24.2.0版本开始，将support-v4库模块化为多个jar包，包含：support-fragment, support-ui, support-media-compat等，这么做是为了减少APK包大小，你需要用哪个模块就引入哪个模块。如果想引入整个support-v4库，则compile ‘com.android.support:support-v4:24.2.1’，如果只想引入support-fragment库，则com.android.support:support-fragment:24.2.1。
注意：因为support库是不断更新的，因此建议使用support库中的android.support.v4.app.Fragment，而不要用系统自带的android.app.Fragment。而如果要使用support库的Fragment，Activity必须要继承FragmentActivity（AppCompatActivity是FragmentActivity的子类）。
Fragment 官方定义如下：
A Fragment represents a behavior or a portion of user interface in an Activity. You can combine multiple fragments in a single activity to build a multi-pane UI and reuse a fragment in multiple activities. You can think of a fragment as a modular section of an activity, which has its own lifecycle, receives its own input events, and which you can add or remove while the activity is running.
根据上面的定义我们知道：
- Fragment是依赖于Activity的，不能独立存在的。
- 一个Activity里可以有多个Fragment。
- 一个Fragment可以被多个Activity重用。
- Fragment有自己的生命周期，并能接收输入事件。
- 我们能在Activity运行时动态地添加或删除Fragment。
优点
模块化（Modularity）：我们不必把所有代码全部写在Activity中，而是把代码写在各自的Fragment中。
可重用（Reusability）：多个Activity可以重用一个Fragment。
可适配（Adaptability）：根据硬件的屏幕尺寸、屏幕方向，能够方便地实现不同的布局，这样用户体验更好。
核心类
Fragment：Fragment的基类，任何创建的Fragment都需要继承该类。
FragmentManager：管理和维护Fragment。他是抽象类，具体的实现类是FragmentManagerImpl。
FragmentTransaction：对Fragment的添加、删除等操作都需要通过事务方式进行。他是抽象类，具体的实现类是BackStackRecord。
Nested Fragment（Fragment内部嵌套Fragment的能力）是Android 4.2提出的，support-fragment库可以兼容到1.6。通过getChildFragmentManager()能够获得管理子Fragment的FragmentManager，在子Fragment中可以通过getParentFragment()获得父Fragment。
2 Fragment 使用方式
这里给出Fragment最基本的使用方式。首先，创建继承Fragment的类，名为Fragment1：
public class Fragment1 extends Fragment {
private static String ARG_PARAM = "param_key";
private String mParam;
private Activity mActivity;
public void onAttach(Context context) {
super.onAttach(context);
mActivity = (Activity) context;
mParam = getArguments().getString(ARG_PARAM); //获取参数
}
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
View root = inflater.inflate(R.layout.fragment_blank, container, false);
TextView view = root.findViewById(R.id.text);
view.setText(mParam);
return root;
}
public static Fragment1 newInstance(String str) {
Fragment1 fragment = new Fragment1();
Bundle bundle = new Bundle();
bundle.putString(ARG_PARAM, str);
fragment.setArguments(bundle); //设置参数
return fragment;
}
}Fragment有很多可以复写的方法，其中最常用的就是onCreateView()，该方法返回Fragment的UI布局，需要注意的是inflate()的第三个参数是false，因为在Fragment内部实现中，会把该布局添加到container中，如果设为true，那么就会重复做两次添加，则会抛如下异常：
Caused by: java.lang.IllegalStateException: The specified child already has a parent. You must call removeView() on the child’s parent first.
如果在创建Fragment时要传入参数，必须要通过setArguments(Bundle bundle)方式添加，而不建议通过为Fragment添加带参数的构造函数，因为通过setArguments()方式添加，在由于内存紧张导致Fragment被系统杀掉并恢复（re-instantiate）时能保留这些数据。官方建议如下：
It is strongly recommended that subclasses do not have other constructors with parameters, since these constructors will not be called when the fragment is re-instantiated.
我们可以在Fragment的onAttach()中通过getArguments()获得传进来的参数，并在之后使用这些参数。如果要获取Activity对象，不建议调用getActivity()，而是在onAttach()中将Context对象强转为Activity对象。
创建完Fragment后，接下来就是把Fragment添加到Activity中。在Activity中添加Fragment的方式有两种：静态添加、动态添加。
- 静态添加：在xml中通过的方式添加，缺点是一旦添加就不能在运行时删除。
1）MainActivity
public class MainActivity extends FragmentActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}2)创建 Fragment
public class MyFragment extends Fragment {
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,Bundle savedInstanceState) {
/** * Inflate the layout for this fragment */
return inflater.inflate(R.layout.left_fragment, container, false);
}
} 3)创建 Fragment 的XML布局
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layoutwidth="fillparent" android:layoutheight="fillparent" android:background="#77777777" android:gravity="center" android:orientation="vertical" >
<TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_gravity="center" android:text="Left" android:textColor="#000000" android:textSize="30sp" />
</LinearLayout>4)创建 Activity的布局
<fragment
android:id="@+id/my_fragment"
class="mgzxc.fragmentdemo.MyFragment"
android:layout_width="0dp"
android:layout_height="match_parent"/>注意事项：在Activity 的布局文件 中，必须指定 fragment的class或android:name为对应的Fragment的全包名类名。
缺点：fragment的类型必须指定，因此通用性，灵活性不强。
- 动态添加：运行时添加，这种方式比较灵活，因此建议使用这种方式。
首先Activity需要有一个容器存放Fragment，一般是FrameLayout，因此在Activity的布局文件中加入FrameLayout：
<FrameLayout android:id="@+id/container" android:layout_width="match_parent" android:layout_height="match_parent"/>然后在Activity加入下列代码：
if (bundle == null) {
getSupportFragmentManager().beginTransaction()
.add(R.id.container, Fragment1.newInstance("hello world"), "f1") //.addToBackStack("fname")
.commit();
}这里需要注意几点：
- 因为我们使用了support库的Fragment，因此需要使用getSupportFragmentManager()获取FragmentManager。
- add()是对Fragment众多操作中的一种，还有remove(), replace()等，第一个参数是根容器的id（FrameLayout的id，即”@id/container”），第二个参数是Fragment对象，第三个参数是fragment的tag名，指定tag的好处是后续我们可以通过Fragment1 frag = getSupportFragmentManager().findFragmentByTag(“f1”)从FragmentManager中查找Fragment对象。
- 在一次事务中，可以做多个操作，比如同时做add().remove().replace()。
- commit()操作是异步的，内部通过mManager.enqueueAction()加入处理队列。对应的同步方法为commitNow()，commit()内部会有checkStateLoss()操作，如果开发人员使用不当（比如commit()操作在onSaveInstanceState()之后），可能会抛出异常，而commitAllowingStateLoss()方法则是不会抛出异常版本的commit()方法，但是尽量使用commit()，而不要使用commitAllowingStateLoss()。
- addToBackStack(“fname”)是可选的。FragmentManager拥有回退栈（BackStack），类似于Activity的任务栈，如果添加了该语句，就把该事务加入回退栈，当用户点击返回按钮，会回退该事务（回退指的是如果事务是add(frag1)，那么回退操作就是remove(frag1)）；如果没添加该语句，用户点击返回按钮会直接销毁Activity。
- Fragment有一个常见的问题，即Fragment重叠问题，这是由于Fragment被系统杀掉，并重新初始化时再次将fragment加入activity，因此通过在外围加if语句能判断此时是否是被系统杀掉并重新初始化的情况。
Fragment有个常见的异常：
java.lang.IllegalStateException: Can not perform this action after
onSaveInstanceState
at android.support.v4.app.FragmentManagerImpl.checkStateLoss(FragmentManager.java:1341)
at android.support.v4.app.FragmentManagerImpl.enqueueAction(FragmentManager.java:1352)
at android.support.v4.app.BackStackRecord.commitInternal(BackStackRecord.java:595)
at android.support.v4.app.BackStackRecord.commit(BackStackRecord.java:574)
该异常出现的原因是：commit()在onSaveInstanceState()后调用。首先，onSaveInstanceState()在onPause()之后，onStop()之前调用。onRestoreInstanceState()在onStart()之后，onResume()之前。
因此避免出现该异常的方案有：
- 不要把Fragment事务放在异步线程的回调中，比如不要把Fragment事务放在AsyncTask的onPostExecute()，因此onPostExecute()可能会在onSaveInstanceState()之后执行。
- 逼不得已时使用commitAllowingStateLoss()。
2.1 add 和 replace 区别
添加和替换，是最常用的两个方法，从字面的意思上看能够非常明确的理解，添加就是往容器中添加（add），替换（replace）则是把容器清空再添加，也就是把容器中的所有内容都替换掉。
1）首先获取FragmentTransaction对象：
FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();2）添加
transaction.add(R.id.fragment_container, oneFragment).commit();第一个参数是容器id， 第二个参数是要添加的fragment，添加不会清空容器中的内容，不停的往里面添加，值得强调的是，如果一个fragment已经进来的话，再次添加（指的是同一个对象）的话会报异常错误的，不重复添加同一fragment，这是非常重要的特点。
添加进来的fragment都是可见的（visible），后添加的fragment会展示在先添加的fragment上面，在绘制界面的时候会绘制所有可见的view，所以大多数add都是和hide或者是remove同时使用的，例如：
transaction.add(R.id.fragment_container, oneFragment).hide(twoFragment).commit();这样可以节省绘制界面的时间，节省内存消耗，是推荐的用法。
3)替换
transaction.replace(R.id.fragment_container, oneFragment).commit();替换会把容器中的所以内容全都替换掉，有一些app会使用这样的做法，保持只有一个fragment在显示，减少了界面的层级关系。
- 不同之处
就是是否要清空容器再添加fragment的区别，用法上add配合hide或是remove使用，replace一般单独出现。
- 相同之处
每次add和replace都要重新走一遍fragment 的周期。
3 Fragment 生命周期
Fragment的生命周期和Activity类似，但比Activity的生命周期复杂一些，基本的生命周期方法如下图：
- onAttach()：Fragment和Activity相关联时调用。可以通过该方法获取Activity引用，还可以通过getArguments()获取参数。
- onCreate()：Fragment被创建时调用。
- onCreateView()：创建Fragment的布局。
- onActivityCreated()：当Activity完成onCreate()时调用。
- onStart()：当Fragment可见时调用。
- onResume()：当Fragment可见且可交互时调用。
- onPause()：当Fragment不可交互但可见时调用。
- onStop()：当Fragment不可见时调用。
- onDestroyView()：当Fragment的UI从视图结构中移除时调用。
- onDestroy()：销毁Fragment时调用。
- onDetach()：当Fragment和Activity解除关联时调用。
上面的方法中，只有onCreateView()在重写时不用写super方法，其他都需要。
因为Fragment是依赖Activity的，因此为了讲解Fragment的生命周期，需要和Activity的生命周期方法一起讲，即Fragment的各个生命周期方法和Activity的各个生命周期方法的关系和顺序，如图：
我们这里举个例子来理解Fragment生命周期方法。功能如下：共有两个Fragment：F1和F2，F1在初始化时就加入Activity，点击F1中的按钮调用replace替换为F2。
当F1在Activity的onCreate()中被添加时，日志如下：
可以看出：
Fragment的onAttach()->onCreate()->onCreateView()->onActivityCreated()->onStart()都是在Activity的onStart()中调用的。
Fragment的onResume()在Activity的onResume()之后调用。
3.1 加不加 addToBackStack() 区别
接下去分两种情况，分别是不加addToBackStack()和加addToBackStack()，即是否把fragment加入回退栈的区别。
1、当点击F1的按钮，调用replace()替换为F2，且不加addToBackStack()时，日志如下：
可以看到，F1最后调用了onDestroy()和onDetach()。当点击返回按钮时 日志如下：
2、当点击F1的按钮，调用replace()替换为F2，且加addToBackStack()时，日志如下：
可以看到，F1被替换时，最后只调到了onDestroyView()，并没有调用onDestroy()和onDetach()。当用户点返回按钮回退事务时，F1会调onCreateView()->onStart()->onResume()，日志如下：
因此在Fragment事务中加不加addToBackStack()会影响Fragment的生命周期。
FragmentTransaction有一些基本方法，下面给出调用这些方法时，Fragment生命周期的变化：
- add(): onAttach()->…->onResume()。
- remove(): onPause()->…->onDetach()。
- replace(): 相当于旧Fragment调用remove()，新Fragment调用add()。
- show(): 不调用任何生命周期方法，调用该方法的前提是要显示的Fragment已经被添加到容器，只是纯粹把Fragment UI的setVisibility为true。
- hide(): 不调用任何生命周期方法，调用该方法的前提是要显示的Fragment已经被添加到容器，只是纯粹把Fragment UI的setVisibility为false。
- detach(): onPause()->onStop()->onDestroyView()。UI从布局中移除，但是仍然被FragmentManager管理。
- attach(): onCreateView()->onStart()->onResume()。
3.2 回退栈的内部实现
我们知道Activity有任务栈，用户通过startActivity将Activity加入栈，点击返回按钮将Activity出栈。Fragment也有类似的栈，称为回退栈（Back Stack），回退栈是由FragmentManager管理的。默认情况下，Fragment事务是不会加入回退栈的，如果想将Fragment事务加入回退栈，则可以加入addToBackStack(“”)。如果没有加入回退栈，则用户点击返回按钮会直接将Activity出栈；如果加入了回退栈，则用户点击返回按钮会回滚Fragment事务。
我们将通过最常见的Fragment用法，讲解Back Stack的实现原理：
getSupportFragmentManager().beginTransaction()
.add(R.id.container, f1, "f1")
.addToBackStack("")
.commit();上面这个代码的功能就是将Fragment加入Activity中，内部实现为：创建一个BackStackRecord对象，该对象记录了这个事务的全部操作轨迹（这里只做了一次add操作，并且加入回退栈），随后将该对象提交到FragmentManager的执行队列中，等待执行。
BackStackRecord类的定义如下
class BackStackRecord extends FragmentTransaction implements FragmentManager.BackStackEntry, Runnable {}从定义可以看出，BackStackRecord有三重含义：
- 继承了FragmentTransaction，即是事务，保存了整个事务的全部操作轨迹。
- 实现了BackStackEntry，作为回退栈的元素，正是因为该类拥有事务全部的操作轨迹，因此在popBackStack()时能回退整个事务。
- 继承了Runnable，即被放入FragmentManager执行队列，等待被执行。
先看第一层含义，getSupportFragmentManager.beginTransaction()返回的就是BackStackRecord对象，代码如下：
public FragmentTransaction beginTransaction() {
return new BackStackRecord(this);
}BackStackRecord类包含了一次事务的整个操作轨迹，是以链表形式存在的，链表的元素是Op类，表示其中某个操作，定义如下：
static final class Op {
Op next; //链表后一个节点
Op prev; //链表前一个节点
int cmd; //操作是add或remove或replace或hide或show等
Fragment fragment; //对哪个Fragment对象做操作
}我们来看下具体场景下这些类是怎么被使用的，比如我们的事务做add操作。add函数的定义：
public FragmentTransaction add(int containerViewId, Fragment fragment, String tag) {
doAddOp(containerViewId, fragment, tag, OP_ADD);
return this;
}doAddOp()方法就是创建Op对象，并加入链表，定义如下：
private void doAddOp(int containerViewId, Fragment fragment, String tag, int opcmd) {
fragment.mTag = tag; //设置fragment的tag
fragment.mContainerId = fragment.mFragmentId = containerViewId; //设置fragment的容器id
Op op = new Op();
op.cmd = opcmd;
op.fragment = fragment;
addOp(op);
}addOp()是将创建好的Op对象加入链表，定义如下：
void addOp(Op op) {
if (mHead == null) {
mHead = mTail = op;
} else {
op.prev = mTail;
mTail.next = op;
mTail = op;
}
mNumOp++;
}addToBackStack(“”)是将mAddToBackStack变量记为true，在commit()中会用到该变量。commit()是异步的，即不是立即生效的，但是后面会看到整个过程还是在主线程完成，只是把事务的执行扔给主线程的Handler，commit()内部是commitInternal()，实现如下：
int commitInternal(boolean allowStateLoss) {
mCommitted = true;
if (mAddToBackStack) {
mIndex = mManager.allocBackStackIndex(this);
} else {
mIndex = -1;
}
mManager.enqueueAction(this, allowStateLoss); //将事务添加进待执行队列中
return mIndex;
}如果mAddToBackStack为true，则调用allocBackStackIndex(this)将事务添加进回退栈，FragmentManager类的变量ArrayListmBackStackIndices;就是回退栈。实现如下：
public int allocBackStackIndex(BackStackRecord bse) {
if (mBackStackIndices == null) {
mBackStackIndices = new ArrayList<BackStackRecord>();
}
int index = mBackStackIndices.size();
mBackStackIndices.add(bse);
return index;
}在commitInternal()中，mManager.enqueueAction(this, allowStateLoss);是将BackStackRecord加入待执行队列中，定义如下：
public void enqueueAction(Runnable action, boolean allowStateLoss) {
if (mPendingActions == null) {
mPendingActions = new ArrayList<Runnable>();
}
mPendingActions.add(action);
if (mPendingActions.size() == 1) {
mHost.getHandler().removeCallbacks(mExecCommit);
mHost.getHandler().post(mExecCommit); //调用execPendingActions()执行待执行队列的事务
}
}mPendingActions就是前面说的待执行队列，mHost.getHandler()就是主线程的Handler，因此Runnable是在主线程执行的，mExecCommit的内部就是调用了execPendingActions()，即把mPendingActions中所有积压的没被执行的事务全部执行。执行队列中的事务会怎样被执行呢？就是调用BackStackRecord的run()方法，run()方法就是执行Fragment的生命周期函数，还有将视图添加进container中。
与addToBackStack()对应的是popBackStack()，有以下几种变种：
- popBackStack()：将回退栈的栈顶弹出，并回退该事务。
- popBackStack(String name, int flag)：name为addToBackStack(String name)的参数，通过name能找到回退栈的特定元素，flag可以为0或者FragmentManager.POP_BACK_STACK_INCLUSIVE，0表示只弹出该元素以上的所有元素，POP_BACK_STACK_INCLUSIVE表示弹出包含该元素及以上的所有元素。这里说的弹出所有元素包含回退这些事务。
- popBackStack()是异步执行的，是丢到主线程的MessageQueue执行，而popBackStackImmediate()是同步版本。
我们通过讲解案例来更清晰地了解回退栈的使用。功能如下：共有三个Fragment：F1, F2, F3，F1在初始化时就加入Activity，点击F1中的按钮跳转到F2，点击F2的按钮跳转到F3，点击F3的按钮回退到F1。
在Activity的onCreate()中，将F1加入Activity中：
getSupportFragmentManager().beginTransaction()
.add(R.id.container, f1, "f1")
.addToBackStack(Fragment1.class.getSimpleName())
.commit();F1按钮的onClick()内容如下：
getFragmentManager().beginTransaction()
.replace(R.id.container, f2, "f2")
.addToBackStack(Fragment2.class.getSimpleName())
.commit();F2按钮的onClick()如下：
getFragmentManager().beginTransaction()
.replace(R.id.container, f3, "f3")
.addToBackStack(Fragment3.class.getSimpleName())
.commit();F3按钮的onClick()如下：
getFragmentManager().popBackStack(Fragment2.class.getSimpleName(), getFragmentManager().POP_BACK_STACK_INCLUSIVE);这里补充一个点
getSupportFragmentManager().findFragmentByTag()是经常用到的方法，他是FragmentManager的方法，FragmentManager是抽象类，FragmentManagerImpl是继承FragmentManager的实现类，他的内部实现是：
class FragmentManagerImpl extends FragmentManager {
ArrayList<Fragment> mActive;
ArrayList<Fragment> mAdded;
public Fragment findFragmentByTag(String tag) {
if (mAdded != null && tag != null) {
for (int i=mAdded.size()-1; i>=0; i--) {
Fragment f = mAdded.get(i);
if (f != null && tag.equals(f.mTag)) {
return f;
}
}
}
if (mActive != null && tag != null) {
for (int i=mActive.size()-1; i>=0; i--) {
Fragment f = mActive.get(i);
if (f != null && tag.equals(f.mTag)) {
return f;
}
}
}
return null;
}
}从上面看到，先从mAdded中查找是否有该Fragment，如果没找到，再从mActive中查找是否有该Fragment。mAdded是已经添加到Activity的Fragment的集合，mActive不仅包含mAdded，还包含虽然不在Activity中，但还在回退栈中的Fragment。
4 Fragment通信
4.1 Fragment 和 Activity交互
- activity向fragment传递数据
a、如果你Activity中包含自己管理的Fragment的引用，可以通过引用直接访问所有的Fragment的public方法。
b、如果Activity中未保存任何Fragment的引用，那么没关系，每个Fragment都有一个唯一的TAG或者ID,可以通过getFragmentManager.findFragmentByTag()或者findFragmentById()获得任何Fragment实例，然后进行操作。
c、在activity实例化的过程中构造方法传入数据。
d、通过Bundle从activity传到fragment
activity中代码：
FragmentManager fragmentManager = getSupportFragmentManager();
FragmentTransaction transaction = fragmentManager.beginTransaction();
MyFragment fragment = new MyFragment();
Bundle bundle = new Bundle();
bundle.putString("content", "这是Activity给你的数据");
fragment.setArguments(bundle);
transaction.add(R.id.fl_container, fragment);
transaction.commit();fragment中代码：
Bundle arguments = getArguments();
String content = arguments.getString("content");- fragment向activity传递数据
a、在Fragment中可以通过getActivity得到当前绑定的Activity的实例，然后进行操作。
b、通过接口回调
1、声名一个接口：
public interface OnFragmentSendDataListener {
public void onSendData(String data);
}2、activity实现这个接口及方法
3、在fragment中调用接口里的方法
OnFragmentSendDataListener listener = (OnFragmentSendDataListener) getActivity();
listener.onSendData("这是Fragment给你的数据");注：如果在Fragment中需要Context，可以通过调用getActivity(),如果该Context需要在Activity被销毁后还存在，则使用getActivity().getApplicationContext()。
4.2 Fragment 和 Fragment 交互
由于Fragment之间是没有任何依赖关系的，因此如果要进行Fragment之间的通信，建议通过Activity作为中介，不要Fragment之间直接通信，那么问题就转换为fragment像activity传递数据和activity向fragment传递数据，具体解决方式参考上面说的。而我下面要说的是另一种快捷方式进行fragment之间进行通信。
通过第三方工具实现Fragment之间通信，比如 EventBus
EventBus是一个Android端优化的publish/subscribe消息总线，简化了应用程序内各组件间、组件与后台线程间的通信。比如请求网络，等网络返回时通过Handler或Broadcast通知UI，两个Fragment之间需要通过Listener通信，这些需求都可以通过EventBus实现。
作为一个消息总线，有三个主要的元素：
- Event：事件
- Subscriber：事件订阅者，接收特定的事件
- Publisher:事件发布者，用于通知Subscriber有事件发生
本处重点是介绍EventBus进行fragment之间通信，不对EventBus详细介绍，下面是案例（activity中左边一个fragment 右边一个fragment，实现点击左边的条目将数据 传到右侧显示）效果如下图所示：
1、添加依赖 implementation ‘com.squareup:otto:1.3.5’
2、构造BusFactory
public class BusFactory {
private static Bus bus = new Bus();
public static Bus newInstance(){
return bus;
}
}3、mainactivity:
public class MainActivity extends AppCompatActivity {
private LeftFragment leftFragment;
private RightFragment rightFragment;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");
list.add("F");
list.add("G");
list.add("H");
list.add("I");
list.add("J");
list.add("k");
list.add("L");
list.add("M");
list.add("N");
FragmentManager fragmentManager = getSupportFragmentManager();
FragmentTransaction transaction = fragmentManager.beginTransaction();
leftFragment = new LeftFragment();
leftFragment.setListAdapter(new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, list));
rightFragment = new RightFragment();
transaction.add(R.id.left_container, leftFragment);
transaction.add(R.id.right_container, rightFragment);
transaction.commit();
}
}4、LeftFragment:
public class LeftFragment extends ListFragment {
public LeftFragment() {
// Required empty public constructor
}
@Override
public void onListItemClick(ListView l, View v, int position, long id) {
Object item = l.getAdapter().getItem(position);
//消息发送者
BusFactory.newInstance().post(item);
}
}5、RightFragment:
public class RightFragment extends Fragment {
private TextView tvRight;
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
BusFactory.newInstance().register(this); //订阅事件
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View view=inflater.inflate(R.layout.fragment_right, container, false);
tvRight = (TextView) view.findViewById(R.id.tv_right);
return view;
}
// 注解订阅事件有消息来了就自动调用此方法
@Subscribe
public void onLeftItemClick(Object item){
tvRight.setText(item.toString());
}
}4.3 startFragmentForResult
在activity中有个方法startActivityForResult，这个方法是在activity跳转回去时，携带数据的，而fragment 中是没有这个“startFragmentForResult”方法的，接下来，我们就实现这个方法，代码如下所示：
1、mainactivity:
public class MainActivity extends AppCompatActivity {
private FragmentB leftFragment;
private FragmentA rightFragment;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
FragmentManager fragmentManager = getSupportFragmentManager();
FragmentTransaction transaction = fragmentManager.beginTransaction();
transaction.add(R.id.fl_container, new FragmentA());
transaction.commit();
}
}2、FragmentA:
public class FragmentA extends Fragment {
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_a, null);
Button bt_a = (Button) view.findViewById(R.id.bt_a);
bt_a.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
FragmentManager fragmentManager = getFragmentManager();
FragmentTransaction transaction = fragmentManager.beginTransaction();
FragmentB fragmentB = new FragmentB();
fragmentB.setOnFragmentResult(new OnFragmentResult() {
@Override
public void onFragmentResult(Object data) {
Toast.makeText(getContext(), "fragment b 关闭了" +data.toString(), Toast.LENGTH_SHORT).show();
}
});
transaction.add(R.id.fl_container, fragmentB);
transaction.addToBackStack(null);
transaction.commit();
}
});
return view;
}
}3、FragmentB:
public class FragmentB extends Fragment {
private OnFragmentResult onFragmentResult;
public OnFragmentResult getOnFragmentResult() {
return onFragmentResult;
}
public void setOnFragmentResult(OnFragmentResult onFragmentResult) {
this.onFragmentResult = onFragmentResult;
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_b, null);
Button bt_b = (Button) view.findViewById(R.id.bt_b);
bt_b.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
FragmentManager fragmentManager = getFragmentManager();
fragmentManager.popBackStackImmediate();
if(onFragmentResult!= null){
onFragmentResult.onFragmentResult("这是fragment b关了给你的数据");
}
}
});
return view;
}
}4、定义接口
public interface OnFragmentResult {
public void onFragmentResult(Object data);
}
5 Fragment 应用场景
5.1 DialogFragment的使用
效果：
DialogFragment是Android 3.0提出的，代替了Dialog，用于实现对话框。他的优点是：即使旋转屏幕，也能保留对话框状态。
如果要自定义对话框样式，只需要继承DialogFragment，并重写onCreateView()，该方法返回对话框UI。这里我们举个例子，实现进度条样式的圆角对话框。
添加依赖：compile ‘com.airbnb.android:lottie:2.2.0’
public class ProgressDialogFragment extends DialogFragment { @Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
getDialog().requestWindowFeature(Window.FEATURE_NO_TITLE); //消除Title区域
getDialog().getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT)); //将背景变为透明
setCancelable(false); //点击外部不可取消
View root = inflater.inflate(R.layout.fragment_progress_dialog, container);
return root;
}
public static ProgressDialogFragment newInstance() {
return new ProgressDialogFragment();
}
}进度条动画我们使用Lottie(https://github.com/airbnb/lottie-android)实现，Lottie动画从这里(https://www.lottiefiles.com/)找到。使用非常方便，只需要下载JSON动画文件（放入\src\main\assets中），然后在XML中写入：
<com.airbnb.lottie.LottieAnimationView
android:layout_width="wrap_content" //大小根据JSON文件确定
android:layout_height="wrap_content"
app:lottie_fileName="loader_ring.json" //JSON文件
app:lottie_loop="true" //循环播放
app:lottie_autoPlay="true" /> //自动播放然后通过下面代码显示对话框：
ProgressDialogFragment fragment = ProgressDialogFragment.newInstance();
fragment.show(getSupportFragmentManager(), "tag");//fragment.dismiss();为了实现圆角，除了在onCreateView()中把背景设为透明，还需要对UI加入背景：
<shape xmlns:android="http://schemas.android.com/apk/res/android">
<solid android:color="#ffffff"/>
<corners android:radius="20dp"/>
</shape>5.2 ViewPager+Fragment的使用
ViewPager是support v4库中提供界面滑动的类，继承自ViewGroup。PagerAdapter是ViewPager的适配器类，为ViewPager提供界面。但是一般来说，通常都会使用PagerAdapter的两个子类：FragmentPagerAdapter和FragmentStatePagerAdapter作为ViewPager的适配器，他们的特点是界面是Fragment。
在support v13和support v4中都提供了FragmentPagerAdapter和FragmentStatePagerAdapter，区别在于：support v13中使用android.app.Fragment，而support v4使用android.support.v4.app.Fragment。一般都使用support v4中的FragmentPagerAdapter和FragmentStatePagerAdapter。
默认，ViewPager会缓存当前页相邻的界面，比如当滑动到第2页时，会初始化第1页和第3页的界面（即Fragment对象，且生命周期函数运行到onResume()），可以通过setOffscreenPageLimit(count)设置离线缓存的界面个数。
FragmentPagerAdapter和FragmentStatePagerAdapter需要重写的方法都一样，常见的重写方法如下：
- public FragmentPagerAdapter(FragmentManager fm): 构造函数，参数为FragmentManager。如果是嵌套Fragment场景，子 PagerAdapter的参数传入getChildFragmentManager()。
- Fragment getItem(int position): 返回第position位置的Fragment，必须重写。
- int getCount(): 返回ViewPager的页数，必须重写。
- Object instantiateItem(ViewGroup container, int position): container是ViewPager对象，返回第position位置的Fragment。
- void destroyItem(ViewGroup container, int position, Object object): container是ViewPager对象，object是Fragment对象。
- getItemPosition(Object object): object是Fragment对象，如果返回POSITION_UNCHANGED，则表示当前Fragment不刷新，如果返回POSITION_NONE，则表示当前Fragment需要调用destroyItem()和instantiateItem()进行销毁和重建。 默认情况下返回POSITION_UNCHANGED。
部分代码：
public class MainActivity extends AppCompatActivity {
@BindView(R.id.vp)
ViewPager vp;
@BindView(R.id.tablayout)
TabLayout mTabLayout;
private ArrayList<String> list;
private MyFragmentStatePagerAdapter statePagerAdapter;
private ArrayList<Fragment> fragments;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
list = new ArrayList<String>();
list.add("TAB1");
list.add("TAB2");
list.add("TAB3");
list.add("TAB4");
list.add("TAB5");
fragments = new ArrayList<>();
fragments.add(MyFragment.newInstance("fragment1"));
fragments.add(MyFragment.newInstance("fragment2"));
fragments.add(MyFragment.newInstance("fragment3"));
fragments.add(MyFragment.newInstance("fragment4"));
fragments.add(MyFragment.newInstance("fragment5"));
ButterKnife.bind(this);
loadTabData();
statePagerAdapter = new MyFragmentStatePagerAdapter(getSupportFragmentManager());
vp.setAdapter(statePagerAdapter);
vp.addOnPageChangeListener(new MyPageChangeListener());
mTabLayout.addOnTabSelectedListener(new TabLayout.ViewPagerOnTabSelectedListener(vp));
//mTabLayout.addOnTabSelectedListener();
}
private void loadTabData() {
for (String s : list) {
TabLayout.Tab tab = mTabLayout.newTab();
View tabview = LayoutInflater.from(this).inflate(R.layout.tab_item, null);
TextView tv_tab = (TextView) tabview.findViewById(R.id.tab_tv);
tv_tab.setText(s);
tab.setCustomView(tabview);
mTabLayout.addTab(tab);
}
}
class MyFragmentStatePagerAdapter extends FragmentStatePagerAdapter{
public MyFragmentStatePagerAdapter(FragmentManager fm) {
super(fm);
}
@Override
public Fragment getItem(int position) {
return fragments.get(position);
}
@Override
public int getCount() {
return list.size();
}
}
class MyPageChangeListener implements ViewPager.OnPageChangeListener {
@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
}
@Override
public void onPageSelected(int position) {
mTabLayout.getTabAt(position).select();
}
@Override
public void onPageScrollStateChanged(int state) {
}
}
}fragment 代码如下：
public class MyFragment extends Fragment {
private static final String ARG_PARAM1 = "param1";
private String mParam1;
public MyFragment() {
// Required empty public constructor
}
public static MyFragment newInstance(String param1) {
MyFragment fragment = new MyFragment();
Bundle args = new Bundle();
args.putString(ARG_PARAM1, param1);
fragment.setArguments(args);
return fragment;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (getArguments() != null) {
mParam1 = getArguments().getString(ARG_PARAM1);
}
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_my, container, false);
TextView tv_fragment = (TextView) view.findViewById(R.id.tv_fragment);
tv_fragment.setText(mParam1);
return view;
}
}布局文件 就不列出了
相关详细代码
5.3 Fragment与SlidingPaneLayout的结合使用
布局文件：
<?xml version="1.0" encoding="utf-8"?>
<android.support.v4.widget.SlidingPaneLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:id="@+id/spl_root" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".simple.SimpleUse2Activity">
<fragment android:id="@+id/fragment_leftmenu" android:name="com.diygreen.slidingpanelayoutdemo.simple.LeftMenuFragment" android:layout_width="100dp" android:layout_height="match_parent" android:layout_gravity="left"/>
<fragment android:id="@+id/fragment_rightcontent" android:name="com.diygreen.slidingpanelayoutdemo.simple.RightContentFragment" android:layout_width="match_parent" android:layout_height="match_parent" android:layout_weight="1" android:layout_gravity="right"/>
</android.support.v4.widget.SlidingPaneLayout>5.4 Fragment与FragmentTabhost的结合使用
- 我自己自定义了一个FragmentTabHost，因为原来的FragmentTabHost每次切换Fragment事都会走一遍onCreateView（）和onResume（）方法；
自定义的FragmentTabHost如下：
public class FragmentTabHost extends TabHost implements TabHost.OnTabChangeListener {
private final ArrayList<TabInfo> mTabs = new ArrayList<TabInfo>();
private FrameLayout mRealTabContent;
private Context mContext;
private FragmentManager mFragmentManager;
private int mContainerId;
private OnTabChangeListener mOnTabChangeListener;
private TabInfo mLastTab;
private boolean mAttached;
static final class TabInfo {
private final String tag;
private final Class<?> clss;
private final Bundle args;
private Fragment fragment;
TabInfo(String _tag, Class<?> _class, Bundle _args) {
tag = _tag;
clss = _class;
args = _args;
}
}
static class DummyTabFactory implements 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;
}
}
static class SavedState extends BaseSavedState {
String curTab;
SavedState(Parcelable superState) {
super(superState);
}
private SavedState(Parcel in) {
super(in);
curTab = in.readString();
}
@Override
public void writeToParcel(Parcel out, int flags) {
super.writeToParcel(out, flags);
out.writeString(curTab);
}
@Override
public String toString() {
return "FragmentTabHost.SavedState{"
+ Integer.toHexString(System.identityHashCode(this))
+ " curTab=" + curTab + "}";
}
public static final Creator<SavedState> CREATOR = new Creator<SavedState>() {
public SavedState createFromParcel(Parcel in) {
return new SavedState(in);
}
public SavedState[] newArray(int size) {
return new SavedState[size];
}
};
}
public FragmentTabHost(Context context) {
// Note that we call through to the version that takes an AttributeSet,
// because the simple Context construct can result in a broken object!
super(context, null);
initFragmentTabHost(context, null);
}
public FragmentTabHost(Context context, AttributeSet attrs) {
super(context, attrs);
initFragmentTabHost(context, attrs);
}
private void initFragmentTabHost(Context context, AttributeSet attrs) {
TypedArray a = context.obtainStyledAttributes(attrs,
new int[] { android.R.attr.inflatedId }, 0, 0);
mContainerId = a.getResourceId(0, 0);
a.recycle();
super.setOnTabChangedListener(this);
}
private void ensureHierarchy(Context context) {
// If owner hasn't made its own view hierarchy, then as a convenience
// we will construct a standard one here.
if (findViewById(android.R.id.tabs) == null) {
LinearLayout ll = new LinearLayout(context);
ll.setOrientation(LinearLayout.VERTICAL);
addView(ll, new LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT));
TabWidget tw = new TabWidget(context);
tw.setId(android.R.id.tabs);
tw.setOrientation(TabWidget.HORIZONTAL);
ll.addView(tw, new LinearLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.WRAP_CONTENT, 0));
FrameLayout fl = new FrameLayout(context);
fl.setId(android.R.id.tabcontent);
ll.addView(fl, new LinearLayout.LayoutParams(0, 0, 0));
mRealTabContent = fl = new FrameLayout(context);
mRealTabContent.setId(mContainerId);
ll.addView(fl, new LinearLayout.LayoutParams(
LinearLayout.LayoutParams.MATCH_PARENT, 0, 1));
}
}
/** * @deprecated Don't call the original TabHost setup, you must instead call * {@link #setup(Context, FragmentManager)} or * {@link #setup(Context, FragmentManager, int)}. */
@Override
@Deprecated
public void setup() {
throw new IllegalStateException(
"Must call setup() that takes a Context and FragmentManager");
}
public void setup(Context context, FragmentManager manager) {
ensureHierarchy(context); // Ensure views required by super.setup()
super.setup();
mContext = context;
mFragmentManager = manager;
ensureContent();
}
public void setup(Context context, FragmentManager manager, int containerId) {
ensureHierarchy(context); // Ensure views required by super.setup()
super.setup();
mContext = context;
mFragmentManager = manager;
mContainerId = containerId;
ensureContent();
mRealTabContent.setId(containerId);
// We must have an ID to be able to save/restore our state. If
// the owner hasn't set one at this point, we will set it ourself.
if (getId() == View.NO_ID) {
setId(android.R.id.tabhost);
}
}
private void ensureContent() {
if (mRealTabContent == null) {
mRealTabContent = (FrameLayout) findViewById(mContainerId);
if (mRealTabContent == null) {
throw new IllegalStateException(
"No tab content FrameLayout found for id "
+ mContainerId);
}
}
}
@Override
public void setOnTabChangedListener(OnTabChangeListener l) {
mOnTabChangeListener = l;
}
public void addTab(TabSpec tabSpec, Class<?> clss, Bundle args) {
tabSpec.setContent(new DummyTabFactory(mContext));
String tag = tabSpec.getTag();
TabInfo info = new TabInfo(tag, clss, args);
if (mAttached) {
// If we are already attached to the window, then check to make
// sure this tab's fragment is inactive if it exists. This shouldn't
// normally happen.
info.fragment = mFragmentManager.findFragmentByTag(tag);
if (info.fragment != null && !info.fragment.isDetached()) {
FragmentTransaction ft = mFragmentManager.beginTransaction();
// ft.detach(info.fragment);
ft.hide(info.fragment);
ft.commit();
}
}
mTabs.add(info);
addTab(tabSpec);
}
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
String currentTab = getCurrentTabTag();
// Go through all tabs and make sure their fragments match
// the correct state.
FragmentTransaction ft = null;
for (int i = 0; i < mTabs.size(); i++) {
TabInfo tab = mTabs.get(i);
tab.fragment = mFragmentManager.findFragmentByTag(tab.tag);
// if (tab.fragment != null && !tab.fragment.isDetached()) {
if (tab.fragment != null) {
if (tab.tag.equals(currentTab)) {
// The fragment for this tab is already there and
// active, and it is what we really want to have
// as the current tab. Nothing to do.
mLastTab = tab;
} else {
// This fragment was restored in the active state,
// but is not the current tab. Deactivate it.
if (ft == null) {
ft = mFragmentManager.beginTransaction();
}
// ft.detach(tab.fragment);
ft.hide(tab.fragment);
}
}
}
// We are now ready to go. Make sure we are switched to the
// correct tab.
mAttached = true;
ft = doTabChanged(currentTab, ft);
if (ft != null) {
ft.commitAllowingStateLoss();
mFragmentManager.executePendingTransactions();
}
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
mAttached = false;
}
@Override
protected Parcelable onSaveInstanceState() {
Parcelable superState = super.onSaveInstanceState();
SavedState ss = new SavedState(superState);
ss.curTab = getCurrentTabTag();
return ss;
}
@Override
protected void onRestoreInstanceState(Parcelable state) {
SavedState ss = (SavedState) state;
super.onRestoreInstanceState(ss.getSuperState());
setCurrentTabByTag(ss.curTab);
}
@Override
public void onTabChanged(String tabId) {
if (mAttached) {
FragmentTransaction ft = doTabChanged(tabId, null);
if (ft != null) {
ft.commit();
}
}
if (mOnTabChangeListener != null) {
mOnTabChangeListener.onTabChanged(tabId);
}
}
private FragmentTransaction doTabChanged(String tabId,
FragmentTransaction ft) {
TabInfo newTab = null;
for (int i = 0; i < mTabs.size(); i++) {
TabInfo tab = mTabs.get(i);
if (tab.tag.equals(tabId)) {
newTab = tab;
}
}
if (newTab == null) {
throw new IllegalStateException("No tab known for tag " + tabId);
}
if (mLastTab != newTab) {
if (ft == null) {
ft = mFragmentManager.beginTransaction();
}
if (mLastTab != null) {
if (mLastTab.fragment != null) {
// ft.detach(mLastTab.fragment);
ft.hide(mLastTab.fragment);
}
}
if (newTab != null) {
if (newTab.fragment == null) {
newTab.fragment = Fragment.instantiate(mContext,
newTab.clss.getName(), newTab.args);
ft.add(mContainerId, newTab.fragment, newTab.tag);
} else {
// ft.attach(newTab.fragment);
ft.show(newTab.fragment);
}
}
mLastTab = newTab;
}
return ft;
}
}activity布局:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical" tools:context="mgzxc.fragmenttabhostdemo.MainActivity">
<FrameLayout android:id="@+id/flayout_content" android:layout_width="match_parent" android:layout_height="0dp" android:layout_weight="1"/>
<mgzxc.fragmenttabhostdemo.FragmentTabHost android:id="@android:id/tabhost" android:background="#ffffff" android:layout_width="match_parent" android:layout_height="wrap_content">
<FrameLayout android:id="@android:id/tabhost" android:layout_width="0dp" android:layout_height="0dp" android:layout_weight="0"/>
</mgzxc.fragmenttabhostdemo.FragmentTabHost>
</LinearLayout>注意：
id必须是android:id=”@android:id/tabhost”这个；
里面的FrameLayout的id必须是android:id=”@android:id/tabcontent”
定义Tab类：
public class Tab {
private int title; // 文字
private int icon; // 图标
private Class fragment; // 对应fragment
public Tab() {
}
public Tab(int title, int icon, Class fragment) {
this.title = title;
this.icon = icon;
this.fragment = fragment;
}
public int getTitle() {
return title;
}
public void setTitle(int title) {
this.title = title;
}
public int getIcon() {
return icon;
}
public void setIcon(int icon) {
this.icon = icon;
}
public Class getFragment() {
return fragment;
}
public void setFragment(Class fragment) {
this.fragment = fragment;
}
}初始化Tab
mTabs = new ArrayList<Tab>();
Tab tab_home = new Tab(R.string.home,R.drawable.selector_icon_home,HomeFragment.class);
Tab tab_news = new Tab(R.string.news,R.drawable.selector_icon_news,NewsFragment.class);
Tab tab_service = new Tab(R.string.service,R.drawable.selector_icon_service,ServiceFragment.class);
Tab tab_person = new Tab(R.string.person,R.drawable.selector_icon_person,PersonFragment.class);
mTabs.add(tab_home);
mTabs.add(tab_news);
mTabs.add(tab_service);
mTabs.add(tab_person);找到该控件之后，就要调用对应的这个方法
mInflater = LayoutInflater.from(this);
tabHost = ((FragmentTabHost) findViewById(android.R.id.tabhost));
tabHost.setup(this,getSupportFragmentManager(),R.id.flayout_content);添加TabSpec有几个Tab，就添加几个TabSpec
for (Tab mTab : mTabs) {
TabHost.TabSpec tabSpec = this.tabHost.newTabSpec(getString(mTab.getTitle()));
tabSpec.setIndicator(buildIndicator(mTab));
this.tabHost.addTab(tabSpec,mTab.getFragment(),null);
}
tabHost.setCurrentTab(0);
//构建Indicator
private View buildIndicator(Tab tab){
View view =mInflater.inflate(R.layout.tab_indicator,null);
ImageView img = (ImageView) view.findViewById(R.id.icon_tab);
TextView text = (TextView) view.findViewById(R.id.txt_indicator);
img.setBackgroundResource(tab.getIcon());
text.setText(tab.getTitle());
return view;
}5.5 Fragment 嵌套
主要代码：
在第一层fragment处：
FragmentManager fragmentManager = getChildFragmentManager();
FragmentTransaction transaction = fragmentManager.beginTransaction();
leftFragment = new LeftFragment();
rightFragment = new RightFragment();
transaction.add(R.id.left_container, leftFragment);
transaction.add(R.id.right_container, rightFragment);
transaction.commit();5.6 Fragment 动画
效果：
fragment这里所说的动画指的是fragment转场动画，是通过fragment事物管理器里的setCustomAnimations方法来实现：
activity代码：
public class MainActivity extends AppCompatActivity {
private FragmentLeft fragmentLeft;
private FragmentRight fragmentRight;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
fragmentLeft = new FragmentLeft();
fragmentRight = new FragmentRight();
}
public void clickLeft(View view){
FragmentManager fragmentManager = getSupportFragmentManager();
FragmentTransaction transaction = fragmentManager.beginTransaction();
//arg0,进入 arg1 退出 add 或 Replace操作的动画
//arg2,进入 arg3 退出 按返回键
transaction.setCustomAnimations(R.anim.next_enter, R.anim.next_exit, R.anim.pre_enter, R.anim.pre_exit);
if( fragmentRight.isVisible()){
transaction.hide(fragmentRight);
}
if(fragmentLeft.isAdded()){
transaction.show(fragmentLeft);
}else{
transaction.add(R.id.fl_container, fragmentLeft );
}
transaction.addToBackStack(null);
transaction.commit();
}
public void clickRight(View view){
FragmentManager fragmentManager = getSupportFragmentManager();
FragmentTransaction transaction = fragmentManager.beginTransaction();
transaction.setCustomAnimations(R.anim.next_enter, R.anim.next_exit, R.anim.pre_enter, R.anim.pre_exit);
if( fragmentLeft.isVisible()){
transaction.hide(fragmentLeft);
}
if(fragmentRight.isAdded()){
transaction.show(fragmentRight);
}else{
transaction.add(R.id.fl_container, fragmentRight );
}
transaction.addToBackStack(null);
transaction.commit();
}
}动画：
next_enter.xml:
<?xml version="1.0" encoding="utf-8"?>
<translate android:fromXDelta="100%" xmlns:android="http://schemas.android.com/apk/res/android" android:toXDelta="0" android:duration="500">
</translate>pre_enter.xml:
<?xml version="1.0" encoding="utf-8"?>
<translate android:fromXDelta="-100%" xmlns:android="http://schemas.android.com/apk/res/android" android:toXDelta="0" android:duration="500">
</translate>next_exit.xml:
<?xml version="1.0" encoding="utf-8"?>
<translate android:fromXDelta="0" xmlns:android="http://schemas.android.com/apk/res/android" android:toXDelta="-100%" android:duration="500">
</translate>pre_exit.xml:
<?xml version="1.0" encoding="utf-8"?>
<translate android:fromXDelta="0" xmlns:android="http://schemas.android.com/apk/res/android" android:toXDelta="100%" android:duration="500">
</translate>5.7 懒加载
懒加载主要用于ViewPager且每页是Fragment的情况，当滑到另一个tab时，先显示”正在加载”，过一会才会显示正常界面。
默认情况，ViewPager会缓存当前页和左右相邻的界面。实现懒加载的主要原因是：用户没进入的界面需要有一系列的网络、数据库等耗资源、耗时的操作，预先做这些数据加载是不必要的。
这里懒加载的实现思路是：用户不可见的界面，只初始化UI，但是不会做任何数据加载。等滑到该页，才会异步做数据加载并更新UI。
这里就实现类似微信那种效果，整个UI布局为：底部用PagerBottomTabStrip(https://github.com/tyzlmjj/PagerBottomTabStrip)项目实现，上面是ViewPager，使用FragmentPagerAdapter。逻辑为：当用户滑到另一个界面，首先会显示正在加载，等数据加载完毕后（这里用睡眠1秒钟代替）显示正常界面。
ViewPager默认缓存左右相邻界面，为了避免不必要的重新数据加载（重复调用onCreateView()），因为有4个tab，因此将离线缓存的半径设置为3，即setOffscreenPageLimit(3)。
懒加载主要依赖Fragment的setUserVisibleHint(boolean isVisible)方法，当Fragment变为可见时，会调用setUserVisibleHint(true)；当Fragment变为不可见时，会调用setUserVisibleHint(false)，且该方法调用时机：
- onAttach()之前，调用setUserVisibleHint(false)。
- onCreateView()之前，如果该界面为当前页，则调用setUserVisibleHint(true)，否则调用setUserVisibleHint(false)。
- 界面变为可见时，调用setUserVisibleHint(true)。
- 界面变为不可见时，调用setUserVisibleHint(false)。
- viewpager监听切换tab事件，tab切换一次，执行一次setUserVisibleHint()方法
- setUserVisibleHint()在fragment所有生命周期之前，无论viewpager是在activity哪个生命周期里初始化。
- activity生命周期 和 fragment生命周期 时序并不是按序来的，也就是说fragment的oncreate方法时序并不一定在activity的oncreate方法之后。
懒加载Fragment的实现：
public class LazyFragment extends Fragment { private View mRootView;
private boolean mIsInited;
private boolean mIsPrepared; @Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
mRootView = inflater.inflate(R.layout.fragment_lazy, container, false);
mIsPrepared = true;
lazyLoad();
return mRootView;
}
public void lazyLoad() {
if (getUserVisibleHint() && mIsPrepared && !mIsInited) {
//异步初始化，在初始化后显示正常UI
loadData();
}
}
private void loadData() {
new Thread() {
public void run() {
//1. 加载数据
//2. 更新UI
//3. mIsInited = true
}
}.start();
}
@Override
public void setUserVisibleHint(boolean isVisibleToUser) {
super.setUserVisibleHint(isVisibleToUser);
if (isVisibleToUser) {
lazyLoad();
}
}
public static LazyFragment newInstance() {
return new LazyFragment();
}
}注意点：
1）在Fragment中有两个变量控制是否需要做数据加载：
- mIsPrepared：表示UI是否准备好，因为数据加载后需要更新UI，如果UI还没有inflate，就不需要做数据加载，因为setUserVisibleHint()会在onCreateView()之前调用一次，如果此时调用，UI还没有inflate，因此不能加载数据。
- mIsInited：表示是否已经做过数据加载，如果做过了就不需要做了。因为setUserVisibleHint(true)在界面可见时都会调用，如果滑到该界面做过数据加载后，滑走，再滑回来，还是会调用setUserVisibleHint(true)，此时由于mIsInited=true，因此不会再做一遍数据加载。
2）lazyLoad()：懒加载的核心类，在该方法中，只有界面可见（getUserVisibleHint()==true）、UI准备好（mIsPrepared==true）、过去没做过数据加载（mIsInited==false）时，才需要调loadData()做数据加载，数据加载做完后把mIsInited置为true。
布局XML主要分两个container，一个是初始显示的状态，即R.id.container_empty，当数据加载完成，就显示R.id.container：
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent">
<RelativeLayout
android:id="@+id/container_empty"
android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
android:text="正在加载"
/>
</RelativeLayout>
<RelativeLayout
android:id="@+id/container"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:visibility="gone"
>
...
</RelativeLayout>
</FrameLayout>