What is the meaning of addToBackStack with null parameter?

I have a customer code. There is only one activity for all of the fragments i.e. the single activity is managing all the fragments.

This activity contains the following code for any fragment at the method end of that fragment-

For example - fragment MoreFragment:

MoreFragment firstFragment = new MoreFragment();
getSupportFragmentManager().beginTransaction()
.replace(R.id.article_fragment, firstFragment)
.addToBackStack(null).commit();

So,

1. What is the meaning of addToBackStack(null) followed by a commit() ?

2. Why you need to pass a null parameter to addToBackStack ?

3. How to get that fragment after being added like this ?

Seems like this code is useless as I ran the code without the last line .addToBackStack(null).commit() and it ran without any problems.

> What is the meaning of addToBackStack(null) followed by a commit()?

Quoting docs:

> By calling addToBackStack(), the replace transaction is saved to the > back stack so the user can reverse the transaction and bring back the > previous fragment by pressing the Back button. > > If you add multiple changes to the transaction (such as another add() > or remove()) and call addToBackStack(), then all changes applied > before you call commit() are added to the back stack as a single > transaction and the Back button will reverse them all together.

The order in which you add changes to a FragmentTransaction doesn't matter, except:

You must call commit() last. If you're adding multiple fragments to the same container, then the order in which you add them determines the order they appear in the view hierarchy.

So you have to commit at the last.

> Why you need to pass a null parameter to addToBackStack?

It don't need to be null, it can be a string. If you don't want, just pass null.

>public abstract FragmentTransaction addToBackStack (String name) >
> Added in API level 11 > 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.

> Parameters > name An optional name for this back stack state, or null.

Concerning: > Seems like this code is useless as I ran the code without the last > line .addToBackStack(null).commit() and it ran without any problems

If you want to navigate to previous fragment add it to backstack. So it depends on whether you want to add the fragment to the backstack.

> How to get that fragment after being added like this?

You already have the fragment instance firstFragment. So I don't know what you mean by get the fragment later.

More information @

http://developer.android.com/guide/components/fragments.html

http://developer.android.com/reference/android/app/FragmentTransaction.html#addToBackStack(java.lang.String)

The tag string in addToBackStack(String name) gives a way to locate the back stack for later pop directly to that location. It meant to be used in the method popToBackStack(String name, int flags):

> Pop the last fragment transition from the manager's fragment back stack. This function is asynchronous -- it enqueues the request to pop, but the action will not be performed until the application returns to its event loop.

> name: If non-null, this is the name of a previous back state to look for; if found, all states up to that state will be popped. The POP_BACK_STACK_INCLUSIVE flag can be used to control whether the named state itself is popped. If null, only the top state is popped.

> flags: Either 0 or POP_BACK_STACK_INCLUSIVE.

In other words, it will pop your back stack until it finds the fragment that was added by the name in addToBackStack(String name).

For example, if you do a series of additions or replaces to the fragment manager giving the names "frag1", "frag2", "frag3", "frag4" and later want to go back directly to the fragment 2 added with addToBackStack("frag2"), you call popToBackStack("frag2", 0).

So,

• Use .addToBackStack("fragName"): if you want later popToBackStack(String name, int flags) to pop more than one back stack.

• Use .addToBackStack(null): If you don't want later pop more than one back stack, but still want to pop one at a time. Do this even if you won't explicitly call popToBackStack() but instead will let the back press default implementation handle the back stack.

• Use .disallowAddToBackStack(): If you don't want either the back press or call popBackStack() it explicitly. It will make sure no part of the code is using .addToBackStack().

Your answers are deprecated. If you don't want to add fragments to back stack, you should use below snippet of code:

    public static void replaceFragment (@NonNull FragmentManager fragmentManager,
            @NonNull Fragment fragment, int frameId){

        checkNotNull(fragmentManager);
        checkNotNull(fragment);
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.replace(frameId, fragment);
        transaction.disallowAddToBackStack(); // <-- This makes magic!
        transaction.commit();
    }

Below you have cute example of how use it:

GameFragment fragment = GameFragment.newInstance(mGameObject, currentQuestion);
ActivityUtils.replaceFragment(getFragmentManager(), fragment, R.id.main);