Meilleure pratique pour instancier un nouveau fragment Android

J'ai vu deux pratiques générales pour instancier un nouveau fragment dans une application:

Fragment newFragment = new MyFragment();

et

Fragment newFragment = MyFragment.newInstance();

La deuxième option utilise une méthode statique newInstance()et contient généralement la méthode suivante.

public static Fragment newInstance() 
{
    MyFragment myFragment = new MyFragment();
    return myFragment;
}

Au début, je pensais que le principal avantage était le fait que je pouvais surcharger la méthode newInstance () pour donner de la flexibilité lors de la création de nouvelles instances d'un fragment - mais je pouvais également le faire en créant un constructeur surchargé pour le fragment.

Ai-je oublié quelque chose?

Quels sont les avantages d'une approche par rapport à l'autre? Ou s'agit-il simplement d'une bonne pratique?

Si Android décide de recréer votre fragment plus tard, il appellera le constructeur sans argument de votre fragment. Surcharger le constructeur n'est donc pas une solution.

Cela étant dit, la façon de transmettre des éléments à votre fragment afin qu'ils soient disponibles après la recréation d'un fragment par Android est de passer un bundle à la setArgumentsméthode.

Ainsi, par exemple, si nous voulions passer un entier au fragment, nous utiliserions quelque chose comme:

public static MyFragment newInstance(int someInt) {
    MyFragment myFragment = new MyFragment();

    Bundle args = new Bundle();
    args.putInt("someInt", someInt);
    myFragment.setArguments(args);

    return myFragment;
}

Et plus tard dans le fragment, onCreate()vous pouvez accéder à cet entier en utilisant:

getArguments().getInt("someInt", 0);

Ce bundle sera disponible même si le fragment est en quelque sorte recréé par Android.

Notez également: setArgumentsne peut être appelé que lorsque le fragment est attaché à l'activité.

Cette approche est également documentée dans la référence du développeur Android: https://developer.android.com/reference/android/app/Fragment.html

Le seul avantage à utiliser le newInstance()que je vois sont les suivants:

1. Vous aurez un seul endroit où tous les arguments utilisés par le fragment pourraient être regroupés et vous n'avez pas à écrire le code ci-dessous chaque fois que vous instanciez un fragment.

   Bundle args = new Bundle();
   args.putInt("someInt", someInt);
   args.putString("someString", someString);
   // Put any other arguments
   myFragment.setArguments(args);

2. C'est un bon moyen de dire aux autres classes quels arguments il attend pour fonctionner fidèlement (bien que vous devriez être capable de gérer les cas si aucun argument n'est groupé dans l'instance de fragment).

Donc, mon avis est que l'utilisation d'une statique newInstance()pour instancier un fragment est une bonne pratique.

Il existe également un autre moyen:

Fragment.instantiate(context, MyFragment.class.getName(), myBundle)

Alors que @yydl donne une raison convaincante pour laquelle la newInstanceméthode est meilleure:

Si Android décide de recréer votre fragment plus tard, il appellera le constructeur sans argument de votre fragment. Surcharger le constructeur n'est donc pas une solution.

il est tout à fait possible d'utiliser un constructeur . Pour voir pourquoi cela est, nous devons d'abord voir pourquoi la solution de contournement ci-dessus est utilisée par Android.

Avant qu'un fragment puisse être utilisé, une instance est nécessaire. Android appelle YourFragment()(le constructeur sans arguments ) pour construire une instance du fragment. Ici, tout constructeur surchargé que vous écrivez sera ignoré, car Android ne peut pas savoir lequel utiliser.

Pendant la durée de vie d'une activité, le fragment est créé comme ci-dessus et détruit plusieurs fois par Android. Cela signifie que si vous placez des données dans l'objet fragment lui-même, elles seront perdues une fois le fragment détruit.

Pour contourner ce problème, Android vous demande de stocker les données à l'aide d'un Bundle(appel setArguments()), auquel vous pourrez ensuite accéder YourFragment. Les arguments bundlesont protégés par Android et sont donc garantis persistants .

Une façon de définir cet ensemble consiste à utiliser une newInstanceméthode statique :

public static YourFragment newInstance (int data) {
    YourFragment yf = new YourFragment()
    /* See this code gets executed immediately on your object construction */
    Bundle args = new Bundle();
    args.putInt("data", data);
    yf.setArguments(args);
    return yf;
}

Cependant, un constructeur:

public YourFragment(int data) {
    Bundle args = new Bundle();
    args.putInt("data", data);
    setArguments(args);
}

peut faire exactement la même chose que la newInstanceméthode.

Naturellement, cela échouerait et c'est l'une des raisons pour lesquelles Android souhaite que vous utilisiez la newInstanceméthode:

public YourFragment(int data) {
    this.data = data; // Don't do this
}

Pour plus d'explications, voici la classe de fragments d'Android:

/**
 * 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.
 */
public void setArguments(Bundle args) {
    if (mIndex >= 0) {
        throw new IllegalStateException("Fragment already active");
    }
    mArguments = args;
}

Notez qu'Android demande que les arguments ne soient définis qu'à la construction et garantit qu'ils seront conservés.

EDIT : Comme indiqué dans les commentaires de @JHH, si vous fournissez un constructeur personnalisé qui nécessite des arguments, alors Java ne fournira pas votre fragment avec un constructeur par défaut sans argument . Donc, cela vous obligerait à définir un constructeur sans argument , qui est du code que vous pourriez éviter avec la newInstanceméthode d'usine.

EDIT : Android ne permet plus d'utiliser un constructeur surchargé pour les fragments. Vous devez utiliser la newInstanceméthode.

Je ne suis pas d' accord avec la réponse de yydi disant:

Si Android décide de recréer votre fragment plus tard, il appellera le constructeur sans argument de votre fragment. Surcharger le constructeur n'est donc pas une solution.

Je pense que c'est une solution et une bonne, c'est exactement la raison pour laquelle elle a été développée par le langage Java Core.

Il est vrai que le système Android peut détruire et recréer votre Fragment. Vous pouvez donc faire ceci:

public MyFragment() {
//  An empty constructor for Android System to use, otherwise exception may occur.
}

public MyFragment(int someInt) {
    Bundle args = new Bundle();
    args.putInt("someInt", someInt);
    setArguments(args);
}

Il vous permettra de tirer someIntde getArguments()ce dernier, même s'il a Fragmentété recréé par le système. C'est une solution plus élégante que le staticconstructeur.

Pour moi, les staticconstructeurs sont inutiles et ne doivent pas être utilisés. De plus, ils vous limiteront si à l'avenir vous souhaitez étendre cela Fragmentet ajouter plus de fonctionnalités au constructeur. Avec le staticconstructeur, vous ne pouvez pas faire cela.

Mise à jour:

Android a ajouté une inspection qui marque tous les constructeurs non par défaut avec une erreur.
Je recommande de le désactiver, pour les raisons mentionnées ci-dessus.

Certains Kotlin code:

companion object {
    fun newInstance(first: String, second: String) : SampleFragment {
        return SampleFragment().apply {
            arguments = Bundle().apply {
                putString("firstString", first)
                putString("secondString", second)
            }
        }
    }
}

Et vous pouvez obtenir des arguments avec ceci:

val first: String by lazy { arguments?.getString("firstString") ?: "default"}
val second: String by lazy { arguments?.getString("secondString") ?: "default"}

La meilleure pratique pour instance de fragments avec des arguments dans Android est d'avoir une méthode d'usine statique dans votre fragment.

public static MyFragment newInstance(String name, int age) {
    Bundle bundle = new Bundle();
    bundle.putString("name", name);
    bundle.putInt("age", age);

    MyFragment fragment = new MyFragment();
    fragment.setArguments(bundle);

    return fragment;
}

Vous devez éviter de définir vos champs avec l'instance d'un fragment. Parce que chaque fois que le système Android recrée votre fragment, s'il estime que le système a besoin de plus de mémoire, il recréera votre fragment en utilisant un constructeur sans arguments.

Vous pouvez trouver plus d'informations sur les meilleures pratiques pour instancier des fragments avec des arguments ici.

Étant donné que les questions sur les meilleures pratiques, j'ajouterais, cette très bonne idée d'utiliser une approche hybride pour créer des fragments lorsque vous travaillez avec certains services Web REST

Nous ne pouvons pas passer des objets complexes, par exemple certains modèles utilisateur, pour le cas de l'affichage d'un fragment utilisateur

Mais ce que nous pouvons faire, c'est archiver onCreatecet utilisateur! = Null et sinon - l'amener de la couche de données, sinon - utiliser l'existant.

De cette façon, nous gagnons à la fois la capacité de recréer par userId en cas de recréation de fragments par Android et l'accrochage pour les actions de l'utilisateur, ainsi que la capacité de créer des fragments en se tenant à l'objet lui-même ou uniquement son identifiant

Quelque chose aime ça:

public class UserFragment extends Fragment {
    public final static String USER_ID="user_id";
    private User user;
    private long userId;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        userId = getArguments().getLong(USER_ID);
        if(user==null){
            //
            // Recreating here user from user id(i.e requesting from your data model,
            // which could be services, direct request to rest, or data layer sitting
            // on application model
            //
             user = bringUser();
        }
    }

    public static UserFragment newInstance(User user, long user_id){
        UserFragment userFragment = new UserFragment();
        Bundle args = new Bundle();
        args.putLong(USER_ID,user_id);
        if(user!=null){
            userFragment.user=user;
        }
        userFragment.setArguments(args);
        return userFragment;

    }

    public static UserFragment newInstance(long user_id){
        return newInstance(null,user_id);
    }

    public static UserFragment newInstance(User user){
        return newInstance(user,user.id);
    }
}

utiliser ce code 100% résoudre votre problème

entrez ce code dans firstFragment

public static yourNameParentFragment newInstance() {

    Bundle args = new Bundle();
    args.putBoolean("yourKey",yourValue);
    YourFragment fragment = new YourFragment();
    fragment.setArguments(args);
    return fragment;
}

cet échantillon envoie des données booléennes

et dans SecendFragment

yourNameParentFragment name =yourNameParentFragment.newInstance();
   Bundle bundle;
   bundle=sellDiamondFragments2.getArguments();
  boolean a= bundle.getBoolean("yourKey");

la valeur du premier fragment doit être statique

code heureux

La meilleure façon d'instancier le fragment est d'utiliser la méthode Fragment.instantiate par défaut ou de créer la méthode d'usine pour instancier le fragment
.

Je suis ici dernièrement. Mais quelque chose que je viens de savoir pourrait vous aider un peu.

Si vous utilisez Java, il n'y a rien à changer. Mais pour les développeurs de kotlin, voici un extrait suivant, je pense, qui peut faire de vous un sous-sol sur lequel fonctionner:

• Fragment parent:

inline fun <reified T : SampleFragment> newInstance(text: String): T {
    return T::class.java.newInstance().apply {
        arguments = Bundle().also { it.putString("key_text_arg", text) }
    }
}

• Appel normal

val f: SampleFragment = SampleFragment.newInstance("ABC")
// or val f = SampleFragment.newInstance<SampleFragment>("ABC")

• Vous pouvez étendre l'opération d'initialisation parent dans la classe de fragment enfant en:

fun newInstance(): ChildSampleFragment {
    val child = UserProfileFragment.newInstance<ChildSampleFragment>("XYZ")
    // Do anything with the current initialized args bundle here
    // with child.arguments = ....
    return child
}

Codage heureux.

setArguments()est inutile. Cela ne fait qu'amener un gâchis.

public class MyFragment extends Fragment {

    public String mTitle;
    public String mInitialTitle;

    public static MyFragment newInstance(String param1) {
        MyFragment f = new MyFragment();
        f.mInitialTitle = param1;
        f.mTitle = param1;
        return f;
    }

    @Override
    public void onSaveInstanceState(Bundle state) {
        state.putString("mInitialTitle", mInitialTitle);
        state.putString("mTitle", mTitle);
        super.onSaveInstanceState(state);
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle state) {
        if (state != null) {
            mInitialTitle = state.getString("mInitialTitle");
            mTitle = state.getString("mTitle");
        } 
        ...
    }
}

Je crois que j'ai une solution beaucoup plus simple pour cela.

public class MyFragment extends Fragment{

   private String mTitle;
   private List<MyObject> mObjects;

   public static MyFragment newInstance(String title, List<MyObject> objects)
   MyFragment myFrag = new MyFragment();
   myFrag.mTitle = title;
   myFrag.mObjects = objects;
   return myFrag;
   }