Come posso mantenere lo stato del frammento quando aggiunto allo stack posteriore?

Ho scritto un'attività fittizia che passa tra due frammenti. Quando passi da FragmentA a FragmentB, FragmentA viene aggiunto allo stack posteriore. Tuttavia, quando torno a FragmentA (premendo indietro), viene creato un frammento A completamente nuovo e lo stato in cui si trovava viene perso. Ho la sensazione di cercare la stessa cosa di questa domanda, ma ho incluso un esempio di codice completo per aiutare a risolvere il problema:

public class FooActivity extends Activity {
  @Override public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    final FragmentTransaction transaction = getFragmentManager().beginTransaction();
    transaction.replace(android.R.id.content, new FragmentA());
    transaction.commit();
  }

  public void nextFragment() {
    final FragmentTransaction transaction = getFragmentManager().beginTransaction();
    transaction.replace(android.R.id.content, new FragmentB());
    transaction.addToBackStack(null);
    transaction.commit();
  }

  public static class FragmentA extends Fragment {
    @Override public View onCreateView(LayoutInflater inflater, ViewGroup container,
        Bundle savedInstanceState) {
      final View main = inflater.inflate(R.layout.main, container, false);
      main.findViewById(R.id.next_fragment_button).setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
          ((FooActivity) getActivity()).nextFragment();
        }
      });
      return main;
    }

    @Override public void onSaveInstanceState(Bundle outState) {
      super.onSaveInstanceState(outState);
      // Save some state!
    }
  }

  public static class FragmentB extends Fragment {
    @Override public View onCreateView(LayoutInflater inflater, ViewGroup container,
        Bundle savedInstanceState) {
      return inflater.inflate(R.layout.b, container, false);
    }
  }
}

Con alcuni messaggi di registro aggiunti:

07-05 14:28:59.722 D/OMG     ( 1260): FooActivity.onCreate
07-05 14:28:59.742 D/OMG     ( 1260): FragmentA.onCreateView
07-05 14:28:59.742 D/OMG     ( 1260): FooActivity.onResume
<Tap Button on FragmentA>
07-05 14:29:12.842 D/OMG     ( 1260): FooActivity.nextFragment
07-05 14:29:12.852 D/OMG     ( 1260): FragmentB.onCreateView
<Tap 'Back'>
07-05 14:29:16.792 D/OMG     ( 1260): FragmentA.onCreateView

Non chiama mai FragmentA.onSaveInstanceState e crea un nuovo FragmentA quando rispondi. Tuttavia, se sono su FragmentA e blocco lo schermo, FragmentA.onSaveInstanceState viene chiamato. Così strano ... mi sbaglio nell'aspettarmi che un frammento aggiunto allo stack posteriore non abbia bisogno di essere ricreato? Ecco cosa dicono i documenti :

Considerando che, se si chiama addToBackStack () quando si rimuove un frammento, il frammento viene arrestato e riprenderà se l'utente torna indietro.

Se si ritorna a un frammento dallo stack posteriore, questo non ricrea il frammento ma riutilizza la stessa istanza e inizia con onCreateView()il ciclo di vita del frammento, vedere Ciclo di vita del frammento .

Quindi, se si desidera memorizzare lo stato, è necessario utilizzare le variabili di istanza e non fare affidamento su onSaveInstanceState().

Rispetto a Apple UINavigationControllere UIViewController, Google non funziona bene nell'architettura del software Android. E il documento di Android suFragment non aiuta molto.

Quando si immette FragmentB da FragmentA, l'istanza FragmentA esistente non viene distrutta. Quando premi Back in FragmentB e ritorni su FragmentA, non creiamo una nuova istanza di FragmentA. onCreateView()Verrà chiamata l'istanza di FragmentA esistente .

La cosa fondamentale è che non dovremmo gonfiare di nuovo la vista in FragmentA onCreateView(), perché stiamo usando l'istanza esistente di FragmentA. Dobbiamo salvare e riutilizzare rootView.

Il seguente codice funziona bene. Non solo mantiene lo stato del frammento, ma riduce anche il carico di RAM e CPU (perché gonfiamo il layout solo se necessario). Non posso credere che il codice e il documento di esempio di Google non ne parlino mai, ma gonfiano sempre il layout .

Versione 1 (Non utilizzare la versione 1. Utilizzare la versione 2)

public class FragmentA extends Fragment {
    View _rootView;
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        if (_rootView == null) {
            // Inflate the layout for this fragment
            _rootView = inflater.inflate(R.layout.fragment_a, container, false);
            // Find and setup subviews
            _listView = (ListView)_rootView.findViewById(R.id.listView);
            ...
        } else {
            // Do not inflate the layout again.
            // The returned View of onCreateView will be added into the fragment.
            // However it is not allowed to be added twice even if the parent is same.
            // So we must remove _rootView from the existing parent view group
            // (it will be added back).
            ((ViewGroup)_rootView.getParent()).removeView(_rootView);
        }
        return _rootView;
    }
}

------ Aggiornamento del 3 maggio 2005: -------

Come menzionato nei commenti, a volte _rootView.getParent()è nullo in onCreateView, che causa l'arresto anomalo. La versione 2 rimuove _rootView in onDestroyView (), come suggerito dell116. Testato su Android 4.0.3, 4.4.4, 5.1.0.

Versione 2

public class FragmentA extends Fragment {
    View _rootView;
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        if (_rootView == null) {
            // Inflate the layout for this fragment
            _rootView = inflater.inflate(R.layout.fragment_a, container, false);
            // Find and setup subviews
            _listView = (ListView)_rootView.findViewById(R.id.listView);
            ...
        } else {
            // Do not inflate the layout again.
            // The returned View of onCreateView will be added into the fragment.
            // However it is not allowed to be added twice even if the parent is same.
            // So we must remove _rootView from the existing parent view group
            // in onDestroyView() (it will be added back).
        }
        return _rootView;
    }

    @Override
    public void onDestroyView() {
        if (_rootView.getParent() != null) {
            ((ViewGroup)_rootView.getParent()).removeView(_rootView);
        }
        super.onDestroyView();
    }
}

AVVERTIMENTO!!!

Questo è un HACK! Anche se lo sto usando nella mia app, devi testare e leggere attentamente i commenti.

Immagino che ci sia un modo alternativo per ottenere ciò che stai cercando. Non dico che è una soluzione completa, ma ha servito allo scopo nel mio caso.

Quello che ho fatto è stato invece di sostituire il frammento che ho appena aggiunto il frammento di destinazione. Quindi in pratica userete add()invece il metodo replace().

Cos'altro ho fatto. Nascondo il mio frammento attuale e lo aggiungo anche allo zaino.

Quindi si sovrappone al nuovo frammento sul frammento attuale senza distruggere la sua vista (controlla che il suo onDestroyView()metodo non venga chiamato. Inoltre aggiungendolo a backstatemi dà il vantaggio di riprendere il frammento.

Ecco il codice:

Fragment fragment=new DestinationFragment();
FragmentManager fragmentManager = getFragmentManager();
android.app.FragmentTransaction ft=fragmentManager.beginTransaction();
ft.add(R.id.content_frame, fragment);
ft.hide(SourceFragment.this);
ft.addToBackStack(SourceFragment.class.getName());
ft.commit();

Il sistema AFAIK chiama solo onCreateView()se la vista è distrutta o non creata. Ma qui abbiamo salvato la vista non rimuovendola dalla memoria. Quindi non creerà una nuova vista.

E quando torni da Frammento di destinazione, si aprirà l'ultimo FragmentTransaction frammento superiore rimuovendo che farà apparire la vista più in alto (di SourceFragment) sullo schermo.

COMMENTO: Come ho già detto, non è una soluzione completa in quanto non rimuove la vista del frammento di Source e quindi occupa più memoria del solito. Tuttavia, servire allo scopo. Inoltre, stiamo usando un meccanismo totalmente diverso di nascondere la vista invece di sostituirlo che non è tradizionale.

Quindi non è proprio per come mantieni lo stato, ma per come mantieni la vista.

Suggerirei una soluzione molto semplice.

Prendi la variabile di riferimento Visualizza e imposta la vista in OnCreateView. Controlla se la vista esiste già in questa variabile, quindi restituisci la stessa vista.

   private View fragmentView;

   public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        super.onCreateView(inflater, container, savedInstanceState);

        if (fragmentView != null) {
            return fragmentView;
        }
        View view = inflater.inflate(R.layout.yourfragment, container, false);
        fragmentView = view;
        return view;
    }

Ho riscontrato questo problema in un frammento contenente una mappa, che contiene troppi dettagli di configurazione per salvare / ricaricare. La mia soluzione è stata sostanzialmente quella di mantenere attivo questo frammento per tutto il tempo (in modo simile a quanto menzionato da @kaushal).

Supponi di avere l'attuale frammento A e desideri visualizzare il frammento B. Riassumendo le conseguenze:

• sostituire () - rimuovere il frammento A e sostituirlo con il frammento B. Il frammento A verrà ricreato una volta portato di nuovo in primo piano
• add () - (create and) aggiunge un frammento B e si sovrappone al frammento A, che è ancora attivo in background
• remove () - può essere usato per rimuovere il frammento B e tornare ad A. Il frammento B verrà ricreato quando chiamato in seguito

Quindi, se vuoi mantenere entrambi i frammenti "salvati", basta attivarli usando hide () / show ().

Pro : metodo facile e semplice per mantenere in esecuzione più frammenti
Contro : usi molta più memoria per mantenerli tutti in esecuzione. Potrebbero verificarsi problemi, ad esempio la visualizzazione di molte bitmap di grandi dimensioni

onSaveInstanceState() viene chiamato solo in caso di modifica della configurazione.

Dal momento che il passaggio da un frammento a un altro non è stato apportato alcun cambiamento di configurazione, quindi nessuna chiamata a onSaveInstanceState() è presente . Quale stato non viene salvato? Puoi specificare?

Se inserisci del testo in EditText, questo verrà salvato automaticamente. Qualsiasi elemento dell'interfaccia utente senza ID è l'elemento il cui stato di visualizzazione non deve essere salvato.

Qui, poiché onSaveInstanceStatenel frammento non viene chiamato quando si aggiunge il frammento nel backstack. Il ciclo di vita del frammento nel backstack quando ripristinato inizia onCreateViewe termina onDestroyViewmentre onSaveInstanceStateviene chiamato tra onDestroyViewe onDestroy. La mia soluzione è creare la variabile di istanza e init in onCreate. Codice di esempio:

private boolean isDataLoading = true;
private ArrayList<String> listData;
public void onCreate(Bundle savedInstanceState){
     super.onCreate(savedInstanceState);
     isDataLoading = false;
     // init list at once when create fragment
     listData = new ArrayList();
}

E check in onActivityCreated:

public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    if(isDataLoading){
         fetchData();
    }else{
         //get saved instance variable listData()
    }
}

private void fetchData(){
     // do fetch data into listData
}

getSupportFragmentManager().addOnBackStackChangedListener(new FragmentManager.OnBackStackChangedListener()
    {
        @Override
        public void onBackStackChanged()
        {
            if (getSupportFragmentManager().getBackStackEntryCount() == 0)
            {
                //setToolbarTitle("Main Activity");
            }
            else
            {
                Log.e("fragment_replace11111", "replace");
            }
        }
    });


YourActivity.java
@Override
public void onBackPressed()
{
 Fragment fragment = getSupportFragmentManager().findFragmentById(R.id.Fragment_content);
  if (fragment instanceof YourFragmentName)
    {
        fragmentReplace(new HomeFragment(),"Home Fragment");
        txt_toolbar_title.setText("Your Fragment");
    }
  else{
     super.onBackPressed();
   }
 }


public void fragmentReplace(Fragment fragment, String fragment_name)
{
    try
    {
        fragmentTransaction = fragmentManager.beginTransaction();
        fragmentTransaction.replace(R.id.Fragment_content, fragment, fragment_name);
        fragmentTransaction.setCustomAnimations(R.anim.enter_from_right, R.anim.exit_to_left, R.anim.enter_from_left, R.anim.exit_to_right);
        fragmentTransaction.addToBackStack(fragment_name);
        fragmentTransaction.commitAllowingStateLoss();
    }
    catch (Exception e)
    {
        e.printStackTrace();
    }
}

Il mio problema era simile ma mi ha superato senza mantenere vivo il frammento. Supponiamo di avere un'attività che ha 2 frammenti: F1 e F2. F1 viene avviato inizialmente e consente di dire che contiene alcune informazioni utente e quindi su una condizione F2 si apre chiedendo all'utente di inserire un attributo aggiuntivo : il loro numero di telefono. Successivamente, vuoi che quel numero di telefono ritorni su F1 e completi la registrazione, ma ti rendi conto che tutte le informazioni utente precedenti sono state perse e non hai i loro dati precedenti. Il frammento viene ricreato da zero e anche se si sono salvate queste informazioni nel onSaveInstanceStatebundle, viene restituito null onActivityCreated.

Soluzione: salvare le informazioni richieste come variabile di istanza nell'attività di chiamata. Quindi passa quella variabile di istanza nel tuo frammento.

@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);

    Bundle args = getArguments();

    // this will be null the first time F1 is created. 
    // it will be populated once you replace fragment and provide bundle data
    if (args != null) {
        if (args.get("your_info") != null) {
            // do what you want with restored information
        }
    }
}

Quindi, seguendo il mio esempio: prima di visualizzare F2, salvo i dati utente nella variabile di istanza usando un callback. Quindi avvio F2, l'utente inserisce il numero di telefono e preme Salva. Uso un altro callback in attività, raccolgo queste informazioni e sostituisco il mio frammento F1, questa volta ha i dati del bundle che posso usare.

@Override
public void onPhoneAdded(String phone) {
        //replace fragment
        F1 f1 = new F1 ();
        Bundle args = new Bundle();
        yourInfo.setPhone(phone);
        args.putSerializable("you_info", yourInfo);
        f1.setArguments(args);

        getFragmentManager().beginTransaction()
                .replace(R.id.fragmentContainer, f1).addToBackStack(null).commit();

    }
}

Ulteriori informazioni sui callback sono disponibili qui: https://developer.android.com/training/basics/fragments/communicating.html

primo : basta usare il metodo add invece di sostituire il metodo della classe FragmentTransaction quindi devi aggiungere secondFragment per impilare con il metodo addToBackStack

secondo : al back click devi chiamare popBackStackImmediate ()

Fragment sourceFragment = new SourceFragment ();
final Fragment secondFragment = new SecondFragment();
final FragmentTransaction ft = getChildFragmentManager().beginTransaction();
ft.add(R.id.child_fragment_container, secondFragment );
ft.hide(sourceFragment );
ft.addToBackStack(NewsShow.class.getName());
ft.commit();
                                
((SecondFragment)secondFragment).backFragmentInstanceClick = new SecondFragment.backFragmentNewsResult()
{
        @Override
        public void backFragmentNewsResult()
        {                                    
            getChildFragmentManager().popBackStackImmediate();                                
        }
};

Sostituisci un frammento usando il seguente codice:

Fragment fragment = new AddPaymentFragment();
getSupportFragmentManager().beginTransaction().replace(R.id.frame, fragment, "Tag_AddPayment")
                .addToBackStack("Tag_AddPayment")
                .commit();

OnBackPressed () dell'attività è:

  @Override
public void onBackPressed() {
    android.support.v4.app.FragmentManager fm = getSupportFragmentManager();
    if (fm.getBackStackEntryCount() > 1) {

        fm.popBackStack();
    } else {


        finish();

    }
    Log.e("popping BACKSTRACK===> ",""+fm.getBackStackEntryCount());

}

Public void replaceFragment(Fragment mFragment, int id, String tag, boolean addToStack) {
        FragmentTransaction mTransaction = getSupportFragmentManager().beginTransaction();
        mTransaction.replace(id, mFragment);
        hideKeyboard();
        if (addToStack) {
            mTransaction.addToBackStack(tag);
        }
        mTransaction.commitAllowingStateLoss();
    }
replaceFragment(new Splash_Fragment(), R.id.container, null, false);

Soluzione perfetta che trova il vecchio frammento nello stack e lo carica se esiste nello stack.

/**
     * replace or add fragment to the container
     *
     * @param fragment pass android.support.v4.app.Fragment
     * @param bundle pass your extra bundle if any
     * @param popBackStack if true it will clear back stack
     * @param findInStack if true it will load old fragment if found
     */
    public void replaceFragment(Fragment fragment, @Nullable Bundle bundle, boolean popBackStack, boolean findInStack) {
        FragmentManager fm = getSupportFragmentManager();
        FragmentTransaction ft = fm.beginTransaction();
        String tag = fragment.getClass().getName();
        Fragment parentFragment;
        if (findInStack && fm.findFragmentByTag(tag) != null) {
            parentFragment = fm.findFragmentByTag(tag);
        } else {
            parentFragment = fragment;
        }
        // if user passes the @bundle in not null, then can be added to the fragment
        if (bundle != null)
            parentFragment.setArguments(bundle);
        else parentFragment.setArguments(null);
        // this is for the very first fragment not to be added into the back stack.
        if (popBackStack) {
            fm.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);
        } else {
            ft.addToBackStack(parentFragment.getClass().getName() + "");
        }
        ft.replace(R.id.contenedor_principal, parentFragment, tag);
        ft.commit();
        fm.executePendingTransactions();
    }

usalo come

Fragment f = new YourFragment();
replaceFragment(f, null, boolean true, true);