FragmentTransaction 中的 Commit 方法
- commit():int
- commitAllowingStateLoss():int
- commitNow():void
- commitNowAllowingStateLoss():void
commit 方法
文档注释：
* Schedules a commit of this transaction. The commit does
* not happen immediately; it will be scheduled as work on the main thread
* to be done the next time that thread is ready.
*
* <p class="note">A transaction can only be committed with this method
* prior to(prior to 前于) its containing activity saving its state. If the commit is
* attempted after that point, an exception will be thrown. This is
* because the state after the commit can be lost if the activity needs to
* be restored from its state. See {@link #commitAllowingStateLoss()} for
* situations where it may be okay to lose the commit.</p>
*
* @return Returns the identifier(标识符) of this transaction's back stack entry,
* if {@link #addToBackStack(String)} had been called. Otherwise, returns
* a negative number.
从文档中我们知道：
commit 方法并非一个立即执行的方法，他需要等待线程准备好了再执行（如果需要立即执行则调用executePendingTransactions()）。
commit 方法必须要在 fragment 的容器 Activity 执行 onSavaInstance() 方法之前执行（onSaveInstanceState() 方法在 onStop() 方法之前执行，确保 Activity 因为各种原因被系统杀掉后能正确的保存和恢复状态，onSaveInstanceState() 方法 和 onPause() 方法之间没有必然的执行先后顺序），否则会抛出异常（IllegalStateException("Can not perform this action after onSaveInstanceState")）。因为在 Activity 执行了 onSaveInstanceState() 方法之后再执行 commit 方法的话，Fragment 的状态就丢失了，在官方看来这是很危险的，如果我们不在乎 Fragment 的状态的话，官方推荐使用 commitAllowingStateLoss() 方法。
使用注意事项和源代码解析
- 在 Activity 中调用 commit() 方法的时候，应该注意在 onCreate() 或者是在 FragmentActivity#onResume()/Activity#onPostResume() 中调用。后者是保证 Activity 的状态已经完全恢复，避免出现 IllegalStateException.
- 避免在异步任务中调用 commit，因为异步任务不能确保Activity的状态，如果 Activity 已经调用 onStop() 方法，此时再 Commit() 就会报错。
- 如果不在乎 Fragment 状态丢失，可以使用 commitAllowingStateLoss() 方法。
- 同一个 transaction 中只能调用一次 commit()
源码解析
查看源码，可以看到 commit 方法调用的是 commitInternal(boolean allowStateLoss):int 方法
@Override
public int commit() {
return commitInternal(false);
}
查看 commitInternal(boolean allowStateLoss):int 方法
int commitInternal(boolean allowStateLoss) {
// 首先会检查是否已经进行过 commit，所以 Commit 方法只能在同一个 transaction 中调用一次
if (mCommitted) throw new IllegalStateException("commit already called");
if (FragmentManagerImpl.DEBUG) {
Log.v(TAG, "Commit: " + this);
LogWriter logw = new LogWriter(TAG);
PrintWriter pw = new PrintWriter(logw);
dump(" ", null, pw, null);
pw.close();
}
mCommitted = true;
if (mAddToBackStack) {
mIndex = mManager.allocBackStackIndex(this);
} else {
mIndex = -1;
}
mManager.enqueueAction(this, allowStateLoss);
// 证实了注释中说的，如果没有加入返回栈那么返回一个负数
return mIndex;
}
继续进入 enqueueAction 方法，我们看到了 checkStateLoss() 方法。
public void enqueueAction(OpGenerator action, boolean allowStateLoss) {
// 如果我们没有忽略状态，那么会检查当前状态
if (!allowStateLoss) {
checkStateLoss();
}
synchronized (this) {
if (mDestroyed || mHost == null) {
if (allowStateLoss) {
// This FragmentManager isn't attached, so drop the entire transaction.
return;
}
throw new IllegalStateException("Activity has been destroyed");
}
if (mPendingActions == null) {
mPendingActions = new ArrayList<>();
}
mPendingActions.add(action);
scheduleCommit();
}
}
checkStateLoss() 中进行了状态判定，并且抛出了异常。
private void checkStateLoss() {
if (isStateSaved()) {
throw new IllegalStateException(
"Can not perform this action after onSaveInstanceState");
}
if (mNoTransactionsBecause != null) {
throw new IllegalStateException(
"Can not perform this action inside of " + mNoTransactionsBecause);
}
}
@Override
public boolean isStateSaved() {
// See saveAllState() for the explanation of this. We do this for
// all platform versions, to keep our behavior more consistent between
// them.
return mStateSaved || mStopped;
}
由此，我们明白了 Commit 可能产生的两个异常是如何发生的，以及如何避免这样的异常。
commitAllowingStateLoss 方法
从文档注释中我们可以看出，官方并不推荐我们使用这个可能丢失状态的方法。
/**
* Like {@link #commit} but allows the commit to be executed after an
* activity's state is saved. This is dangerous because the commit can
* be lost if the activity needs to later be restored from its state, so
* this should only be used for cases where it is okay for the UI state
* to change unexpectedly on the user.
*/
源码：和 commit() 方法调用的是同一个方法，但是设置了可忽略状态。从 commit() 方法的流程中我们可以看出，使用 commitAllowingStateLoss()确实可以避免发生状态丢失的异常，但是我们在使用的时候，还是应该尽量少使用这个方法，而是正确、安全的使用 commit()，使问题能够得到正确的解决。
@Override
public int commitAllowingStateLoss() {
return commitInternal(true);
}
commitNow##
注释：
* <p>Calling <code>commitNow</code> is preferable to calling
* {@link #commit()} followed by {@link FragmentManager#executePendingTransactions()}
* ...
* * This method will throw {@link IllegalStateException} if the transaction
* previously requested to be added to the back stack with
* {@link #addToBackStack(String)}.</p>
* ...
* <p class="note">A transaction can only be committed with this method
* prior to its containing activity saving its state. If the commit is
* attempted after that point, an exception will be thrown. This is
* because the state after the commit can be lost if the activity needs to
* be restored from its state. See {@link #commitAllowingStateLoss()} for
* situations where it may be okay to lose the commit.</p>
*/
从注释中，我们知道，commitNow()方法是立即执行，而不是等待 Activity 的 Handler 准备好了。commitNow()方法产生的 Fragment 不能添加到回退栈。和 commit() 方法 一样，会检查 Activity 的状态。
源码解读：
@Override
public void commitNow() {
// 禁止添加到回退栈
disallowAddToBackStack();
mManager.execSingleAction(this, false);
}
@Override
public FragmentTransaction disallowAddToBackStack() {
if (mAddToBackStack) {
throw new IllegalStateException(
"This transaction is already being added to the back stack");
}
mAllowAddToBackStack = false;
return this;
}
CommitNowAllowingStateLoss
除了不检查 Activity 的状态以外，其他方面和 CommitNow一样
@Override
public void commitNowAllowingStateLoss() {
disallowAddToBackStack();
mManager.execSingleAction(this, true);
}
