Best practice per creare un'istanza di un nuovo frammento Android

Ho visto due pratiche generali per creare un'istanza di un nuovo frammento in un'applicazione:

Fragment newFragment = new MyFragment();

e

Fragment newFragment = MyFragment.newInstance();

La seconda opzione fa uso di un metodo statico newInstance()e generalmente contiene il seguente metodo.

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

Inizialmente, ho pensato che il vantaggio principale fosse il fatto che avrei potuto sovraccaricare il metodo newInstance () per dare flessibilità durante la creazione di nuove istanze di un frammento, ma potevo anche farlo creando un costruttore sovraccaricato per il frammento.

Ho dimenticato qualcosa?

Quali sono i vantaggi di un approccio rispetto all'altro? O è solo una buona pratica?

Se Android decide di ricreare il tuo frammento in un secondo momento, chiamerà il costruttore senza argomenti del tuo frammento. Quindi sovraccaricare il costruttore non è una soluzione.

Detto questo, il modo per passare le cose al tuo frammento in modo che siano disponibili dopo che un frammento è stato ricreato da Android è quello di passare un bundle al setArgumentsmetodo.

Quindi, ad esempio, se volessimo passare un intero al frammento, utilizzeremmo qualcosa del tipo:

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

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

    return myFragment;
}

E più tardi nel frammento onCreate()puoi accedere a quell'intero usando:

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

Questo pacchetto sarà disponibile anche se il frammento viene in qualche modo ricreato da Android.

Nota anche: setArgumentspuò essere chiamato solo prima che il frammento sia attaccato all'attività.

Questo approccio è documentato anche nel riferimento per gli sviluppatori Android: https://developer.android.com/reference/android/app/Fragment.html

L'unico vantaggio nell'uso di quello newInstance()che vedo sono i seguenti:

1. Avrai un unico posto in cui tutti gli argomenti usati dal frammento potrebbero essere raggruppati e non dovrai scrivere il codice qui sotto ogni volta che crei un'istanza di un frammento.

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

2. È un buon modo per dire ad altre classi quali argomenti si aspetta che funzionino fedelmente (anche se dovresti essere in grado di gestire i casi se nessun argomento è raggruppato nell'istanza del frammento).

Quindi, la mia opinione è che usare una statica newInstance()per creare un'istanza di un frammento sia una buona pratica.

C'è anche un altro modo:

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

Mentre @yydl fornisce un motivo convincente sul perché il newInstancemetodo è migliore:

Se Android decide di ricreare il tuo frammento in un secondo momento, chiamerà il costruttore senza argomenti del tuo frammento. Quindi sovraccaricare il costruttore non è una soluzione.

è ancora del tutto possibile usare un costruttore . Per capire perché, innanzitutto dobbiamo vedere perché la soluzione sopra descritta viene utilizzata da Android.

Prima di poter utilizzare un frammento, è necessaria un'istanza. Chiamate Android YourFragment()( nessun argomento costruttore ) per costruire un'istanza del frammento. Qui qualsiasi costruttore sovraccarico che scrivi verrà ignorato, poiché Android non può sapere quale utilizzare.

Nel corso della vita di un'attività il frammento viene creato come sopra e distrutto più volte da Android. Ciò significa che se si inseriscono dati nell'oggetto frammento stesso, questi verranno persi una volta che il frammento viene distrutto.

Per ovviare al problema, Android chiede di archiviare i dati utilizzando un Bundle(chiamante setArguments()), a cui è possibile accedere da YourFragment. Gli argomenti bundlesono protetti da Android e quindi sono garantiti come persistenti .

Un modo per impostare questo pacchetto è utilizzando un newInstancemetodo statico :

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

Tuttavia, un costruttore:

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

può fare esattamente la stessa cosa del newInstancemetodo.

Naturalmente, ciò fallirebbe ed è uno dei motivi per cui Android vuole che tu usi il newInstancemetodo:

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

Come ulteriore spiegazione, ecco la classe dei frammenti di 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;
}

Si noti che Android chiede che gli argomenti siano impostati solo durante la costruzione e garantisce che questi verranno conservati.

EDIT : Come sottolineato nei commenti di @JHH, se stai fornendo un costruttore personalizzato che richiede alcuni argomenti, Java non fornirà al tuo frammento un costruttore predefinito senza arg . Quindi questo richiederebbe di definire un costruttore no arg , che è il codice che potresti evitare con il newInstancemetodo factory.

EDIT : Android non consente più l'utilizzo di un costruttore sovraccaricato per i frammenti. È necessario utilizzare il newInstancemetodo

Non sono d' accordo con la risposta yydi dicendo:

Se Android decide di ricreare il tuo frammento in un secondo momento, chiamerà il costruttore senza argomenti del tuo frammento. Quindi sovraccaricare il costruttore non è una soluzione.

Penso che sia una soluzione valida, questa è esattamente la ragione per cui è stata sviluppata dal linguaggio centrale Java.

È vero che il sistema Android può distruggere e ricreare il tuo Fragment. Quindi puoi farlo:

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

Ti permetterà di tirare someIntda getArguments()quest'ultimo in poi, anche se Fragmentricreato dal sistema. Questa è una soluzione più elegante del staticcostruttore.

Secondo me i staticcostruttori sono inutili e non dovrebbero essere usati. Inoltre ti limiteranno se in futuro desideri estenderlo Fragmente aggiungere più funzionalità al costruttore. Con il staticcostruttore non puoi farlo.

Aggiornare:

Android ha aggiunto l'ispezione che contrassegna tutti i costruttori non predefiniti con un errore.
Consiglio di disabilitarlo, per i motivi sopra menzionati.

Alcuni codici kotlin :

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

E puoi ottenere argomenti con questo:

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

La migliore pratica per istanziare frammenti con argomenti in Android è di avere un metodo factory statico nel tuo frammento.

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

Dovresti evitare di impostare i campi con l'istanza di un frammento. Perché ogni volta che il sistema Android ricrea il frammento, se ritiene che il sistema abbia bisogno di più memoria, allora ricrea il frammento utilizzando il costruttore senza argomenti.

Puoi trovare maggiori informazioni sulle migliori pratiche per creare un'istanza di frammenti con argomenti qui.

Dopo le domande sulle migliori pratiche, aggiungerei, molto spesso una buona idea di utilizzare un approccio ibrido per creare frammenti quando si lavora con alcuni servizi Web REST

Non possiamo trasmettere oggetti complessi, ad esempio un modello utente, nel caso di visualizzazione di frammenti utente

Ma quello che possiamo fare è fare il check-in onCreate quell'utente! = Null e, in caso contrario, portarlo dal livello dati, altrimenti - usare esistente.

In questo modo otteniamo sia la capacità di ricreare dall'utenteId in caso di ricreazione di frammenti di Android e la reattività per le azioni dell'utente, sia la capacità di creare frammenti mantenendo l'oggetto stesso o solo il suo ID

Qualcosa di simile a questo:

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

usa questo codice al 100% per risolvere il tuo problema

inserisci questo codice in firstFragment

public static yourNameParentFragment newInstance() {

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

questo esempio invia dati booleani

e in SecendFragment

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

il valore deve nel primo frammento è statico

codice felice

Il modo migliore per creare un'istanza del frammento è utilizzare il metodo Fragment.instantiate predefinito o creare un metodo factory per creare un'istanza del frammento
Attenzione: creare sempre un costruttore vuoto nel frammento altro mentre il ripristino della memoria del frammento genererà un'eccezione di runtime.

Sono di recente qui. Ma alcune cose che ho appena saputo potrebbero aiutarti un po '.

Se stai usando Java, non c'è molto da cambiare. Ma per gli sviluppatori di kotlin, ecco alcuni frammenti seguenti che penso possano farti diventare un seminterrato:

• Frammento principale:

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

• Chiamata normale

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

• È possibile estendere l'operazione init padre nella classe di frammento figlio:

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

Buona codifica.

setArguments()è inutile. Porta solo un casino.

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");
        } 
        ...
    }
}

Credo di avere una soluzione molto più semplice per questo.

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