Os fragmentos realmente precisam de um construtor vazio?

Eu tenho um Fragmentcom um construtor que leva vários argumentos. Meu aplicativo funcionou bem durante o desenvolvimento, mas, na produção, meus usuários às vezes veem essa falha:

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

Eu poderia criar um construtor vazio como essa mensagem de erro sugere, mas isso não faz sentido para mim desde então, eu teria que chamar um método separado para concluir a configuração Fragment.

Estou curioso para saber por que esse acidente ocorre ocasionalmente. Talvez eu esteja usando o ViewPagerincorretamente? Eu instanciar todos os Fragments eu mesmo e salvá-los em uma lista dentro do Activity. Não uso FragmentManagertransações, pois os ViewPagerexemplos que eu vi não exigem isso e tudo parecia funcionar durante o desenvolvimento.

Sim, eles fazem.

Você realmente não deveria substituir o construtor de qualquer maneira. Você deve ter um newInstance()método estático definido e passar quaisquer parâmetros por meio de argumentos (pacote configurável)

Por exemplo:

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, claro, pegando os argumentos dessa maneira:

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

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

Então você instanciaria do seu gerenciador de fragmentos da seguinte forma:

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

Dessa forma, se desanexado e reconectado, o estado do objeto pode ser armazenado através dos argumentos. Muito parecido com pacotes anexados aos Intents.

Razão - Leitura extra

Eu pensei em explicar o porquê das pessoas que se perguntam o porquê.

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

Você verá que o instantiate(..)método na Fragmentclasse chama o newInstancemétodo:

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 () Explica por que, por instanciação, verifica se o acessador é publice se esse carregador de classes permite acesso a ele.

É um método bastante desagradável, mas permite FragmentMangermatar e recriar Fragmentscom estados. (O subsistema Android faz coisas semelhantes Activities).

Classe de exemplo

Me perguntam muito sobre ligar newInstance. Não confunda isso com o método de classe. Este exemplo de classe inteira deve mostrar o uso.

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

Conforme observado pelo CommonsWare nesta pergunta https://stackoverflow.com/a/16064418/1319061 , esse erro também pode ocorrer se você estiver criando uma subclasse anônima de um Fragmento, pois as classes anônimas não podem ter construtores.

Não faça subclasses anônimas de Fragment :-)

Sim, como você pode ver, o pacote de suporte instancia os fragmentos também (quando eles são destruídos e reabertos). Suas Fragmentsubclasses precisam de um construtor público vazio, pois é isso que está sendo chamado pela estrutura.

Aqui está minha solução simples:

1 - Defina seu fragmento

public class MyFragment extends Fragment {

    private String parameter;

    public MyFragment() {
    }

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

2 - Crie seu novo fragmento e preencha o parâmetro

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

3 - Aproveite!

Obviamente, você pode alterar o tipo e o número de parâmetros. Rápido e fácil.