I frammenti hanno davvero bisogno di un costruttore vuoto?

Ho un Fragmentcon un costruttore che accetta più argomenti. La mia app ha funzionato bene durante lo sviluppo, ma in produzione i miei utenti a volte vedono questo crash:

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

Potrei creare un costruttore vuoto come suggerisce questo messaggio di errore, ma per me non ha senso da allora dovrei chiamare un metodo separato per completare la configurazione di Fragment.

Sono curioso di sapere perché questo incidente si verifica solo occasionalmente. Forse sto usando in ViewPagermodo errato? Ho un'istanza di tutti Fragmenti messaggi personali e li salvo in un elenco all'interno di Activity. Non utilizzo le FragmentManagertransazioni, poiché gli ViewPageresempi che ho visto non lo richiedono e tutto sembra funzionare durante lo sviluppo.

Si lo fanno.

Non dovresti davvero scavalcare il costruttore comunque. Dovresti avere un newInstance()metodo statico definito e passare qualsiasi parametro tramite argomenti (bundle)

Per esempio:

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

E ovviamente afferrando gli argomenti in questo modo:

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

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

Quindi creeresti un'istanza dal gestore dei frammenti in questo modo:

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

In questo modo, se disconnesso e ricollegato, lo stato dell'oggetto può essere memorizzato tramite gli argomenti. Proprio come i bundle associati a Intents.

Motivo: lettura aggiuntiva

Ho pensato di spiegare perché per le persone che si chiedono perché.

Se controlli: https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/app/Fragment.java

Vedrai il instantiate(..)metodo nella Fragmentclasse chiama il newInstancemetodo:

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 () Spiega perché, all'istanza, verifica che l'accessor sia publice che quel caricatore di classi ne consenta l'accesso.

È un metodo piuttosto brutto nel complesso, ma consente FragmentMangerdi uccidere e ricreare Fragmentscon gli stati. (Il sottosistema Android fa cose simili con Activities).

Classe di esempio

Mi viene chiesto molto sulla chiamata newInstance. Non confonderlo con il metodo class. Questo esempio di intera classe dovrebbe mostrare l'utilizzo.

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

Come notato da CommonsWare in questa domanda https://stackoverflow.com/a/16064418/1319061 , questo errore può verificarsi anche se si sta creando una sottoclasse anonima di un frammento, poiché le classi anonime non possono avere costruttori.

Non creare sottoclassi anonime di Fragment :-)

Sì, come puoi vedere il pacchetto di supporto crea anche un'istanza dei frammenti (quando vengono distrutti e riaperti). Le tue Fragmentsottoclassi necessitano di un costruttore vuoto pubblico poiché questo è ciò che viene chiamato dal framework.

Ecco la mia soluzione semplice:

1 - Definisci il tuo frammento

public class MyFragment extends Fragment {

    private String parameter;

    public MyFragment() {
    }

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

2 - Crea il tuo nuovo frammento e popola il parametro

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

3 - Divertiti!

Ovviamente puoi cambiare il tipo e il numero di parametri. Facile e veloce.