Prática recomendada para instanciar um novo fragmento Android

Vi duas práticas gerais para instanciar um novo fragmento em um aplicativo:

Fragment newFragment = new MyFragment();

e

Fragment newFragment = MyFragment.newInstance();

A segunda opção utiliza um método estático newInstance()e geralmente contém o seguinte método.

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

No começo, pensei que o principal benefício era o fato de poder sobrecarregar o método newInstance () para dar flexibilidade ao criar novas instâncias de um fragmento - mas também poderia fazer isso criando um construtor sobrecarregado para o fragmento.

Perdi alguma coisa?

Quais são os benefícios de uma abordagem sobre a outra? Ou é apenas uma boa prática?

Se o Android decidir recriar o seu Fragmento mais tarde, chamará o construtor sem argumentos do seu fragmento. Portanto, sobrecarregar o construtor não é uma solução.

Com isso dito, a maneira de passar as coisas para o seu Fragmento para que elas estejam disponíveis após a recriação de um fragmento pelo Android é passar um pacote para o setArgumentsmétodo.

Então, por exemplo, se quiséssemos passar um número inteiro para o fragmento, usaríamos algo como:

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

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

    return myFragment;
}

E mais tarde no fragmento, onCreate()você pode acessar esse número inteiro usando:

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

Este pacote estará disponível mesmo que o fragmento seja recriado de alguma forma pelo Android.

Observe também: setArgumentssó pode ser chamado antes que o fragmento seja anexado à atividade.

Essa abordagem também está documentada na referência do desenvolvedor do Android: https://developer.android.com/reference/android/app/Fragment.html

O único benefício em usar o newInstance()que vejo são os seguintes:

1. Você terá um único local em que todos os argumentos usados ​​pelo fragmento poderão ser agrupados e não precisará escrever o código abaixo sempre que instanciar um fragmento.

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

2. É uma boa maneira de dizer a outras classes quais argumentos ele espera que funcionem fielmente (embora você deva poder lidar com casos se nenhum argumento estiver agrupado na instância do fragmento).

Então, minha opinião é que usar uma estática newInstance()para instanciar um fragmento é uma boa prática.

Há também outra maneira:

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

Enquanto @yydl fornece uma razão convincente para o newInstancemelhor método:

Se o Android decidir recriar o seu Fragmento mais tarde, chamará o construtor sem argumentos do seu fragmento. Portanto, sobrecarregar o construtor não é uma solução.

ainda é possível usar um construtor . Para entender por que isso ocorre, primeiro precisamos ver por que a solução alternativa acima é usada pelo Android.

Antes que um fragmento possa ser usado, é necessária uma instância. O Android chama YourFragment()(o construtor sem argumentos ) para construir uma instância do fragmento. Aqui, qualquer construtor sobrecarregado que você escreve será ignorado, pois o Android não pode saber qual usar.

Durante a vida útil de uma atividade, o fragmento é criado como descrito acima e destruído várias vezes pelo Android. Isso significa que se você colocar dados no próprio objeto de fragmento, eles serão perdidos quando o fragmento for destruído.

Para contornar o problema, o Android solicita que você armazene dados usando uma Bundle(chamada setArguments()), que pode ser acessada a partir de YourFragment. Os argumentos bundlesão protegidos pelo Android e, portanto, garantem a persistência .

Uma maneira de configurar esse pacote configurável é usando um newInstancemétodo estático :

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

No entanto, um construtor:

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

pode fazer exatamente a mesma coisa que o newInstancemétodo

Naturalmente, isso falharia e é um dos motivos pelos quais o Android quer que você use o newInstancemétodo:

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

Como explicação adicional, aqui está a Classe de Fragmentos do 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;
}

Observe que o Android pede que os argumentos sejam definidos apenas na construção e garante que eles serão mantidos.

EDIT : Como apontado nos comentários de @JHH, se você estiver fornecendo um construtor personalizado que requer alguns argumentos, o Java não fornecerá ao seu fragmento um construtor padrão sem argumento . Portanto, isso exigiria que você definisse um construtor no arg , que é um código que você poderia evitar com o newInstancemétodo factory.

EDIT : Android não permite mais usar um construtor sobrecarregado para fragmentos. Você deve usar o newInstancemétodo

Não concordo com a resposta do yydi dizendo:

Se o Android decidir recriar o seu Fragmento mais tarde, chamará o construtor sem argumentos do seu fragmento. Portanto, sobrecarregar o construtor não é uma solução.

Eu acho que é uma solução e uma boa solução, esse é exatamente o motivo pelo qual foi desenvolvida pela linguagem principal do Java.

É verdade que o sistema Android pode destruir e recriar o seu Fragment. Então você pode fazer isso:

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

Isso permitirá que você use a someIntpartir getArguments()de agora, mesmo que tenha Fragmentsido recriado pelo sistema. Esta é uma solução mais elegante que o staticconstrutor.

Na minha opinião, staticconstrutores são inúteis e não devem ser usados. Eles também o limitarão se, no futuro, você desejar estender isso Fragmente adicionar mais funcionalidade ao construtor. Com o staticconstrutor, você não pode fazer isso.

Atualizar:

O Android adicionou uma inspeção que sinaliza todos os construtores não padrão com um erro.
Eu recomendo desativá-lo, pelos motivos mencionados acima.

Algum código kotlin :

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

E você pode obter argumentos com isso:

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

A melhor prática para instar fragmentos com argumentos no android é ter o método de fábrica estática no seu fragmento.

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

Você deve evitar definir seus campos com a instância de um fragmento. Porque sempre que o sistema Android recriar seu fragmento, se achar que o sistema precisa de mais memória, ele recriará seu fragmento usando o construtor sem argumentos.

Você pode encontrar mais informações sobre as melhores práticas para instanciar fragmentos com argumentos aqui.

Como as perguntas sobre as melhores práticas, eu acrescentaria, que muitas vezes é uma boa idéia usar a abordagem híbrida para criar fragmentos ao trabalhar com alguns serviços da web REST

Não podemos passar objetos complexos, por exemplo, algum modelo de usuário, para exibir fragmento de usuário

Mas o que podemos fazer é fazer check-in onCreatedesse usuário! = Null e, se não - então trazê-lo da camada de dados, caso contrário - use o existente.

Dessa forma, obtemos a capacidade de recriar pelo userId em caso de recriação de fragmentos pelo Android e o snappiness para as ações do usuário, bem como a capacidade de criar fragmentos mantendo pressionado para objetar a si próprio ou apenas seu ID

Algo gosta disso:

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

use este código 100% corrija seu problema

insira esse código no firstFragment

public static yourNameParentFragment newInstance() {

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

este exemplo envia dados booleanos

e no SecendFragment

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

deve valor no primeiro fragmento é estático

código feliz

A melhor maneira de instanciar o fragmento é usar o método Fragment.instantiate padrão ou criar o método factory para instanciar o fragmento
Cuidado: sempre crie um construtor vazio no fragmento outro enquanto a restauração do fragmento lançará uma exceção em tempo de execução.

Ultimamente estou aqui. Mas algumas coisas que eu acabei de saber que podem ajudá-lo um pouco.

Se você estiver usando Java, não há muito o que mudar. Mas para os desenvolvedores do kotlin, aqui estão alguns trechos a seguir que eu acho que podem torná-lo um porão para rodar:

• Fragmento pai:

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

• Chamada normal

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

• Você pode estender a operação init pai na classe de fragmento filho:

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

Feliz codificação.

setArguments()é inútil. Isso só traz uma bagunça.

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

Acredito que tenho uma solução muito mais simples para isso.

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