What's the point of setArguments?

Question

Hi I was looking at the following Fragments example on the android site.

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

I would like to know why certain methods are performed.

Why for instance, in the detailsFragment is the following method performed:

public static DetailsFragment newInstance(int index) {
    DetailsFragment f = new DetailsFragment();

    // Supply index input as an argument.
    Bundle args = new Bundle();
    args.putInt("index", index);
    f.setArguments(args);

    return f;
}

Could you not also simply instantiate the DetailsFragment and use a setter method to set index instead. Bypassing the whole setArguments.

What's the point of using setArguments in the first place? Could you not just use setters and getters?

Answer 1

You can use getters and setters, but by passing in a bundle you don't need to write that code, since it's already there. Also, I believe that these arguments are automatically passed in again if the screen orientation changes, which also makes life easier.

Essentially, setArguments and getArguments is just a design pattern that Google suggests you follow:

Every fragment must have an empty constructor, so it can be instantiated when restoring its activity's state. It is strongly recommended that subclasses do not have other constructors with parameters, since these constructors will not be called when the fragment is re-instantiated; instead, arguments can be supplied by the caller with setArguments(Bundle) and later retrieved by the Fragment with getArguments(). http://developer.android.com/reference/android/app/Fragment.html

I take that to include setters which are needed for your Fragment to operate as well. Then again - there's nothing forcing you to do it this way, and as you know - it's not the only way things could be made to work.

Answer 2

Just to add to Matthew's answer: he quoted correctly that Fragments need to have an empty constructor, so that the framework can re-instantiate them when needed.

It is fine to use getters and setters, but as the framework may destroy and re-create your Fragment, you must ensure to not lose those parameters.

This must be done via Fragment.onSaveInstanceState(). The saved stated will be passed back to you as the parameter savedInstanceState in Fragment.onCreate(), Fragment.onCreateView() and several other methods.

Using Fragment.setArguments() is (in most cases, I assume) easier, at the framework will automatically preserve the arguments and thus will do most of the work for you.

Setters may be the way to go for parameters you supply to the Fragment initially and which the fragment may adjust itself over time. Dealing with the savedInstanceState alone may be easier in this case than dealing with savedInstanceState and arguments - where you have to make a decision which is the valid parameter.

Answer 3

public void setArguments (Bundle args)

Supply the construction arguments for this fragment. This can only be called before the fragment has been attached to its activity; that is, you should call it immediately after constructing the fragment. The arguments supplied here will be retained across fragment destroy and creation (may be the text in bold was missing from official documentation previously)

Fragments.setArguments(Bundle args)

Answer 4

In addition setters can be misused. If updateSomeOtherStuff() will change some view this will crash.

public class MyFragment extends Fragment {
   void setData(someData){
       this.someData = someData;
       updateSomeOtherStuff()
   }
}

If one passing in a bundle it is not possible to misuse the setter and you will always know that this will be set within the lifecycle methods.