Difference between calling the Fragment call and a new instance

Question

I’m working on a college project where I made an app that uses Ragments. I’ve always been used to creating a Fragment as follows:

// imports

...

public class LoginFragment extends Fragment {
    public LoginFragment() {
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_login, container, false);
        return view;
    }
}

However I saw that Android Studio gives an option to create a blank Fragment, with the following code:

// imports 

...

/**
 * A simple {@link Fragment} subclass.
 * Use the {@link BlankFragment#newInstance} factory method to
 * create an instance of this fragment.
 */
public class BlankFragment extends Fragment {
    // TODO: Rename parameter arguments, choose names that match
    // the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
    private static final String ARG_PARAM1 = "param1";
    private static final String ARG_PARAM2 = "param2";

    // TODO: Rename and change types of parameters
    private String mParam1;
    private String mParam2;


    /**
     * Use this factory method to create a new instance of
     * this fragment using the provided parameters.
     *
     * @param param1 Parameter 1.
     * @param param2 Parameter 2.
     * @return A new instance of fragment BlankFragment.
     */
    // TODO: Rename and change types and number of parameters
    public static BlankFragment newInstance(String param1, String param2) {
        BlankFragment fragment = new BlankFragment();
        Bundle args = new Bundle();
        args.putString(ARG_PARAM1, param1);
        args.putString(ARG_PARAM2, param2);
        fragment.setArguments(args);
        return fragment;
    }

    public BlankFragment() {
        // Required empty public constructor
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (getArguments() != null) {
            mParam1 = getArguments().getString(ARG_PARAM1);
            mParam2 = getArguments().getString(ARG_PARAM2);
        }
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        ((FservActivity) getActivity()).getSupportActionBar().setTitle("Chamados");
        return inflater.inflate(R.layout.fragment_blank, container, false);
    }


}

What I’d like to know is: how do I call an instance of Fragment (using newInstance)? What is the practical difference between me calling a new instance and me calling a new instance (new BlankFragment)?

Answer 1

The way to initialize a new fragment with arguments is to save them in a Bundle and pass that Bundle to the fragment via setArguments(Bundle). This way the arguments passed by you will be preserved between destruction and recreations of the fragment by the Android system itself.

In general however you will want to simplify the action of saving arguments in a Bundle and pass it by setArguments() to its fragments. Initially we may think that the way to do this is to encapsulate this behavior in an overloaded constructor version to receive arguments.

However, creating a constructor with arguments is not a viable option because when Android decides to recreate its fragment it has the behavior to call the version without constructor arguments:

Fragment.instantiate(context, MeuFragmento.class.getName(), meuBundle)

With this, the recommended way to simplify the passage of arguments is to encapsulate it within a static method newInstance(argumento1, argumento2, ...).

Done this, instantiating a fragment using newInstance() has no secrets. Instead of doing:

MeuFragmento fragmento = new MeuFragmento(argumento1, argumento2);

...you do it by calling the static method:

MeuFragmento fragmento = MeuFragmento.newInstance(argumento1, argumento2);

As you can see, newInstance(arg1, arg2, ...) is useful only if your fragment takes arguments; if it does not receive any arguments, then there is no need to create a method newInstance() unencumbered.

(Answered with snippets of this question by Soen)