Les fragments ont-ils vraiment besoin d'un constructeur vide?

J'ai un Fragmentavec un constructeur qui prend plusieurs arguments. Mon application a bien fonctionné pendant le développement, mais en production, mes utilisateurs voient parfois ce plantage:

android.support.v4.app.Fragment$InstantiationException: Unable to instantiate fragment 
make sure class name exists, is public, and has an empty constructor that is public

Je pourrais créer un constructeur vide comme le suggère ce message d'erreur, mais cela n'a pas de sens pour moi car je devrais alors appeler une méthode distincte pour terminer la configuration de Fragment.

Je suis curieux de savoir pourquoi cet accident ne se produit qu'occasionnellement. Peut-être que j'utilise ViewPagermal? J'instancie tous les Fragments moi-même et les enregistre dans une liste à l'intérieur du Activity. Je n'utilise pas de FragmentManagertransactions, car les ViewPagerexemples que j'ai vus ne l'exigeaient pas et tout semblait fonctionner pendant le développement.

Oui, ils le font.

De toute façon, vous ne devriez pas vraiment remplacer le constructeur. Vous devez avoir une newInstance()méthode statique définie et passer tous les paramètres via des arguments (bundle)

Par exemple:

public static final MyFragment newInstance(int title, String message) {
    MyFragment f = new MyFragment();
    Bundle bdl = new Bundle(2);
    bdl.putInt(EXTRA_TITLE, title);
    bdl.putString(EXTRA_MESSAGE, message);
    f.setArguments(bdl);
    return f;
}

Et bien sûr, saisir les arguments de cette façon:

@Override
public void onCreate(Bundle savedInstanceState) {
    title = getArguments().getInt(EXTRA_TITLE);
    message = getArguments().getString(EXTRA_MESSAGE);

    //...
    //etc
    //...
}

Ensuite, vous instancieriez à partir de votre gestionnaire de fragments comme suit:

@Override
public void onCreate(Bundle savedInstanceState) {
    if (savedInstanceState == null){
        getSupportFragmentManager()
            .beginTransaction()
            .replace(R.id.content, MyFragment.newInstance(
                R.string.alert_title,
                "Oh no, an error occurred!")
            )
            .commit();
    }
}

De cette façon, s'il est détaché et re-attaché, l'état de l'objet peut être stocké via les arguments. Tout comme les bundles attachés à Intents.

Motif - Lecture supplémentaire

J'ai pensé expliquer pourquoi les gens se demandent pourquoi.

Si vous cochez: https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/app/Fragment.java

Vous verrez la instantiate(..)méthode dans la Fragmentclasse appelle la newInstanceméthode:

public static Fragment instantiate(Context context, String fname, @Nullable Bundle args) {
    try {
        Class<?> clazz = sClassMap.get(fname);
        if (clazz == null) {
            // Class not found in the cache, see if it's real, and try to add it
            clazz = context.getClassLoader().loadClass(fname);
            if (!Fragment.class.isAssignableFrom(clazz)) {
                throw new InstantiationException("Trying to instantiate a class " + fname
                        + " that is not a Fragment", new ClassCastException());
            }
            sClassMap.put(fname, clazz);
        }
        Fragment f = (Fragment) clazz.getConstructor().newInstance();
        if (args != null) {
            args.setClassLoader(f.getClass().getClassLoader());
            f.setArguments(args);
        }
        return f;
    } catch (ClassNotFoundException e) {
        throw new InstantiationException("Unable to instantiate fragment " + fname
                + ": make sure class name exists, is public, and has an"
                + " empty constructor that is public", e);
    } catch (java.lang.InstantiationException e) {
        throw new InstantiationException("Unable to instantiate fragment " + fname
                + ": make sure class name exists, is public, and has an"
                + " empty constructor that is public", e);
    } catch (IllegalAccessException e) {
        throw new InstantiationException("Unable to instantiate fragment " + fname
                + ": make sure class name exists, is public, and has an"
                + " empty constructor that is public", e);
    } catch (NoSuchMethodException e) {
        throw new InstantiationException("Unable to instantiate fragment " + fname
                + ": could not find Fragment constructor", e);
    } catch (InvocationTargetException e) {
        throw new InstantiationException("Unable to instantiate fragment " + fname
                + ": calling Fragment constructor caused an exception", e);
    }
}

http://docs.oracle.com/javase/6/docs/api/java/lang/Class.html#newInstance () Explique pourquoi, lors de l'instanciation, il vérifie que l'accesseur est publicet que ce chargeur de classe permet d'y accéder.

C'est une méthode assez méchante dans l'ensemble, mais elle permet FragmentMangerde tuer et de recréer Fragmentsavec des états. (Le sous-système Android fait des choses similaires avec Activities).

Exemple de classe

On me demande beaucoup d'appeler newInstance. Ne confondez pas cela avec la méthode de classe. Cet exemple de classe entière doit montrer l'utilisation.

/**
 * Created by chris on 21/11/2013
 */
public class StationInfoAccessibilityFragment extends BaseFragment implements JourneyProviderListener {

    public static final StationInfoAccessibilityFragment newInstance(String crsCode) {
        StationInfoAccessibilityFragment fragment = new StationInfoAccessibilityFragment();

        final Bundle args = new Bundle(1);
        args.putString(EXTRA_CRS_CODE, crsCode);
        fragment.setArguments(args);

        return fragment;
    }

    // Views
    LinearLayout mLinearLayout;

    /**
     * Layout Inflater
     */
    private LayoutInflater mInflater;
    /**
     * Station Crs Code
     */
    private String mCrsCode;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mCrsCode = getArguments().getString(EXTRA_CRS_CODE);
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        mInflater = inflater;
        return inflater.inflate(R.layout.fragment_station_accessibility, container, false);
    }

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        mLinearLayout = (LinearLayout)view.findViewBy(R.id.station_info_accessibility_linear);
        //Do stuff
    }

    @Override
    public void onResume() {
        super.onResume();
        getActivity().getSupportActionBar().setTitle(R.string.station_info_access_mobility_title);
    }

    // Other methods etc...
}

Comme indiqué par CommonsWare dans cette question https://stackoverflow.com/a/16064418/1319061 , cette erreur peut également se produire si vous créez une sous-classe anonyme d'un fragment, car les classes anonymes ne peuvent pas avoir de constructeurs.

Ne faites pas de sous-classes anonymes de Fragment :-)

Oui, comme vous pouvez le voir, le support-package instancie également les fragments (lorsqu'ils sont détruits et rouverts). Vos Fragmentsous-classes ont besoin d'un constructeur public vide car c'est ce que le framework appelle.

Voici ma solution simple:

1 - Définissez votre fragment

public class MyFragment extends Fragment {

    private String parameter;

    public MyFragment() {
    }

    public void setParameter(String parameter) {
        this.parameter = parameter;
    } 
}

2 - Créez votre nouveau fragment et remplissez le paramètre

    myfragment = new MyFragment();
    myfragment.setParameter("here the value of my parameter");

3 - Profitez-en!

Évidemment, vous pouvez changer le type et le nombre de paramètres. Rapide et facile.