前言
最近在项目中用到了一个 Fragment 管理框架，简直是一个牛逼，这个介绍给大家，这款框架让你爱上使用 Fragment，可以让你的 Fragment 像使用 Activity 一样方便管理。使用它绝对可以让你的开发效率大幅度提升，如果再结合 ConstraintLayout 来开发界面的过程简直让你爽的不要不要的。
项目地址：https://github.com/YoKeyword/Fragmentation
演示APK下载：https://www.pgyer.com/fragmentation
特性
- 悬浮球／摇一摇实时查看 Fragment 的栈视图，降低开发难度。
- 内部队列机制 解决 Fragment 多点触控、事务高频次提交异常等问题。
- 增加启动模式、startForResult 等类 Activity 方法。
- 类 Android 事件分发机制的 Fragment BACK 键机制：onBackPressedSupport().
- 提供 onSupportVisible()、懒加载 onLazyInitView() 等生命周期方法，简化嵌套 Fragment 的开发过程。
- 提供 Fragment 转场动画 系列解决方案，动态改变动画。
- 提供 Activity 作用域的 EventBus 辅助类，Fragment 通信更简单、独立(需要使用 EventBusActivityScope 库)。
- 支持 SwipeBack 滑动边缘退出(需要使用 Fragmentation_SwipeBack 库)。
如何使用
引入库
第一步：在 build.gradle 文件中添加如下配置：
// This is the use of androidx, if you are using the android.support: fragmentationx -> fragmentation
implementation 'me.yokeyword:fragmentationx:1.0.1'
// If you don't want to extends SupportActivity/Fragment and would like to customize your own support, just rely on fragmentation-core
// implementation 'me.yokeyword:fragmentationx-core:1.0.1'
// To get SwipeBack feature, rely on both fragmentation & fragmentation-swipeback
implementation 'me.yokeyword:fragmentationx:1.0.1'
// Swipeback is based on fragmentation. Refer to SwipeBackActivity/Fragment for your Customized SupportActivity/Fragment
implementation 'me.yokeyword:fragmentationx-swipeback:1.0.1'
// To simplify the communication between Fragments.
implementation 'me.yokeyword:eventbus-activity-scope:1.1.0'
// Your EventBus's version
implementation 'org.greenrobot:eventbus:{version}'
第二步：让你的 Activity 继承 extends SupportActivity 或者实现接口 implements ISupportActivity.
package me.yokeyword.sample.demo_flow.base;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import android.view.MotionEvent;
import me.yokeyword.fragmentation.ExtraTransaction;
import me.yokeyword.fragmentation.ISupportActivity;
import me.yokeyword.fragmentation.ISupportFragment;
import me.yokeyword.fragmentation.SupportActivityDelegate;
import me.yokeyword.fragmentation.SupportFragment;
import me.yokeyword.fragmentation.SupportHelper;
import me.yokeyword.fragmentation.anim.FragmentAnimator;
/**
* 展示自定制的MySupportActivity，不继承SupportActivity
* Created by YoKey on 17/6/24.
*/
public class MySupportActivity extends AppCompatActivity implements ISupportActivity{
final SupportActivityDelegate mDelegate = new SupportActivityDelegate(this);
@Override
public SupportActivityDelegate getSupportDelegate() {
return mDelegate;
}
/**
* Perform some extra transactions.
* 额外的事务：自定义Tag，添加SharedElement动画，操作非回退栈Fragment
*/
@Override
public ExtraTransaction extraTransaction() {
return mDelegate.extraTransaction();
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mDelegate.onCreate(savedInstanceState);
}
@Override
protected void onPostCreate(@Nullable Bundle savedInstanceState) {
super.onPostCreate(savedInstanceState);
mDelegate.onPostCreate(savedInstanceState);
}
@Override
protected void onDestroy() {
mDelegate.onDestroy();
super.onDestroy();
}
/**
* Note： return mDelegate.dispatchTouchEvent(ev) || super.dispatchTouchEvent(ev);
*/
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
return mDelegate.dispatchTouchEvent(ev) || super.dispatchTouchEvent(ev);
}
/**
* 不建议复写该方法,请使用 {@link #onBackPressedSupport} 代替
*/
@Override
final public void onBackPressed() {
mDelegate.onBackPressed();
}
/**
* 该方法回调时机为,Activity回退栈内Fragment的数量 小于等于1 时,默认finish Activity
* 请尽量复写该方法,避免复写onBackPress(),以保证SupportFragment内的onBackPressedSupport()回退事件正常执行
*/
@Override
public void onBackPressedSupport() {
mDelegate.onBackPressedSupport();
}
/**
* 获取设置的全局动画 copy
*
* @return FragmentAnimator
*/
@Override
public FragmentAnimator getFragmentAnimator() {
return mDelegate.getFragmentAnimator();
}
/**
* Set all fragments animation.
* 设置Fragment内的全局动画
*/
@Override
public void setFragmentAnimator(FragmentAnimator fragmentAnimator) {
mDelegate.setFragmentAnimator(fragmentAnimator);
}
/**
* Set all fragments animation.
* 构建Fragment转场动画
* <p/>
* 如果是在Activity内实现,则构建的是Activity内所有Fragment的转场动画,
* 如果是在Fragment内实现,则构建的是该Fragment的转场动画,此时优先级 > Activity的onCreateFragmentAnimator()
*
* @return FragmentAnimator对象
*/
@Override
public FragmentAnimator onCreateFragmentAnimator() {
return mDelegate.onCreateFragmentAnimator();
}
/**
* Causes the Runnable r to be added to the action queue.
* <p>
* The runnable will be run after all the previous action has been run.
* <p>
* 前面的事务全部执行后 执行该Action
*/
@Override
public void post(Runnable runnable) {
mDelegate.post(runnable);
}
/****************************************以下为可选方法(Optional methods)******************************************************/
// 选择性拓展其他方法
public void loadRootFragment(int containerId, @NonNull ISupportFragment toFragment) {
mDelegate.loadRootFragment(containerId, toFragment);
}
public void start(ISupportFragment toFragment) {
mDelegate.start(toFragment);
}
/**
* @param launchMode Same as Activity's LaunchMode.
*/
public void start(ISupportFragment toFragment, @ISupportFragment.LaunchMode int launchMode) {
mDelegate.start(toFragment, launchMode);
}
/**
* It is recommended to use {@link SupportFragment#startWithPopTo(ISupportFragment, Class, boolean)}.
*
* @see #popTo(Class, boolean)
* +
* @see #start(ISupportFragment)
*/
public void startWithPopTo(ISupportFragment toFragment, Class<?> targetFragmentClass, boolean includeTargetFragment) {
mDelegate.startWithPopTo(toFragment, targetFragmentClass, includeTargetFragment);
}
/**
* Pop the fragment.
*/
public void pop() {
mDelegate.pop();
}
/**
* Pop the last fragment transition from the manager's fragment
* back stack.
*/
public void popTo(Class<?> targetFragmentClass, boolean includeTargetFragment) {
mDelegate.popTo(targetFragmentClass, includeTargetFragment);
}
/**
* If you want to begin another FragmentTransaction immediately after popTo(), use this method.
* 如果你想在出栈后, 立刻进行FragmentTransaction操作，请使用该方法
*/
public void popTo(Class<?> targetFragmentClass, boolean includeTargetFragment, Runnable afterPopTransactionRunnable) {
mDelegate.popTo(targetFragmentClass, includeTargetFragment, afterPopTransactionRunnable);
}
public void popTo(Class<?> targetFragmentClass, boolean includeTargetFragment, Runnable afterPopTransactionRunnable, int popAnim) {
mDelegate.popTo(targetFragmentClass, includeTargetFragment, afterPopTransactionRunnable, popAnim);
}
/**
* 得到位于栈顶Fragment
*/
public ISupportFragment getTopFragment() {
return SupportHelper.getTopFragment(getSupportFragmentManager());
}
/**
* 获取栈内的fragment对象
*/
public <T extends ISupportFragment> T findFragment(Class<T> fragmentClass) {
return SupportHelper.findFragment(getSupportFragmentManager(), fragmentClass);
}
}
第三步：让你的 Fragment 继承 extends SupportFrgment 或者实现接口 implements ISupportFragment。
package me.yokeyword.sample.demo_flow.base;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentActivity;
import android.view.View;
import android.view.animation.Animation;
import me.yokeyword.fragmentation.ExtraTransaction;
import me.yokeyword.fragmentation.ISupportFragment;
import me.yokeyword.fragmentation.SupportFragmentDelegate;
import me.yokeyword.fragmentation.SupportHelper;
import me.yokeyword.fragmentation.anim.FragmentAnimator;
/**
* 展示自定制的MySupportFragment，不继承SupportFragment
* Created by YoKey on 17/6/24.
*/
public class MySupportFragment extends Fragment implements ISupportFragment {
final SupportFragmentDelegate mDelegate = new SupportFragmentDelegate(this);
protected FragmentActivity _mActivity;
@Override
public SupportFragmentDelegate getSupportDelegate() {
return mDelegate;
}
/**
* Perform some extra transactions.
* 额外的事务：自定义Tag，添加SharedElement动画，操作非回退栈Fragment
*/
@Override
public ExtraTransaction extraTransaction() {
return mDelegate.extraTransaction();
}
@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
mDelegate.onAttach(activity);
_mActivity = mDelegate.getActivity();
}
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mDelegate.onCreate(savedInstanceState);
}
@Override
public Animation onCreateAnimation(int transit, boolean enter, int nextAnim) {
return mDelegate.onCreateAnimation(transit, enter, nextAnim);
}
@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
mDelegate.onActivityCreated(savedInstanceState);
}
@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
mDelegate.onSaveInstanceState(outState);
}
@Override
public void onResume() {
super.onResume();
mDelegate.onResume();
}
@Override
public void onPause() {
super.onPause();
mDelegate.onPause();
}
@Override
public void onDestroyView() {
mDelegate.onDestroyView();
super.onDestroyView();
}
@Override
public void onDestroy() {
mDelegate.onDestroy();
super.onDestroy();
}
@Override
public void onHiddenChanged(boolean hidden) {
super.onHiddenChanged(hidden);
mDelegate.onHiddenChanged(hidden);
}
@Override
public void setUserVisibleHint(boolean isVisibleToUser) {
super.setUserVisibleHint(isVisibleToUser);
mDelegate.setUserVisibleHint(isVisibleToUser);
}
/**
* Causes the Runnable r to be added to the action queue.
* <p>
* The runnable will be run after all the previous action has been run.
* <p>
* 前面的事务全部执行后 执行该Action
*
* @deprecated Use {@link #post(Runnable)} instead.
*/
@Deprecated
@Override
public void enqueueAction(Runnable runnable) {
mDelegate.enqueueAction(runnable);
}
/**
* Causes the Runnable r to be added to the action queue.
* <p>
* The runnable will be run after all the previous action has been run.
* <p>
* 前面的事务全部执行后 执行该Action
*/
@Override
public void post(Runnable runnable) {
mDelegate.post(runnable);
}
/**
* Called when the enter-animation end.
* 入栈动画 结束时,回调
*/
@Override
public void onEnterAnimationEnd(Bundle savedInstanceState) {
mDelegate.onEnterAnimationEnd(savedInstanceState);
}
/**
* Lazy initial，Called when fragment is first called.
* <p>
* 同级下的 懒加载 ＋ ViewPager下的懒加载 的结合回调方法
*/
@Override
public void onLazyInitView(@Nullable Bundle savedInstanceState) {
mDelegate.onLazyInitView(savedInstanceState);
}
/**
* Called when the fragment is visible.
* 当Fragment对用户可见时回调
* <p>
* Is the combination of [onHiddenChanged() + onResume()/onPause() + setUserVisibleHint()]
*/
@Override
public void onSupportVisible() {
mDelegate.onSupportVisible();
}
/**
* Called when the fragment is invivible.
* <p>
* Is the combination of [onHiddenChanged() + onResume()/onPause() + setUserVisibleHint()]
*/
@Override
public void onSupportInvisible() {
mDelegate.onSupportInvisible();
}
/**
* Return true if the fragment has been supportVisible.
*/
@Override
final public boolean isSupportVisible() {
return mDelegate.isSupportVisible();
}
/**
* Set fragment animation with a higher priority than the ISupportActivity
* 设定当前Fragmemt动画,优先级比在SupportActivity里高
*/
@Override
public FragmentAnimator onCreateFragmentAnimator() {
return mDelegate.onCreateFragmentAnimator();
}
/**
* 获取设置的全局动画 copy
*
* @return FragmentAnimator
*/
@Override
public FragmentAnimator getFragmentAnimator() {
return mDelegate.getFragmentAnimator();
}
/**
* 设置Fragment内的全局动画
*/
@Override
public void setFragmentAnimator(FragmentAnimator fragmentAnimator) {
mDelegate.setFragmentAnimator(fragmentAnimator);
}
/**
* 按返回键触发,前提是SupportActivity的onBackPressed()方法能被调用
*
* @return false则继续向上传递, true则消费掉该事件
*/
@Override
public boolean onBackPressedSupport() {
return mDelegate.onBackPressedSupport();
}
/**
* 类似 {@link Activity#setResult(int, Intent)}
* <p>
* Similar to {@link Activity#setResult(int, Intent)}
*
* @see #startForResult(ISupportFragment, int)
*/
@Override
public void setFragmentResult(int resultCode, Bundle bundle) {
mDelegate.setFragmentResult(resultCode, bundle);
}
/**
* 类似 {@link Activity#onActivityResult(int, int, Intent)}
* <p>
* Similar to {@link Activity#onActivityResult(int, int, Intent)}
*
* @see #startForResult(ISupportFragment, int)
*/
@Override
public void onFragmentResult(int requestCode, int resultCode, Bundle data) {
mDelegate.onFragmentResult(requestCode, resultCode, data);
}
/**
* 在start(TargetFragment,LaunchMode)时,启动模式为SingleTask/SingleTop, 回调TargetFragment的该方法
* 类似 {@link Activity#onNewIntent(Intent)}
* <p>
* Similar to {@link Activity#onNewIntent(Intent)}
*
* @param args putNewBundle(Bundle newBundle)
* @see #start(ISupportFragment, int)
*/
@Override
public void onNewBundle(Bundle args) {
mDelegate.onNewBundle(args);
}
/**
* 添加NewBundle,用于启动模式为SingleTask/SingleTop时
*
* @see #start(ISupportFragment, int)
*/
@Override
public void putNewBundle(Bundle newBundle) {
mDelegate.putNewBundle(newBundle);
}
/****************************************以下为可选方法(Optional methods)******************************************************/
// 自定制Support时，可移除不必要的方法
/**
* 隐藏软键盘
*/
protected void hideSoftInput() {
mDelegate.hideSoftInput();
}
/**
* 显示软键盘,调用该方法后,会在onPause时自动隐藏软键盘
*/
protected void showSoftInput(final View view) {
mDelegate.showSoftInput(view);
}
/**
* 加载根Fragment, 即Activity内的第一个Fragment 或 Fragment内的第一个子Fragment
*
* @param containerId 容器id
* @param toFragment 目标Fragment
*/
public void loadRootFragment(int containerId, ISupportFragment toFragment) {
mDelegate.loadRootFragment(containerId, toFragment);
}
public void loadRootFragment(int containerId, ISupportFragment toFragment, boolean addToBackStack, boolean allowAnim) {
mDelegate.loadRootFragment(containerId, toFragment, addToBackStack, allowAnim);
}
public void start(ISupportFragment toFragment) {
mDelegate.start(toFragment);
}
/**
* @param launchMode Similar to Activity's LaunchMode.
*/
public void start(final ISupportFragment toFragment, @LaunchMode int launchMode) {
mDelegate.start(toFragment, launchMode);
}
/**
* Launch an fragment for which you would like a result when it poped.
*/
public void startForResult(ISupportFragment toFragment, int requestCode) {
mDelegate.startForResult(toFragment, requestCode);
}
/**
* Start the target Fragment and pop itself
*/
public void startWithPop(ISupportFragment toFragment) {
mDelegate.startWithPop(toFragment);
}
/**
* @see #popTo(Class, boolean)
* +
* @see #start(ISupportFragment)
*/
public void startWithPopTo(ISupportFragment toFragment, Class<?> targetFragmentClass, boolean includeTargetFragment) {
mDelegate.startWithPopTo(toFragment, targetFragmentClass, includeTargetFragment);
}
public void replaceFragment(ISupportFragment toFragment, boolean addToBackStack) {
mDelegate.replaceFragment(toFragment, addToBackStack);
}
public void pop() {
mDelegate.pop();
}
/**
* Pop the last fragment transition from the manager's fragment
* back stack.
* <p>
* 出栈到目标fragment
*
* @param targetFragmentClass 目标fragment
* @param includeTargetFragment 是否包含该fragment
*/
public void popTo(Class<?> targetFragmentClass, boolean includeTargetFragment) {
mDelegate.popTo(targetFragmentClass, includeTargetFragment);
}
/**
* 获取栈内的fragment对象
*/
public <T extends ISupportFragment> T findChildFragment(Class<T> fragmentClass) {
return SupportHelper.findFragment(getChildFragmentManager(), fragmentClass);
}
}
第四步： 在 Application 中初始化 API.
Fragmentation.builder()
// 设置 栈视图 模式为 悬浮球模式 SHAKE: 摇一摇唤出 NONE：隐藏
.stackViewMode(Fragmentation.BUBBLE)
.debug(BuildConfig.DEBUG)
// 在遇到After onSaveInstanceState时，不会抛出异常，会回调到下面的ExceptionHandler
.handleException(new ExceptionHandler() {
@Override
public void onException(Exception e) {
// 建议在该回调处上传至我们的Crash监测服务器
// 以Bugtags为例子: 手动把捕获到的 Exception 传到 Bugtags 后台。
// Bugtags.sendException(e);
}
})
.install();
第五步：加载根 fragment，也就是第一个 fragment.
if (findFragment(HomeFragment.class) == null) {
loadRootFragment(R.id.fl_container, HomeFragment.newInstance()); // 加载根Fragment
}
第六步：启动一个新的 fragment.
// v1.0.0开始，不强制继承SupportFragment，可使用接口＋委托形式来实现自己的SupportFragment
public class HomeFragment extends SupportFragment {
private void xxx() {
// 启动新的Fragment, 另有start(fragment,SINGTASK)、startForResult、startWithPop等启动方法
start(DetailFragment.newInstance(HomeBean));
// ... 其他pop, find, 设置动画等等API, 请自行查看WIKI
}
}
API介绍
装载根 Fragment
一般在 findChildFragment(ChildFragment.class)==null 时 load。
// 装载根Fragment, 即Activity内的第一个Fragment 或 Fragment内的第一个子Fragment
loadRootFragment(int containerId, SupportFragment toFragment)
loadRootFragment(int containerId, SupportFragment toFragment, boolean addToBackStack, boolean allowEnterAnim)
// 装载多个根Fragment，用于同级Fragment的场景，详情见新Demo的MainActivity
loadMultipleRootFragment(int containerId, int showPosition, SupportFragment... toFragments);
同级 Fragment 场景下的切换：
// show一个Fragment，hide一个Fragment； 主要用于类似微信主页那种 切换tab的情况
showHideFragment(SupportFragment showFragment, SupportFragment hideFragment);
启动 Fragment
// 启动新的Fragment，启动者和被启动者是在同一个栈的
start(SupportFragment fragment)
// 以某种启动模式，启动新的Fragment
start(SupportFragment fragment, int launchMode)
// 启动新的Fragment，并能接收到新Fragment的数据返回
startForResult(SupportFragment fragment,int requestCode)
// 启动目标Fragment，并关闭当前Fragment
startWithPop(SupportFragment fragment)
// 启动目标Fragment，并关闭targetFragment之上的Fragments
startWithPopTo(SupportFragment fragment, Class targetFragment, boolean includeTargetFragment)
// 1.0.0 New: 你可以使用extraTransaction() + start() 来实现上面的各种startXX()设置更多功能
supportFragment.extraTransaction()
.setTag(tag) // 自定义tag
.addSharedElement(xx).setLaunchMode(SINGLETASK).withPop(true).forResult(1)
.start()
.popTo(tag, includeTagFragment)
//.dontAddToBackStack()
//.add()
//.remove(f) ...
下面的方法是 SupportFragment 才有的：
// replace方式启动目标Fragment，配合replaceLoadRootFragment()使用
replaceFragment(SupportFragment toFragment, boolean addToBack)
// Fragmentation的事务内部是通过一个ActionQueue队列排队执行的，使用该方法可以将自定义任务（事务）入队执行
post(Runnable runnable)
出栈
// 出栈当前Fragment(在当前Fragment所在栈内pop)
pop();
// 出栈targetFragment之上的所有Fragments
popTo(Class targetFragment, boolean includeTargetFragment);
// 如果想出栈后，紧接着.beginTransaction()开始一个新事务，请使用下面的方法：
// 该方法可以自定义出栈动画，可以让动画看起来更自然，如果对动画无要求，也可以使用popTo() + 事务来执行
popTo(Class targetFragment, boolean includeTargetFragment, Runnable afterTransaction, int animation)
下面的方法是 SupportFragment 才有的，操作目标是子 Fragment：
popChild();
popToChild(Class fragmentClass, boolean includeSelf);
popToChild(Class fragmentClass, boolean includeSelf, Runnable afterTransaction)
popToChild(Class fragmentClass, boolean includeSelf, Runnable afterTransaction,int popAnim)
查找 Fragment
// 获取所在栈内的栈顶Fragment
getTopFragment();
// 获取当前Fragment所在栈内的前一个Fragment
getPreFragment();
// 通过class获取所在栈内的某个Fragment
findFragment(Class fragmentClass);
下面的方法是 SupportFragment 才有的，从子栈内查找：
getTopChildFragment();
findChildFragment(Class fragmentClass);
输入法相关
因为 Fragment 被出栈时，不会自动隐藏软键盘，以及弹出软键盘有些麻烦，故提供下面 2 个方法：
// 隐藏软键盘 一般用在hide时
hideSoftInput();
// 显示软键盘，调用该方法后，会在onPause时自动隐藏软键盘
showSoftInput(View view);
