FragmentTransaction

TRANSIT_ENTER_MASK

int TRANSIT_ENTER_MASK

Bit mask that is set for all enter transitions.

Constant Value: 4096 (0x00001000)

TRANSIT_EXIT_MASK

int TRANSIT_EXIT_MASK

Bit mask that is set for all exit transitions.

Constant Value: 8192 (0x00002000)

TRANSIT_FRAGMENT_CLOSE

int TRANSIT_FRAGMENT_CLOSE

Fragment is being removed from the stack

Constant Value: 8194 (0x00002002)

TRANSIT_FRAGMENT_FADE

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.

Constant Value: 4099 (0x00001003)

TRANSIT_FRAGMENT_OPEN

int TRANSIT_FRAGMENT_OPEN

Fragment is being added onto the stack

Constant Value: 4097 (0x00001001)

TRANSIT_NONE

int TRANSIT_NONE

No animation for transition.

Constant Value: 0 (0x00000000)

TRANSIT_UNSET

int TRANSIT_UNSET

Not set up for a transition.

Constant Value: -1 (0xffffffff)

FragmentTransaction

FragmentTransaction ()

add

FragmentTransaction add (Fragment fragment, 
                String tag)

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

add

FragmentTransaction add (int containerViewId, 
                Fragment fragment, 
                String tag)

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.

add

FragmentTransaction add (int containerViewId, 
                Fragment fragment)

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

addSharedElement

FragmentTransaction addSharedElement (View sharedElement, 
                String name)

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.

addToBackStack

FragmentTransaction addToBackStack (String name)

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.

attach

FragmentTransaction attach (Fragment fragment)

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.

commit

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

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.

commitAllowingStateLoss

int commitAllowingStateLoss ()

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

void commitNow ()

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

void commitNowAllowingStateLoss ()

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

FragmentTransaction detach (Fragment fragment)

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.

disallowAddToBackStack

FragmentTransaction disallowAddToBackStack ()

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

FragmentTransaction hide (Fragment fragment)

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.

isAddToBackStackAllowed

boolean isAddToBackStackAllowed ()

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.

isEmpty

boolean isEmpty ()

remove

FragmentTransaction remove (Fragment fragment)

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

replace

FragmentTransaction replace (int containerViewId, 
                Fragment fragment, 
                String tag)

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.

replace

FragmentTransaction replace (int containerViewId, 
                Fragment fragment)

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

runOnCommit

FragmentTransaction runOnCommit (Runnable runnable)

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.

setAllowOptimization

FragmentTransaction setAllowOptimization (boolean allowOptimization)

This method was deprecated in API level 26.1.0.
This has been renamed setReorderingAllowed(boolean).

setBreadCrumbShortTitle

FragmentTransaction setBreadCrumbShortTitle (int res)

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

setBreadCrumbShortTitle

FragmentTransaction setBreadCrumbShortTitle (CharSequence text)

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

FragmentTransaction setBreadCrumbTitle (int res)

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

setBreadCrumbTitle

FragmentTransaction setBreadCrumbTitle (CharSequence text)

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

FragmentTransaction setCustomAnimations (int enter, 
                int exit, 
                int popEnter, 
                int popExit)

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.