Najlepsza praktyka tworzenia instancji nowego fragmentu Androida

Jedyne korzyści z używania newInstance(), które widzę są następujące:

1. Będziesz miał jedno miejsce, gdzie wszystkie argumenty użyte przez fragment mogą być połączone i nie musisz pisać poniższego kodu za każdym razem, gdy tworzysz instancję fragmentu.

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

2. Jest to dobry sposób, aby powiedzieć innym klasom, jakie argumenty oczekuje, że będą działać wiernie(chociaż powinieneś być w stanie obsłużyć przypadki, jeśli nie ma argumentów w pakiecie we fragmencie instancja).

Moim zdaniem używanie statycznego newInstance() do tworzenia instancji fragmentu jest dobrą praktyką.

Jest też inny sposób:

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

Podczas gdy @yydl podaje przekonujący powód, dlaczego metoda newInstance jest lepsza:

Jeśli Android zdecyduje się odtworzyć Twój Fragment później, zadzwoni bezdyskusyjny konstruktor twojego fragmentu. Więc przeciążenie konstruktor nie jest rozwiązaniem.

Wciąż możliwe jest użycie konstruktora . Aby zobaczyć, dlaczego tak jest, najpierw musimy zobaczyć, dlaczego powyższe obejście jest używane przez Androida.

Zanim fragment może być użyty, instancja jest potrzebne. Android wywołuje YourFragment() (konstruktor bez argumentów ), aby skonstruować instancję fragmentu. Tutaj każdy przeciążony konstruktor, który napiszesz, zostanie zignorowany, ponieważ Android nie może wiedzieć, którego użyć.

W czasie trwania aktywności fragment zostaje utworzony jak wyżej i wielokrotnie niszczony przez Androida. Oznacza to, że jeśli umieścisz dane w samym obiekcie fragment, zostaną one utracone po zniszczeniu fragmentu.

Aby obejść, android prosi, aby przechowuj dane za pomocą Bundle (wywołanie setArguments()), do którego można uzyskać dostęp z YourFragment. Argumenty bundle S są chronione przez system Android, a zatem gwarantowane są trwałe.

Jednym ze sposobów ustawienia tego pakietu jest użycie statycznej metody newInstance:

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

Jednak konstruktor:

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

Może zrobić dokładnie to samo, co metoda newInstance.

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

Jako dalsze wyjaśnienie, oto Klasa fragmentu Androida:

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

Zauważ, że Android prosi o ustawienie argumentów tylko przy budowie i gwarantuje, że zostaną one zachowane.

EDIT: Jak wspomniano w komentarzach przez @JHH, jeśli dostarczasz własny konstruktor, który wymaga pewnych argumentów, to Java nie dostarczy twojego fragmentu z domyślnym konstruktorem no arg. Wymagałoby to więc zdefiniowania No ARG constructor, czyli kod, którego można uniknąć za pomocą metody fabrycznej newInstance.

EDIT : Android nie pozwala na używanie przeciążonego konstruktora dla fragmentów. Należy użyć metody newInstance.

Some kotlin kod:

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

I możesz uzyskać argumenty za pomocą tego:

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

I nie zgadzam się z yydi odpowiedź mówiąc:

Jeśli Android zdecyduje się odtworzyć Twój Fragment później, zadzwoni bezdyskusyjny konstruktor twojego fragmentu. Więc przeciążenie konstruktor nie jest rozwiązaniem.

Myślę, że jest to rozwiązanie i dobre, właśnie dlatego zostało opracowane przez Java core language.

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

Pozwoli Ci wyciągnąć someInt z getArguments(), nawet jeśli Fragment został odtworzony przez system. Jest to bardziej eleganckie rozwiązanie niż konstruktor static.

Moim zdaniem static konstruktory są bezużyteczne i nie powinny być używane. Również będą cię ograniczać, jeśli w przyszłości będziesz chciał rozszerzyć to Fragment i dodać więcej funkcjonalności do konstruktora. Z konstruktorem static nie możesz tego zrobić.

Update:

Najlepszą praktyką instancji fragmentów z argumentami w Androidzie jest posiadanie statycznej metody fabrycznej w swoim fragmencie.

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

Należy unikać ustawiania pól z instancją fragmentu. Ponieważ ilekroć system Android odtworzy Twój fragment, jeśli uzna, że system potrzebuje więcej pamięci, niż odtworzy Twój fragment za pomocą konstruktora bez argumentów.

Możesz znaleźć więcej informacji o najlepszych praktykach tworzenia instancji fragmentów z argumentami proszę.

Ponieważ pytania dotyczące najlepszych praktyk, dodam, że bardzo często dobrym pomysłem jest użycie podejścia hybrydowego do tworzenia fragmentów podczas pracy z niektórymi usługami sieciowymi REST

Nie możemy przekazać złożonych obiektów, na przykład jakiegoś modelu użytkownika, w przypadku wyświetlenia fragmentu użytkownika

Ale co możemy zrobić, to sprawdzić onCreate tego użytkownika!=null, a jeśli nie-to przynieś go z warstwy danych, w przeciwnym razie-użyj existing.

W ten sposób zyskujemy zarówno możliwość odtworzenia przez userId w przypadku fragment recreation przez Androida i snappiness dla działań użytkownika, a także możliwość tworzenia fragmentów przez trzymanie się obiektu lub tylko jego id

Coś takiego:

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

Użyj tego kodu w 100% rozwiąż swój problem

Wpisz ten kod w firstFragment

public static yourNameParentFragment newInstance() {

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

Ta próbka wysyła dane logiczne

I w SecendFragment

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

Wartość Must w pierwszym fragmencie jest statyczna

Happy code

Jestem tu ostatnio. Ale wiem coś, co może Ci trochę pomóc.

Jeśli używasz Javy, nie ma nic do zmiany. Ale dla programistów Kotlina, oto następujący fragment, który może sprawić, że będziesz mógł uruchomić: {]}

• fragment nadrzędny:

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

• normalne wywołanie

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

• możesz rozszerzyć operację INIT rodzica w klasie fragment potomka o:

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

Najlepszym sposobem utworzenia instancji fragmentu jest użycie domyślnego fragmentu .instantiate method lub create factory method to instantiate the fragment
Uwaga: zawsze Utwórz jeden pusty konstruktor we fragmencie Inne podczas przywracania pamięci fragment wyrzuci wyjątek run-time.

Możesz użyć smth w następujący sposób:

val fragment = supportFragmentManager.fragmentFactory.instantiate(classLoader, YourFragment::class.java.name)

Ponieważ ta odpowiedź jest teraz przestarzała

setArguments() jest bezużyteczny. To tylko bałagan.

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

Wydaje mi się, że mam na to dużo prostsze rozwiązanie.

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