Difference between calling the fragment call and a new instance

Question

Difference between calling the fragment call and a new instance

Navigation

#1 by (4 votes)

4

I'm working on a college project where I made an application that uses fragments. I've always been accustomed to creating a fragment in the following way:

// 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;
    }
}

But I saw that Android Studio gives you 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 would like to know is: how do I call an instance of fragment (using newInstance )? What is the practical difference between calling a new instance and calling a new fragment ( new BlankFragment )?

java android android-fragment

asked by anonymous 17.11.2014 / 19:22

1 answer

IDE in Cloud for C # ASP.NET development Different layout on another device

score 4 · Accepted Answer

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 destructions and re-creations of the fragment by the Android system itself.

In general, however, you will want to simplify the action of saving arguments to a Bundle and passing it via 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 constructor-free version:

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

This way, the recommended way to simplify passing arguments is to encapsulate it within a static newInstance(argumento1, argumento2, ...) method.

Once this is done, the instantiation of a fragment using newInstance() has no secrets. Instead of doing:

MeuFragmento fragmento = new MeuFragmento(argumento1, argumento2);

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

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

As you can see, newInstance(arg1, arg2, ...) is useful only if your snippet receives arguments; if it does not get any arguments, then there is no need to create a newInstance() method with no arguments.

(Respond with excerpts from this SOen question )