android fragment- Como salvar estados de visualizações em um fragmento quando outro fragmento é empurrado em cima dele

No android, um fragmento (digamos FragA) é adicionado ao backstack e outro fragmento (digamos FragB) chega ao topo. Agora, ao voltar, FragAchega ao topo e onCreateView()é chamado. Agora eu estava FragAem um estado específico antes de FragBser empurrado para cima.

Minha pergunta é como posso restaurar FragApara o estado anterior? Existe uma maneira de salvar o estado (como, por exemplo, em um pacote) e, em caso afirmativo, qual método devo substituir?

No exemplo de guia FragmentList do fragmento, você pode encontrar:

@Override
public void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putInt("curChoice", mCurCheckPosition);
}

Que você pode usar mais tarde, assim:

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    if (savedInstanceState != null) {
        // Restore last state for checked position.
        mCurCheckPosition = savedInstanceState.getInt("curChoice", 0);
    }
}

Eu sou iniciante em Fragmentos, mas parece que a solução do seu problema;) OnActivityCreated é invocada após o retorno do fragmento da pilha traseira.

Os fragmentos onSaveInstanceState(Bundle outState)nunca serão chamados, a menos que a atividade do fragmento invoque a si mesma e os fragmentos anexados. Portanto, esse método não será chamado até que algo (normalmente rotação) force a atividade SaveInstanceStatee a restaure posteriormente. Porém, se você tiver apenas uma atividade e um grande conjunto de fragmentos (com uso intensivo de replace) e o aplicativo for executado apenas em uma atividade de orientação, onSaveInstanceState(Bundle outState)poderá não ser chamada por muito tempo.

Conheço três soluções possíveis.

O primeiro:

use os argumentos do fragmento para armazenar dados importantes:

public class FragmentA extends Fragment {
    private static final String PERSISTENT_VARIABLE_BUNDLE_KEY = "persistentVariable";

    private EditText persistentVariableEdit;

    public FragmentA() {
        setArguments(new Bundle());
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_a, null);

        persistentVariableEdit = (EditText) view.findViewById(R.id.editText);

        TextView proofTextView = (TextView) view.findViewById(R.id.textView);

        Bundle mySavedInstanceState = getArguments();
        String persistentVariable = mySavedInstanceState.getString(PERSISTENT_VARIABLE_BUNDLE_KEY);

        proofTextView.setText(persistentVariable);


        view.findViewById(R.id.btnPushFragmentB).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                getFragmentManager()
                        .beginTransaction()
                        .replace(R.id.frameLayout, new FragmentB())
                        .addToBackStack(null)
                        .commit();
            }
        });

        return view;
    }

    @Override
    public void onPause() {
        super.onPause();
        String persistentVariable = persistentVariableEdit.getText().toString();

        getArguments().putString(PERSISTENT_VARIABLE_BUNDLE_KEY, persistentVariable);
    }
}

A segunda maneira, mas menos pedante - mantenha variáveis ​​em singletons

O terceiro - não replace()fragmentos, mas add()/ show()/ hide()eles.

Observe que, se você trabalha com fragmentos usando o ViewPager, é muito fácil. Você só precisa chamar esse método: setOffscreenPageLimit().

De acordo com os documentos:

Defina o número de páginas que devem ser mantidas nos dois lados da página atual na hierarquia de exibição em um estado ocioso. As páginas além desse limite serão recriadas do adaptador quando necessário.

Problema semelhante aqui

Basta inflar sua visualização pela primeira vez.

Exemplo a seguir:

public class AFragment extends Fragment {

private View mRootView;
@Nullable
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    if(mRootView==null){
        mRootView = inflater.inflate(R.id.fragment_a, container, false);
        //......
    }
    return mRootView;
}

}

Eu trabalhei com um problema muito parecido com isso. Como eu sabia que voltaria frequentemente a um fragmento anterior, verifiquei se o fragmento .isAdded()era verdadeiro e, se sim, em vez de fazer um transaction.replace(), apenas faço a transaction.show(). Isso evita que o fragmento seja recriado se já estiver na pilha - não é necessário salvar o estado.

Fragment target = <my fragment>;
FragmentTransaction transaction = getFragmentManager().beginTransaction();
transaction.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
if(target.isAdded()) {
    transaction.show(target);
} else {
    transaction.addToBackStack(button_id + "stack_item");
    transaction.replace(R.id.page_fragment, target);
}
transaction.commit();

Outra coisa a ter em mente é que, embora isso preserve a ordem natural dos fragmentos, você ainda precisará lidar com a atividade que está sendo destruída e recriada com a mudança de orientação (config). Para contornar isso no AndroidManifest.xml para o seu nó:

android:configChanges="orientation|screenSize"

No Android 3.0 e superior, o screenSizeé aparentemente necessário.

Boa sorte

A melhor solução que encontrei está abaixo:

onSavedInstanceState (): sempre chamado dentro do fragmento quando a atividade é encerrada (mova a atividade de um para outro ou as alterações de configuração). Portanto, se estivermos chamando vários fragmentos na mesma atividade, precisamos usar a seguinte abordagem:

Use OnDestroyView () do fragmento e salve o objeto inteiro dentro desse método. Em seguida, OnActivityCreated (): verifique se o objeto é nulo ou não (porque esse método chama sempre). Agora restaure o estado de um objeto aqui.

Funciona sempre!

se você estiver lidando com as alterações de configuração em sua atividade de fragmento especificada no manifesto do Android como esta

<activity
    android:name=".courses.posts.EditPostActivity"
    android:configChanges="keyboardHidden|orientation"
    android:screenOrientation="unspecified" />

então o onSaveInstanceStatefragmento não será chamado e o savedInstanceStateobjeto sempre será nulo.

Não acho que onSaveInstanceStateseja uma boa solução. apenas use para atividades que foram destruídas.

No Android 3.0, o Fragmen foi gerenciado pelo FragmentManager, a condição é: um mapeamento de atividade de manny fragmentos, quando o fragmento é adicionado (não substitua: será recriado) no backStack, a visualização será destruída. quando voltar ao último, ele será exibido como antes.

Então eu acho que o fragmentManger e a transação são bons o suficiente para lidar com isso.

Eu usei uma abordagem híbrida para fragmentos que contêm uma exibição de lista. Parece ter bom desempenho, já que não substituo o fragmento atual, mas adiciono o novo fragmento e oculto o atual. Eu tenho o seguinte método na atividade que hospeda meus fragmentos:

public void addFragment(Fragment currentFragment, Fragment targetFragment, String tag) {
    FragmentManager fragmentManager = getSupportFragmentManager();
    FragmentTransaction transaction = fragmentManager.beginTransaction();
    transaction.setCustomAnimations(0,0,0,0);
    transaction.hide(currentFragment);
    // use a fragment tag, so that later on we can find the currently displayed fragment
    transaction.add(R.id.frame_layout, targetFragment, tag)
            .addToBackStack(tag)
            .commit();
}

Eu uso esse método no meu fragmento (contendo a exibição de lista) sempre que um item da lista é clicado / tocado (e, portanto, preciso iniciar / exibir o fragmento de detalhes):

FragmentManager fragmentManager = getActivity().getSupportFragmentManager();
SearchFragment currentFragment = (SearchFragment) fragmentManager.findFragmentByTag(getFragmentTags()[0]);
DetailsFragment detailsFragment = DetailsFragment.newInstance("some object containing some details");
((MainActivity) getActivity()).addFragment(currentFragment, detailsFragment, "Details");

getFragmentTags()retorna uma matriz de seqüências de caracteres que eu uso como tags para diferentes fragmentos quando adiciono um novo fragmento (consulte o transaction.addmétodo no addFragmentmétodo acima).

No fragmento que contém a exibição de lista, faço isso no método onPause ():

@Override
public void onPause() {
    // keep the list view's state in memory ("save" it) 
    // before adding a new fragment or replacing current fragment with a new one
    ListView lv =  (ListView) getActivity().findViewById(R.id.listView);
    mListViewState = lv.onSaveInstanceState();
    super.onPause();
}

Em seguida, no onCreateView do fragmento (na verdade, em um método que é chamado no onCreateView), restauro o estado:

// Restore previous state (including selected item index and scroll position)
if(mListViewState != null) {
    Log.d(TAG, "Restoring the listview's state.");
    lv.onRestoreInstanceState(mListViewState);
}

No final, depois de tentar muitas dessas soluções complicadas, eu só precisava salvar / restaurar um único valor no meu Fragmento (o conteúdo de um EditText) e, apesar de não ser a solução mais elegante, criar uma SharedPreference e armazenar meu estado trabalhou para mim

Uma maneira simples de manter os valores dos campos em diferentes fragmentos em uma atividade

Crie as instâncias de fragmentos e adicione em vez de substituir e remover

    FragA  fa= new FragA();
    FragB  fb= new FragB();
    FragC  fc= new FragB();
    fragmentManager = getSupportFragmentManager();
    fragmentTransaction = fragmentManager.beginTransaction();
    fragmentTransaction.add(R.id.fragmnt_container, fa);
    fragmentTransaction.add(R.id.fragmnt_container, fb);
    fragmentTransaction.add(R.id.fragmnt_container, fc);
    fragmentTransaction.show(fa);
    fragmentTransaction.hide(fb);
    fragmentTransaction.hide(fc);
    fragmentTransaction.commit();

Em seguida, apenas mostre e oculte os fragmentos em vez de adicioná-los e removê-los novamente

    fragmentTransaction = fragmentManager.beginTransaction();
    fragmentTransaction.hide(fa);
    fragmentTransaction.show(fb);
    fragmentTransaction.hide(fc);
    fragmentTransaction.commit()

;

private ViewPager viewPager;
viewPager = (ViewPager) findViewById(R.id.pager);
mAdapter = new TabsPagerAdapter(getSupportFragmentManager());
viewPager.setAdapter(mAdapter);
viewPager.setOnPageChangeListener(new ViewPager.OnPageChangeListener() {

        @Override
        public void onPageSelected(int position) {
            // on changing the page
            // make respected tab selected
            actionBar.setSelectedNavigationItem(position);
        }

        @Override
        public void onPageScrolled(int arg0, float arg1, int arg2) {
        }

        @Override
        public void onPageScrollStateChanged(int arg0) {
        }
    });
}

@Override
public void onTabReselected(Tab tab, FragmentTransaction ft) {
}

@Override
public void onTabSelected(Tab tab, FragmentTransaction ft) {
    // on tab selected
    // show respected fragment view
    viewPager.setCurrentItem(tab.getPosition());
}

@Override
public void onTabUnselected(Tab tab, FragmentTransaction ft) {
}