Meilleure pratique pour l'instanciation d'un nouveau fragment d'Android

Question

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

Fragment newFragment = new MyFragment();

y

Fragment newFragment = MyFragment.newInstance();

La deuxième option fait appel à une méthode statique newInstance() y généralement contient 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() afin de donner de la flexibilité lors de la création de nouvelles instances d'un Fragment - mais je pouvais aussi le faire en créant un constructeur surchargé pour le Fragment.

J'ai raté quelque chose ?

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

Answer 1

Si Android décide de recréer votre fragment plus tard, il va appeler le constructeur sans argument de votre fragment. Ainsi, surcharger le constructeur n'est pas une solution.

Ceci étant dit, la façon de passer des éléments à votre Fragment afin qu'ils soient disponibles après qu'un Fragment soit recréé par Android est de passer un paquet à la balise setArguments mé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 loin dans le Fragment onCreate() vous pouvez accéder à cet entier en utilisant :

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

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

A noter également : setArguments ne peut être appelé qu'avant que le Fragment soit 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

Answer 2

Le seul avantage d'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 ne devez 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 sont les arguments qu'elles utilisent. s'attend à ce que pour fonctionner fidèlement (bien que vous devriez être capable de gérer les cas où aucun argument n'est regroupé dans l'instance du fragment).

Donc, je pense que l'utilisation d'un newInstance() pour instancier un fragment est une bonne pratique.

Answer 3

Il y a aussi un autre moyen :

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

Answer 4

Alors que @yydl donne une raison convaincante sur la raison pour laquelle la newInstance est meilleure :

Si Android décide de recréer le constructeur sans argument de votre fragment. Donc surcharger le constructeur n'est pas une solution.

il est encore tout à fait possible d'utiliser un Constructeur . Pour comprendre pourquoi, il faut 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 pas d'arguments constructor) pour construire une instance du fragment. Ici, tout constructeur surchargé que vous écrivez sera ignoré, car Android ne peut pas savoir lequel utiliser.

Au cours de la 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 lorsque le fragment sera détruit.

Pour contourner ce problème, Android vous demande de stocker les données à l'aide d'un fichier de type Bundle (appel setArguments() ), qui peut ensuite être consulté à partir de YourFragment . Argumentaire bundle sont protégés par Android, et sont donc garantis d'être persistant .

Une façon de définir ce regroupement est d'utiliser un fichier statique de type newInstance méthode :

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 le newInstance méthode.

Naturellement, cela échouerait, et c'est l'une des raisons pour lesquelles Android veut que vous utilisiez l'option newInstance méthode :

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

Pour plus d'explications, voici la classe des 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 soient définis seulement lors de la construction, et garantit que ceux-ci seront conservés.

EDIT : Comme l'a souligné dans les commentaires @JHH, si vous fournissez un constructeur personnalisé qui nécessite certains arguments, alors Java ne fournira pas à votre fragment un pas d'argument Constructeur par défaut. Il faudrait donc que vous définissiez un pas d'argument ce qui représente du code que vous pourriez éviter avec l'option newInstance méthode d'usine.

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

Answer 5

Quelques 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 ça :

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