FragmentTransaction

Kotlin |Java

abstract class FragmentTransaction

kotlin.Any
↳	androidx.fragment.app.FragmentTransaction

Static library support version of the framework's 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.

Summary

Constants
static Int	TRANSIT_ENTER_MASK Bit mask that is set for all enter transitions.
static Int	TRANSIT_EXIT_MASK Bit mask that is set for all exit transitions.
static Int	TRANSIT_FRAGMENT_CLOSE Fragment is being removed from the stack
static Int	TRANSIT_FRAGMENT_FADE Fragment should simply fade in or out; that is, no strong navigation associated with it except that it is appearing or disappearing for some reason.
static Int	TRANSIT_FRAGMENT_OPEN Fragment is being added onto the stack
static Int	TRANSIT_NONE No animation for transition.
static Int	TRANSIT_UNSET Not set up for a transition.

Public constructors
<init>()

Public methods
FragmentTransaction	add(@NonNull fragmentClass: Class<out Fragment!>, @Nullable args: Bundle?, @Nullable tag: String?) Calls add(int, Class, Bundle, String) with a 0 containerViewId.
open FragmentTransaction	add(@NonNull fragment: Fragment, @Nullable tag: String?) Calls add(int, Fragment, String) with a 0 containerViewId.
FragmentTransaction	add(@IdRes containerViewId: Int, @NonNull fragmentClass: Class<out Fragment!>, @Nullable args: Bundle?) Calls add(int, Class, Bundle, String) with a null tag.
open FragmentTransaction	add(@IdRes containerViewId: Int, @NonNull fragment: Fragment) Calls add(int, Fragment, String) with a null tag.
FragmentTransaction	add(@IdRes containerViewId: Int, @NonNull fragmentClass: Class<out Fragment!>, @Nullable args: Bundle?, @Nullable tag: String?) Add a fragment to the activity state.
open FragmentTransaction	add(@IdRes containerViewId: Int, @NonNull fragment: Fragment, @Nullable tag: String?) Add a fragment to the activity state.
open FragmentTransaction	addSharedElement(@NonNull sharedElement: View, @NonNull name: String) Used with custom Transitions to map a View from a removed or hidden Fragment to a View from a shown or added Fragment.
open FragmentTransaction	addToBackStack(@Nullable name: String?) Add this transaction to the back stack.
open FragmentTransaction	attach(@NonNull fragment: Fragment) Re-attach a fragment after it had previously been detached from the UI with detach(Fragment).
abstract Int	commit() Schedules a commit of this transaction.
abstract Int	commitAllowingStateLoss() Like commit but allows the commit to be executed after an activity's state is saved.
abstract Unit	commitNow() Commits this transaction synchronously.
abstract Unit	commitNowAllowingStateLoss() Like commitNow but allows the commit to be executed after an activity's state is saved.
open FragmentTransaction	detach(@NonNull fragment: Fragment) Detach the given fragment from the UI.
open FragmentTransaction	disallowAddToBackStack() Disallow calls to addToBackStack(String).
open FragmentTransaction	hide(@NonNull fragment: Fragment) Hides an existing fragment.
open Boolean	isAddToBackStackAllowed() Returns true if this FragmentTransaction is allowed to be added to the back stack.
open Boolean	isEmpty()
open FragmentTransaction	remove(@NonNull fragment: Fragment) Remove an existing fragment.
FragmentTransaction	replace(@IdRes containerViewId: Int, @NonNull fragmentClass: Class<out Fragment!>, @Nullable args: Bundle?) Calls replace(int, Class, Bundle, String) with a null tag.
open FragmentTransaction	replace(@IdRes containerViewId: Int, @NonNull fragment: Fragment) Calls replace(int, Fragment, String) with a null tag.
FragmentTransaction	replace(@IdRes containerViewId: Int, @NonNull fragmentClass: Class<out Fragment!>, @Nullable args: Bundle?, @Nullable tag: String?) Replace an existing fragment that was added to a container.
open FragmentTransaction	replace(@IdRes containerViewId: Int, @NonNull fragment: Fragment, @Nullable tag: String?) Replace an existing fragment that was added to a container.
open FragmentTransaction	runOnCommit(@NonNull runnable: Runnable) Add a Runnable to this transaction that will be run after this transaction has been committed.
open FragmentTransaction	setAllowOptimization(allowOptimization: Boolean)
open FragmentTransaction	setBreadCrumbShortTitle(@StringRes res: Int) Set the short title to show as a bread crumb when this transaction is on the back stack.
open FragmentTransaction	setBreadCrumbShortTitle(@Nullable text: CharSequence?) Like setBreadCrumbShortTitle(int) but taking a raw string; this method is not recommended, as the string can not be changed later if the locale changes.
open FragmentTransaction	setBreadCrumbTitle(@StringRes res: Int) Set the full title to show as a bread crumb when this transaction is on the back stack.
open FragmentTransaction	setBreadCrumbTitle(@Nullable text: CharSequence?) Like setBreadCrumbTitle(int) but taking a raw string; this method is not recommended, as the string can not be changed later if the locale changes.
open FragmentTransaction	setCustomAnimations(@AnimatorRes @AnimRes enter: Int, @AnimatorRes @AnimRes exit: Int) Set specific animation resources to run for the fragments that are entering and exiting in this transaction.
open FragmentTransaction	setCustomAnimations(@AnimatorRes @AnimRes enter: Int, @AnimatorRes @AnimRes exit: Int, @AnimatorRes @AnimRes popEnter: Int, @AnimatorRes @AnimRes popExit: Int) Set specific animation resources to run for the fragments that are entering and exiting in this transaction.
open FragmentTransaction	setMaxLifecycle(@NonNull fragment: Fragment, @NonNull state: Lifecycle.State) Set a ceiling for the state of an active fragment in this FragmentManager.
open FragmentTransaction	setPrimaryNavigationFragment(@Nullable fragment: Fragment?) Set a currently active fragment in this FragmentManager as the primary navigation fragment.
open FragmentTransaction	setReorderingAllowed(reorderingAllowed: Boolean) Sets whether or not to allow optimizing operations within and across transactions.
open FragmentTransaction	setTransition(transition: Int) Select a standard transition animation for this transaction.
open FragmentTransaction	setTransitionStyle(@StyleRes styleRes: Int) Set a custom style resource that will be used for resolving transit animations.
open FragmentTransaction	show(@NonNull fragment: Fragment) Shows a previously hidden fragment.

Extension functions

From androidx.fragment.app FragmentTransaction FragmentTransaction.add(@IdRes containerViewId: Int, tag: String? = null, args: Bundle? = null) Add a fragment to the associated FragmentManager, inflating the Fragment's view into the container view specified by containerViewId, to later retrieve via FragmentManager.findFragmentById. FragmentTransaction FragmentTransaction.add(tag: String, args: Bundle? = null) Add a fragment to the associated FragmentManager without adding the Fragment to any container view. FragmentTransaction FragmentTransaction.replace(@IdRes containerViewId: Int, tag: String? = null, args: Bundle? = null) Replace an existing fragment that was added to a container.

Constants

TRANSIT_ENTER_MASK

static val TRANSIT_ENTER_MASK: Int

Bit mask that is set for all enter transitions.

Value: 0x1000

TRANSIT_EXIT_MASK

static val TRANSIT_EXIT_MASK: Int

Bit mask that is set for all exit transitions.

Value: 0x2000

TRANSIT_FRAGMENT_CLOSE

static val TRANSIT_FRAGMENT_CLOSE: Int

Fragment is being removed from the stack

Value: 2 | TRANSIT_EXIT_MASK

TRANSIT_FRAGMENT_FADE

static val TRANSIT_FRAGMENT_FADE: Int

Fragment should simply fade in or out; that is, no strong navigation associated with it except that it is appearing or disappearing for some reason.

Value: 3 | TRANSIT_ENTER_MASK

TRANSIT_FRAGMENT_OPEN

static val TRANSIT_FRAGMENT_OPEN: Int

Fragment is being added onto the stack

Value: 1 | TRANSIT_ENTER_MASK

TRANSIT_NONE

static val TRANSIT_NONE: Int

No animation for transition.

Value: 0

TRANSIT_UNSET

static val TRANSIT_UNSET: Int

Not set up for a transition.

Value: -1

Public constructors

<init>

FragmentTransaction()

Deprecated: You should not instantiate a FragmentTransaction except via FragmentManager#beginTransaction().

Public methods

add

@NonNull fun add(
    @NonNull fragmentClass: Class<out Fragment!>, 
    @Nullable args: Bundle?, 
    @Nullable tag: String?
): FragmentTransaction

Calls add(int, Class, Bundle, String) with a 0 containerViewId.

add

@NonNull open fun add(
    @NonNull fragment: Fragment, 
    @Nullable tag: String?
): FragmentTransaction

Calls add(int, Fragment, String) with a 0 containerViewId.

add

@NonNull fun add(
    @IdRes containerViewId: Int, 
    @NonNull fragmentClass: Class<out Fragment!>, 
    @Nullable args: Bundle?
): FragmentTransaction

Calls add(int, Class, Bundle, String) with a null tag.

add

@NonNull open fun add(
    @IdRes containerViewId: Int, 
    @NonNull fragment: Fragment
): FragmentTransaction

Calls add(int, Fragment, String) with a null tag.

add

@NonNull fun add(
    @IdRes containerViewId: Int, 
    @NonNull fragmentClass: Class<out Fragment!>, 
    @Nullable args: Bundle?, 
    @Nullable tag: String?
): FragmentTransaction

Add a fragment to the activity state. This fragment may optionally also have its view (if Fragment.onCreateView returns non-null) into a container view of the activity.

Parameters
containerViewId	Int: Optional identifier of the container this fragment is to be placed in. If 0, it will not be placed in a container.
fragmentClass	Class<out Fragment!>: The fragment to be added, created via the FragmentManager's FragmentFactory.
args	Bundle?: Optional arguments to be set on the fragment.
tag	String?: Optional tag name for the fragment, to later retrieve the fragment with FragmentManager.findFragmentByTag(String).

Return
FragmentTransaction	Returns the same FragmentTransaction instance.

add

@NonNull open fun add(
    @IdRes containerViewId: Int, 
    @NonNull fragment: Fragment, 
    @Nullable tag: String?
): FragmentTransaction

Add a fragment to the activity state. This fragment may optionally also have its view (if Fragment.onCreateView returns non-null) into a container view of the activity.

Parameters
containerViewId	Int: Optional identifier of the container this fragment is to be placed in. If 0, it will not be placed in a container.
fragment	Fragment: The fragment to be added. This fragment must not already be added to the activity.
tag	String?: Optional tag name for the fragment, to later retrieve the fragment with FragmentManager.findFragmentByTag(String).

Return
FragmentTransaction	Returns the same FragmentTransaction instance.

addSharedElement

@NonNull open fun addSharedElement(
    @NonNull sharedElement: View, 
    @NonNull name: String
): FragmentTransaction

Used with custom Transitions to map a View from a removed or hidden Fragment to a View from a shown or added Fragment. sharedElement must have a unique transitionName in the View hierarchy.

Parameters
sharedElement	View: A View in a disappearing Fragment to match with a View in an appearing Fragment.
name	String: The transitionName for a View in an appearing Fragment to match to the shared element.

See Also

• Fragment#setSharedElementReturnTransition(Object)
• Fragment#setSharedElementEnterTransition(Object)

addToBackStack

@NonNull open fun addToBackStack(@Nullable name: String?): FragmentTransaction

Add this transaction to the back stack. This means that the transaction will be remembered after it is committed, and will reverse its operation when later popped off the stack.

setReorderingAllowed(boolean) must be set to true in the same transaction as addToBackStack() to allow the pop of that transaction to be reordered.

Parameters
name	String?: An optional name for this back stack state, or null.

attach

@NonNull open fun attach(@NonNull fragment: Fragment): FragmentTransaction

Re-attach a fragment after it had previously been detached from the UI with detach(Fragment). This causes its view hierarchy to be re-created, attached to the UI, and displayed.

Parameters
fragment	Fragment: The fragment to be attached.

Return
FragmentTransaction	Returns the same FragmentTransaction instance.

commit

abstract fun commit(): Int

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.

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 commitAllowingStateLoss() for situations where it may be okay to lose the commit.

Return
Int	Returns the identifier of this transaction's back stack entry, if addToBackStack(String) had been called. Otherwise, returns a negative number.

commitAllowingStateLoss

abstract fun commitAllowingStateLoss(): Int

Like 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.

commitNow

abstract fun commitNow(): Unit

Commits this transaction synchronously. Any added fragments will be initialized and brought completely to the lifecycle state of their host and any removed fragments will be torn down accordingly before this call returns. Committing a transaction in this way allows fragments to be added as dedicated, encapsulated components that monitor the lifecycle state of their host while providing firmer ordering guarantees around when those fragments are fully initialized and ready. Fragments that manage views will have those views created and attached.

Calling commitNow is preferable to calling commit() followed by FragmentManager#executePendingTransactions() as the latter will have the side effect of attempting to commit all currently pending transactions whether that is the desired behavior or not.

Transactions committed in this way may not be added to the FragmentManager's back stack, as doing so would break other expected ordering guarantees for other asynchronously committed transactions. This method will throw IllegalStateException if the transaction previously requested to be added to the back stack with addToBackStack(String).

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 commitAllowingStateLoss() for situations where it may be okay to lose the commit.

commitNowAllowingStateLoss

abstract fun commitNowAllowingStateLoss(): Unit

Like commitNow 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.

detach

@NonNull open fun detach(@NonNull fragment: Fragment): FragmentTransaction

Detach the given fragment from the UI. This is the same state as when it is put on the back stack: the fragment is removed from the UI, however its state is still being actively managed by the fragment manager. When going into this state its view hierarchy is destroyed.

Parameters
fragment	Fragment: The fragment to be detached.

Return
FragmentTransaction	Returns the same FragmentTransaction instance.

disallowAddToBackStack

@NonNull open fun disallowAddToBackStack(): FragmentTransaction

Disallow calls to addToBackStack(String). Any future calls to addToBackStack will throw IllegalStateException. If addToBackStack has already been called, this method will throw IllegalStateException.

hide

@NonNull open fun hide(@NonNull fragment: Fragment): FragmentTransaction

Hides an existing fragment. This is only relevant for fragments whose views have been added to a container, as this will cause the view to be hidden.

Parameters
fragment	Fragment: The fragment to be hidden.

Return
FragmentTransaction	Returns the same FragmentTransaction instance.

isAddToBackStackAllowed

open fun isAddToBackStackAllowed(): Boolean

Returns true if this FragmentTransaction is allowed to be added to the back stack. If this method would return false, addToBackStack(String) will throw IllegalStateException.

Return
Boolean	True if addToBackStack(String) is permitted on this transaction.

isEmpty

open fun isEmpty(): Boolean

Return
Boolean	true if this transaction contains no operations, false otherwise.

remove

@NonNull open fun remove(@NonNull fragment: Fragment): FragmentTransaction

Remove an existing fragment. If it was added to a container, its view is also removed from that container.

Parameters
fragment	Fragment: The fragment to be removed.

Return
FragmentTransaction	Returns the same FragmentTransaction instance.

replace

@NonNull fun replace(
    @IdRes containerViewId: Int, 
    @NonNull fragmentClass: Class<out Fragment!>, 
    @Nullable args: Bundle?
): FragmentTransaction

Calls replace(int, Class, Bundle, String) with a null tag.

replace

@NonNull open fun replace(
    @IdRes containerViewId: Int, 
    @NonNull fragment: Fragment
): FragmentTransaction

Calls replace(int, Fragment, String) with a null tag.

replace

@NonNull fun replace(
    @IdRes containerViewId: Int, 
    @NonNull fragmentClass: Class<out Fragment!>, 
    @Nullable args: Bundle?, 
    @Nullable tag: String?
): FragmentTransaction

Replace an existing fragment that was added to a container. This is essentially the same as calling remove(Fragment) for all currently added fragments that were added with the same containerViewId and then add(int, Fragment, String) with the same arguments given here.

Parameters
containerViewId	Int: Identifier of the container whose fragment(s) are to be replaced.
fragmentClass	Class<out Fragment!>: The new fragment to place in the container, created via the FragmentManager's FragmentFactory.
args	Bundle?: Optional arguments to be set on the fragment.
tag	String?: Optional tag name for the fragment, to later retrieve the fragment with FragmentManager.findFragmentByTag(String).

Return
FragmentTransaction	Returns the same FragmentTransaction instance.

replace

@NonNull open fun replace(
    @IdRes containerViewId: Int, 
    @NonNull fragment: Fragment, 
    @Nullable tag: String?
): FragmentTransaction

Replace an existing fragment that was added to a container. This is essentially the same as calling remove(Fragment) for all currently added fragments that were added with the same containerViewId and then add(int, Fragment, String) with the same arguments given here.

Parameters
containerViewId	Int: Identifier of the container whose fragment(s) are to be replaced.
fragment	Fragment: The new fragment to place in the container.
tag	String?: Optional tag name for the fragment, to later retrieve the fragment with FragmentManager.findFragmentByTag(String).

Return
FragmentTransaction	Returns the same FragmentTransaction instance.

runOnCommit

@NonNull open fun runOnCommit(@NonNull runnable: Runnable): FragmentTransaction

Add a Runnable to this transaction that will be run after this transaction has been committed. If fragment transactions are optimized this may be after other subsequent fragment operations have also taken place, or operations in this transaction may have been optimized out due to the presence of a subsequent fragment transaction in the batch.

If a transaction is committed using commitAllowingStateLoss() this runnable may be executed when the FragmentManager is in a state where new transactions may not be committed without allowing state loss.

runOnCommit may not be used with transactions added to the back stack as Runnables cannot be persisted with back stack state. IllegalStateException will be thrown if addToBackStack(String) has been previously called for this transaction or if it is called after a call to runOnCommit.

Parameters
runnable	Runnable: Runnable to add

Return
FragmentTransaction	this FragmentTransaction

Exceptions
IllegalStateException	if addToBackStack(String) has been called

setAllowOptimization

@NonNull open fun setAllowOptimization(allowOptimization: Boolean): FragmentTransaction

Deprecated: This has been renamed setReorderingAllowed(boolean).

setBreadCrumbShortTitle

@NonNull open fun setBreadCrumbShortTitle(@StringRes res: Int): FragmentTransaction

Deprecated: Store breadcrumb short titles separately from fragment transactions. For example, by using an android:label on a fragment in a navigation graph.

Set the short title to show as a bread crumb when this transaction is on the back stack.

Parameters
res	Int: A string resource containing the title.

setBreadCrumbShortTitle

@NonNull open fun setBreadCrumbShortTitle(@Nullable text: CharSequence?): FragmentTransaction

Deprecated: Store breadcrumb short titles separately from fragment transactions. For example, by using an android:label on a fragment in a navigation graph.

Like setBreadCrumbShortTitle(int) but taking a raw string; this method is not recommended, as the string can not be changed later if the locale changes.

setBreadCrumbTitle

@NonNull open fun setBreadCrumbTitle(@StringRes res: Int): FragmentTransaction

Deprecated: Store breadcrumb titles separately from fragment transactions. For example, by using an android:label on a fragment in a navigation graph.

Set the full title to show as a bread crumb when this transaction is on the back stack.

Parameters
res	Int: A string resource containing the title.

setBreadCrumbTitle

@NonNull open fun setBreadCrumbTitle(@Nullable text: CharSequence?): FragmentTransaction

Deprecated: Store breadcrumb titles separately from fragment transactions. For example, by using an android:label on a fragment in a navigation graph.

Like setBreadCrumbTitle(int) but taking a raw string; this method is not recommended, as the string can not be changed later if the locale changes.

setCustomAnimations

@NonNull open fun setCustomAnimations(
    @AnimatorRes @AnimRes enter: Int, 
    @AnimatorRes @AnimRes exit: Int
): FragmentTransaction

Set specific animation resources to run for the fragments that are entering and exiting in this transaction. These animations will not be played when popping the back stack.

This method applies the custom animations to all future fragment operations; previous operations are unaffected. Fragment operations in the same FragmentTransaction can set different animations by calling this method prior to each operation, e.g:

fragmentManager.beingTransaction()
           .setCustomAnimations(enter1, exit1)
           .add(MyFragmentClass, args, tag1) // this fragment gets the first animations
           .setCustomAnimations(enter2, exit2)
           .add(MyFragmentClass, args, tag2) // this fragment gets the second animations
           .commit()
      

Parameters
enter	Int: An animation or animator resource ID used for the enter animation on the view of the fragment being added or attached.
exit	Int: An animation or animator resource ID used for the exit animation on the view of the fragment being removed or detached.

setCustomAnimations

@NonNull open fun setCustomAnimations(
    @AnimatorRes @AnimRes enter: Int, 
    @AnimatorRes @AnimRes exit: Int, 
    @AnimatorRes @AnimRes popEnter: Int, 
    @AnimatorRes @AnimRes popExit: Int
): FragmentTransaction

Set specific animation resources to run for the fragments that are entering and exiting in this transaction. The popEnter and popExit animations will be played for enter/exit operations specifically when popping the back stack.

This method applies the custom animations to all future fragment operations; previous operations are unaffected. Fragment operations in the same FragmentTransaction can set different animations by calling this method prior to each operation, e.g:

fragmentManager.beingTransaction()
           .setCustomAnimations(enter1, exit1, popEnter1, popExit1)
           .add(MyFragmentClass, args, tag1) // this fragment gets the first animations
           .setCustomAnimations(enter2, exit2, popEnter2, popExit2)
           .add(MyFragmentClass, args, tag2) // this fragment gets the second animations
           .commit()
      

Parameters
enter	Int: An animation or animator resource ID used for the enter animation on the view of the fragment being added or attached.
exit	Int: An animation or animator resource ID used for the exit animation on the view of the fragment being removed or detached.
popEnter	Int: An animation or animator resource ID used for the enter animation on the view of the fragment being readded or reattached caused by FragmentManager#popBackStack() or similar methods.
popExit	Int: An animation or animator resource ID used for the enter animation on the view of the fragment being removed or detached caused by FragmentManager#popBackStack() or similar methods.

setMaxLifecycle

@NonNull open fun setMaxLifecycle(
    @NonNull fragment: Fragment, 
    @NonNull state: Lifecycle.State
): FragmentTransaction

Set a ceiling for the state of an active fragment in this FragmentManager. If fragment is already above the received state, it will be forced down to the correct state.

The fragment provided must currently be added to the FragmentManager to have it's Lifecycle state capped, or previously added as part of this transaction. The Lifecycle.State passed in must at least be Lifecycle.State#CREATED, otherwise an IllegalArgumentException will be thrown.

Parameters
fragment	Fragment: the fragment to have it's state capped.
state	Lifecycle.State: the ceiling state for the fragment.

Return
FragmentTransaction	the same FragmentTransaction instance

setPrimaryNavigationFragment

@NonNull open fun setPrimaryNavigationFragment(@Nullable fragment: Fragment?): FragmentTransaction

Set a currently active fragment in this FragmentManager as the primary navigation fragment.

The primary navigation fragment's child FragmentManager will be called first to process delegated navigation actions such as FragmentManager#popBackStack() if no ID or transaction name is provided to pop to. Navigation operations outside of the fragment system may choose to delegate those actions to the primary navigation fragment as returned by FragmentManager#getPrimaryNavigationFragment().

The fragment provided must currently be added to the FragmentManager to be set as a primary navigation fragment, or previously added as part of this transaction.

Parameters
fragment	Fragment?: the fragment to set as the primary navigation fragment

Return
FragmentTransaction	the same FragmentTransaction instance

setReorderingAllowed

@NonNull open fun setReorderingAllowed(reorderingAllowed: Boolean): FragmentTransaction

Sets whether or not to allow optimizing operations within and across transactions. This will remove redundant operations, eliminating operations that cancel. For example, if two transactions are executed together, one that adds a fragment A and the next replaces it with fragment B, the operations will cancel and only fragment B will be added. That means that fragment A may not go through the creation/destruction lifecycle.

The side effect of removing redundant operations is that fragments may have state changes out of the expected order. For example, one transaction adds fragment A, a second adds fragment B, then a third removes fragment A. Without removing the redundant operations, fragment B could expect that while it is being created, fragment A will also exist because fragment A will be removed after fragment B was added. With removing redundant operations, fragment B cannot expect fragment A to exist when it has been created because fragment A's add/remove will be optimized out.

It can also reorder the state changes of Fragments to allow for better Transitions. Added Fragments may have Fragment#onCreate(Bundle) called before replaced Fragments have Fragment#onDestroy() called.

Fragment#postponeEnterTransition() requires setReorderingAllowed(true).

The default is false.

Parameters
reorderingAllowed	Boolean: true to enable optimizing out redundant operations or false to disable optimizing out redundant operations on this transaction.

setTransition

@NonNull open fun setTransition(transition: Int): FragmentTransaction

Select a standard transition animation for this transaction. May be one of TRANSIT_NONE, TRANSIT_FRAGMENT_OPEN, TRANSIT_FRAGMENT_CLOSE, or TRANSIT_FRAGMENT_FADE.

setTransitionStyle

@NonNull open fun setTransitionStyle(@StyleRes styleRes: Int): FragmentTransaction

Deprecated: The desired functionality never worked correctly. This should not be used.

Set a custom style resource that will be used for resolving transit animations.

show

@NonNull open fun show(@NonNull fragment: Fragment): FragmentTransaction

Shows a previously hidden fragment. This is only relevant for fragments whose views have been added to a container, as this will cause the view to be shown.

Parameters
fragment	Fragment: The fragment to be shown.

Return
FragmentTransaction	Returns the same FragmentTransaction instance.