此处将为大家介绍关于Android强化——FragmentManger和Fragment的详细内容，并且为您解答有关androidfragmentmanager的相关问题，此外，我们还将为您介绍关于A
此处将为大家介绍关于Android强化——FragmentManger和Fragment的详细内容，并且为您解答有关android fragmentmanager的相关问题，此外，我们还将为您介绍关于Android 11（仅）FragmentManager崩溃-FragmentManager已被破坏、android 3.0中的getSupportFragmentManager()与getFragmentManager()、Android Fragment – 使用activity的loadermanager而不是Fragment.好吗？、Android Fragment 和 FragmentManager 的代码分析的有用信息。
本文目录一览：- Android强化——FragmentManger和Fragment（android fragmentmanager）
- Android 11（仅）FragmentManager崩溃-FragmentManager已被破坏
- android 3.0中的getSupportFragmentManager()与getFragmentManager()
- Android Fragment – 使用activity的loadermanager而不是Fragment.好吗？
- Android Fragment 和 FragmentManager 的代码分析
Android强化——FragmentManger和Fragment（android fragmentmanager）
Fragment受Fragmentmanger控制。
通过Fragmentmanger获取FragmentTransaction。ft.replace(containerView，fragment)替换fragment
使用
fragmentTransaction = supportFragmentManager.beginTransaction();
fragmentTransaction.replace(R.id.main_page_container,baseFragment);
fragmentTransaction.commit();
而且fragment内嵌套fragment需要getChildFragmentmanger();
public class HomeFragment extends BaseFragment {
private TabLayout tabLayout;
private ViewPager viewPager;
private HomeViewPagerAdapter homeViewPagerAdapter;
private HomePresenter homePresenter;
@Override
protected int getRootViewResId() {
return R.layout.fragment_home;
}
@Override
public void initView(View view) {
tabLayout = view.findViewById(R.id.tabLayout);
viewPager = view.findViewById(R.id.viewPager);
homeViewPagerAdapter = new HomeViewPagerAdapter(getChildFragmentManager());
viewPager.setAdapter(homeViewPagerAdapter);
tabLayout.setupWithViewPager(viewPager);
}
@Override
public void initData() {
}
@Override
public void initEvent() {
}
@Override
public void initPresenter() {
homePresenter = new HomePresenter();
homePresenter.setHomeFragment(HomeFragment.this);
}
@Override
public void loadData() {
homePresenter.getCategories();
}
public void loadCategories(Categories categories){
homeViewPagerAdapter.setCategories(categories);
}
}
HomeViewPagerAdapter
public class HomeViewPagerAdapter extends FragmentPagerAdapter {
private ArrayList<Categories.Data> dataArray = new ArrayList<>();
public HomeViewPagerAdapter(@NonNull FragmentManager fm) {
super(fm, BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT);
}
@Nullable
@Override
public CharSequence getPageTitle(int position) {
String title = dataArray.get(position).getTitle();
return title;
}
@NonNull
@Override
public Fragment getItem(int position) {
HomePagerFragment homePagerFragment = new HomePagerFragment();
return homePagerFragment;
}
@Override
public int getCount() {
return dataArray.size();
}
public void setCategories(Categories categories){
dataArray.clear();
List<Categories.Data> data = categories.getData();
dataArray.addAll(data);
notifyDataSetChanged();
}
}
Android 11（仅）FragmentManager崩溃-FragmentManager已被破坏
使用supportFragmentManager代替fragmentManager
fun pushQuestionHintFragment() {
val fragmentTransaction = supportFragmentManager.beginTransaction()
fragmentTransaction.replace(
R.id.container,TreasureHuntQuestionHintFragment.newInstance(),"questionHintFragment-${specificQuestionId}").addToBackStack("questionHintFragment-${specificQuestionId}")
.commitAllowingStateLoss()
supportFragmentManager.executePendingTransactions()
}
android 3.0中的getSupportFragmentManager()与getFragmentManager()
“框架的FragmentManager的静态库支持版本.用于编写在Android 3.0之前的平台上运行的应用程序.在Android 3.0或更高版本上运行时,仍然使用此实现;它不会尝试切换到框架的实现.请参阅用于类概述的框架SDK文档.“
那么,我是否需要在运行时进行检查并使用适当的FragmentManager来运行应用程序的Android版本？即如果在android 3.0而不是getSupportFragmentManager()上调用getFragmentManager()
解决方法
Android Fragment – 使用activity的loadermanager而不是Fragment.好吗？
问题：
我有一个寻呼机适配器,当用户离开拿着它的标签时会破坏该片段,并在用户返回该标签时重新创建它.由于这种重新创建,每次都会创建一个新的加载器,并且每次都会加载数据.
题 ：
为了避免每次创建片段时重新创建加载器,是否可以在片段的onActivityCreated方法中使用getActivity.getSupportLoaderManager.initLoader(loaderId,null,false)？
我试过它,测试它,似乎工作正常.但我不相信这是对的.
解决方法
Fragment.getLoaderManager：
/**
* Return the LoaderManager for this fragment,creating it if needed.
*/
public LoaderManager getLoaderManager() {
if (mloaderManager != null) {
return mloaderManager;
}
if (mActivity == null) {
throw new IllegalStateException("Fragment " + this + " not attached to Activity");
}
mCheckedForLoaderManager = true;
mloaderManager = mActivity.getLoaderManager(mWho,mloadeRSStarted,true);
return mloaderManager;
}
mWho基本上是片段ID.
final void setIndex(int index,Fragment parent) {
mIndex = index;
if (parent != null) {
mWho = parent.mWho + ":" + mIndex;
} else {
mWho = "android:fragment:" + mIndex;
}
}
Activity.getLoaderManager()的区别在于谁(root)
所以即使你可以做你想要的,直接从Fragment调用它可能是一个更好的方法
> Activity source code
> Fragment source code
免责声明：我只检查了最新版本的源代码,但我不认为它会有很大不同
Android Fragment 和 FragmentManager 的代码分析
这两天在研究插件化编程，在使用 Fragment 碰到了一些问题，于是查看源码，顺便分析了一下 Fragment 和 FragmentManager 以及其他几个 API 的原代码，看看他们是怎么工作的。
我们知道 Fragment 有个 onCreateView() 方法，这个方法在 Fragment 创建 View 的时候被调用，并且返回一个 View 对象。那么 onCreateView 在什么时候被调用呢，咱们在 Fragment 这个类里找到了一个方法，performCreateView() 方法。
Fragment.java
public View onCreateView(LayoutInflater inflater,@Nullable ViewGroup container,@Nullable Bundle savedInstanceState) {
return null;
}
performCreateView 这个方法在什么时候会被调用呢，在 Fragment 里找不到调用它的代码。咱们可以猜测一下，大概会在 FragmentManager 里。
View performCreateView(LayoutInflater inflater,ViewGroup container,Bundle savedInstanceState) {
if (mChildFragmentManager != null) {
mChildFragmentManager.noteStateNotSaved();
}
return onCreateView(inflater,container,savedInstanceState);
}
在 FragmentManager 里，咱们找到了调用 Fragment.performCreateView 的代码，在 movetoState() 方法里，这个方法有点大，我只粘贴了部分代码。可以看到，它会在 Fragment 初始化或者创建的时候被调用。并且我们知道，创建的View 被赋值给 Fragment 的 mView 成员变量了。
FragmentManager.java
void movetoState(Fragment f,int newState,int transit,int transitionStyle,boolean keepActive) {
switch (f.mState) {
case Fragment.INITIALIZING:
if (f.mFromLayout) {
f.mView = f.performCreateView(f.getLayoutInflater(
f.mSavedFragmentState),null,f.mSavedFragmentState);
}
break;
case Fragment.CREATED:
if (!f.mFromLayout) {
f.mView = f.performCreateView(f.getLayoutInflater(
f.mSavedFragmentState),f.mSavedFragmentState);
}
break;
}
}
接下来，咱们要看什么时候会调用 movetoState() 这个方法。找了一下，发现很 N 多的地方调用了这个方法。这样给咱们逆推找代码造成了一定的难度。于是咱们换个思路，正推来分析。怎么正推了，看咱们怎么使用 Fragment 和 FragmentManager 来分析。
一般咱们都是 getFragmentManager() 或者 getSupportFragmentManager() 的方法来获取 FragmentManager.以 FragmentActivity 为例，一般情况下，咱们在这个类的子类里调用这两个方法之一。
咱们在 FragmentActivity 里找到了相应的代码。FragmentManager 是一个抽象类，FragmentManagerImpl 是 FragmentManager 的子类，在 FragmentManager 同一个 java 文件内，是一个内部类。它是 FragmentManager 的实现。
FragmentActivity.java
//FragmentManagerImpl is subclass of FragmentManager
final FragmentManagerImpl mFragments = new FragmentManagerImpl();
public FragmentManager getSupportFragmentManager() {
return mFragments;
}
获取到 FragmentManager 后，咱们一般就会调用 beginTransaction() 方法，返回一个 FragmentTransaction 。咱们看代码去。
FragmentManager.java
public abstract FragmentTransaction beginTransaction();
FragmentManagerImpl extends FragmentManager
@Override
public FragmentTransaction beginTransaction() {
return new BackStackRecord(this);
}
/**
* Static library support version of the framework's {@link android.app.FragmentTransaction}.
* Used to write apps that run on platforms prior to Android 3.0. When running
* on Android 3.0 or above,this implementation is still used; it does not try
* to switch to the framework's implementation. See the framework SDK
* documentation for a class overview.
*/
public abstract class FragmentTransaction
我们发现 FragmentManager 是一个抽象方法，实现在 FragmentManagerImpl。FragmentManagerImpl.beginTransaction() 返回的是一个BackStackRecord，而 FragmentTransaction 是一个抽象类。那么 BackStackRecord 是个什么鬼。
我们找到了 BackStackRecord 这个类。我们注意到，它继承于 FragmentTransaction，并且实现了 Runable 接口。它的方法有很多，咱们就分析一个咱们比较常用的，比如 add() 方法。
BackStackRecord.java
final class BackStackRecord extends FragmentTransaction implements FragmentManager.BackStackEntry,Runnable
final FragmentManagerImpl mManager;
public BackStackRecord(FragmentManagerImpl manager) {
mManager = manager;
}
add() 方法其实没干啥，咱们一路追下去看。
public FragmentTransaction add(Fragment fragment,String tag) {
doAddOp(0,fragment,tag,OP_ADD);
return this;
}
private void doAddOp(int containerViewId,Fragment fragment,String tag,int opcmd) {
fragment.mFragmentManager = mManager;
if (tag != null) {
if (fragment.mTag != null && !tag.equals(fragment.mTag)) {
throw new IllegalStateException("Can't change tag of fragment "
+ fragment + ": was " + fragment.mTag
+ " Now " + tag);
}
fragment.mTag = tag;
}
if (containerViewId != 0) {
if (fragment.mFragmentId != 0 && fragment.mFragmentId != containerViewId) {
throw new IllegalStateException("Can't change container ID of fragment "
+ fragment + ": was " + fragment.mFragmentId
+ " Now " + containerViewId);
}
fragment.mContainerId = fragment.mFragmentId = containerViewId;
}
Op op = new Op();
op.cmd = opcmd;
op.fragment = fragment;
addOp(op);
}
void addOp(Op op) {
if (mHead == null) {
mHead = mTail = op;
} else {
op.prev = mTail;
mTail.next = op;
mTail = op;
}
op.enteranim = mEnteranim;
op.exitAnim = mExitAnim;
op.popEnteranim = mPopEnteranim;
op.popExitAnim = mPopExitAnim;
mNumOp++;
}
一直追到 addOp() 就断了，好像啥事也没干。不过它大概是在一个 add 操作添加到一个链表上了。那咱们怎么办呢？一般咱们add 完后会 commit 一下，咱们看看 commit 都干了啥。
public int commit() {
return commitInternal(false);
}
int commitInternal(boolean allowStateLoss) {
if (mCommitted) throw new IllegalStateException("commit already called");
mCommitted = true;
if (mAddToBackStack) {
mIndex = mManager.allocBackStackIndex(this);
} else {
mIndex = -1;
}
mManager.enqueueAction(this,allowStateLoss);
return mIndex;
}
commit 好像也没干啥特殊的事情，不过可以看到这么一行代码 mManager.enqueueAction(this,allowStateLoss); 看 enqueueAction 这个方法名，应该会做点事情的。
同样，咱们在 FragmentManagerImpl 里找到了这个方法。
public void enqueueAction(Runnable action,boolean allowStateLoss) {
if (!allowStateLoss) {
checkStateLoss();
}
synchronized (this) {
if (mDestroyed || mActivity == null) {
throw new IllegalStateException("Activity has been destroyed");
}
if (mPendingActions == null) {
mPendingActions = new ArrayList<Runnable>();
}
mPendingActions.add(action);
if (mPendingActions.size() == 1) {
mActivity.mHandler.removeCallbacks(mExecCommit);
mActivity.mHandler.post(mExecCommit);
}
}
}
这个方法把咱们的 BackStackRecord -- 其实是 FragmentTransaction，也是 Runnable -- 添加到一个 mPendingActions 的 ArrayList 里了。然后调用 mActivity.mHandler.post(mExecCommit); mExecCommit 又是什么鬼？
Runnable mExecCommit = new Runnable() {
@Override
public void run() {
execPendingActions();
}
};
mActivity.mHandler.post(mExecCommit); 说明它在主线程里执行了 mExecCommit 的 run 方法。别问我咋知道的。
execPendingActions() 方法稍微比较大，我把注释写在代码里。
public boolean execPendingActions() {
if (mExecutingActions) {
throw new IllegalStateException("Recursive entry to executePendingTransactions");
}
//如果不是在主线程，抛出一个异常。
if (Looper.myLooper() != mActivity.mHandler.getLooper()) {
throw new IllegalStateException("Must be called from main thread of process");
}
boolean didSomething = false;
// 这里有一个 while true 循环。
while (true) {
int numActions;
// 这里在一个同步语句块里，把上次 mPendingActions 里的元素转移到 mTmpActions 数组里。并且执行 run方法。执行谁的 run 方法呢？！就是 BackStackRecord ， 也就是 FragmentTransaction 。我在最后面贴了 BackStackRecord 的 run 方法。
synchronized (this) {
if (mPendingActions == null || mPendingActions.size() == 0) {
break;
}
numActions = mPendingActions.size();
if (mTmpActions == null || mTmpActions.length < numActions) {
mTmpActions = new Runnable[numActions];
}
mPendingActions.toArray(mTmpActions);
mPendingActions.clear();
mActivity.mHandler.removeCallbacks(mExecCommit);
}
mExecutingActions = true;
for (int i=0; i<numActions; i++) {
mTmpActions[i].run();
mTmpActions[i] = null;
}
mExecutingActions = false;
didSomething = true;
}
// 这里有好几行代码，不知道干啥的，反正就是做了一些判断，最后可能会调用 startPendingDeferredFragments() 方法。
if (mHavePendingDeferredStart) {
boolean loadersRunning = false;
for (int i=0; i<mActive.size(); i++) {
Fragment f = mActive.get(i);
if (f != null && f.mloaderManager != null) {
loadersRunning |= f.mloaderManager.hasRunningLoaders();
}
}
if (!loadersRunning) {
mHavePendingDeferredStart = false;
startPendingDeferredFragments();
}
}
return didSomething;
}
startPendingDeferredFragments 方法又是一坨不知道啥意思的代码。最后可能调用了 performPendingDeferredStart()
void startPendingDeferredFragments() {
if (mActive == null) return;
for (int i=0; i<mActive.size(); i++) {
Fragment f = mActive.get(i);
if (f != null) {
performPendingDeferredStart(f);
}
}
}
在 这个方法里，咱们看到了很熟悉的 movetoState() 方法。接着就是上面的分析，Fragment 的 onCreateView 会被调用。
public void performPendingDeferredStart(Fragment f) {
if (f.mDeferStart) {
if (mExecutingActions) {
// Wait until we're done executing our pending transactions
mHavePendingDeferredStart = true;
return;
}
f.mDeferStart = false;
movetoState(f,mCurState,false);
}
}
咱们在回来看 BackStackRecord 的 run 方法。这坨代码有点大，我还是写注释在代码里。
public void run() {
if (FragmentManagerImpl.DEBUG) Log.v(TAG,"Run: " + this);
if (mAddToBackStack) {
if (mIndex < 0) {
throw new IllegalStateException("addToBackStack() called after commit()");
}
}
bumpBackStacknesting(1);
TransitionState state = null;
SparseArray<Fragment> firstOutFragments = null;
SparseArray<Fragment> lastInFragments = null;
if (SUPPORTS_TRANSITIONS) {
firstOutFragments = new SparseArray<Fragment>();
lastInFragments = new SparseArray<Fragment>();
calculateFragments(firstOutFragments,lastInFragments);
state = beginTransition(firstOutFragments,lastInFragments,false);
}
int transitionStyle = state != null ? 0 : mTransitionStyle;
int transition = state != null ? 0 : mTransition;
// 注意这里要开始 while 循环了，要遍历刚才咱们说的链表了。
Op op = mHead;
while (op != null) {
int enteranim = state != null ? 0 : op.enteranim;
int exitAnim = state != null ? 0 : op.exitAnim;
switch (op.cmd) {
// OP_ADD 很简单，mManager.addFragment(f,false); 其他的几个也类似，调用 mManager 相应的方法。
case OP_ADD: {
Fragment f = op.fragment;
f.mNextAnim = enteranim;
mManager.addFragment(f,false);
} break;
case OP_REPLACE: {
Fragment f = op.fragment;
if (mManager.mAdded != null) {
for (int i=0; i<mManager.mAdded.size(); i++) {
Fragment old = mManager.mAdded.get(i);
if (FragmentManagerImpl.DEBUG) Log.v(TAG,"OP_REPLACE: adding=" + f + " old=" + old);
if (f == null || old.mContainerId == f.mContainerId) {
if (old == f) {
op.fragment = f = null;
} else {
if (op.removed == null) {
op.removed = new ArrayList<Fragment>();
}
op.removed.add(old);
old.mNextAnim = exitAnim;
if (mAddToBackStack) {
old.mBackStacknesting += 1;
if (FragmentManagerImpl.DEBUG) Log.v(TAG,"Bump nesting of "
+ old + " to " + old.mBackStacknesting);
}
mManager.removeFragment(old,transition,transitionStyle);
}
}
}
}
if (f != null) {
f.mNextAnim = enteranim;
mManager.addFragment(f,false);
}
} break;
case OP_REMOVE: {
Fragment f = op.fragment;
f.mNextAnim = exitAnim;
mManager.removeFragment(f,transitionStyle);
} break;
case OP_HIDE: {
Fragment f = op.fragment;
f.mNextAnim = exitAnim;
mManager.hideFragment(f,transitionStyle);
} break;
case OP_SHOW: {
Fragment f = op.fragment;
f.mNextAnim = enteranim;
mManager.showFragment(f,transitionStyle);
} break;
case OP_DETACH: {
Fragment f = op.fragment;
f.mNextAnim = exitAnim;
mManager.detachFragment(f,transitionStyle);
} break;
case OP_ATTACH: {
Fragment f = op.fragment;
f.mNextAnim = enteranim;
mManager.attachFragment(f,transitionStyle);
} break;
default: {
throw new IllegalArgumentException("UnkNown cmd: " + op.cmd);
}
}
op = op.next;
}
// 最后还调用了movetoState() 这个方法。跟刚才的区别，看最后一个参数，一个true，一个false。
// 而且注意，这行代码在 while 循环之后。
mManager.movetoState(mManager.mCurState,transitionStyle,true);
if (mAddToBackStack) {
mManager.addBackStackState(this);
}
}
以上所述是小编给大家介绍的Android Fragment 和 FragmentManager 的代码分析，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对编程小技巧网站的支持！
今天关于Android强化——FragmentManger和Fragment和android fragmentmanager的讲解已经结束，谢谢您的阅读，如果想了解更多关于Android 11（仅）FragmentManager崩溃-FragmentManager已被破坏、android 3.0中的getSupportFragmentManager()与getFragmentManager()、Android Fragment – 使用activity的loadermanager而不是Fragment.好吗？、Android Fragment 和 FragmentManager 的代码分析的相关知识，请在本站搜索。
本文标签：
