Pisahkan Stack Kembali untuk setiap tab di Android menggunakan Fragmen

Saya mencoba menerapkan tab untuk navigasi di aplikasi Android. Karena TabActivity dan ActivityGroup sudah tidak digunakan lagi, saya ingin mengimplementasikannya menggunakan Fragmen.

Saya tahu cara mengatur satu fragmen untuk setiap tab dan kemudian beralih fragmen ketika tab diklik. Tetapi bagaimana saya bisa memiliki tumpukan belakang terpisah untuk setiap tab?

Sebagai contoh, Fragmen A dan B akan berada di bawah Tab 1 dan Fragmen C dan D di bawah Tab 2. Ketika aplikasi dimulai, Fragmen A ditampilkan dan Tab 1 dipilih. Kemudian Fragmen A mungkin diganti dengan Fragmen B. Ketika Tab 2 dipilih, Fragmen C harus ditampilkan. Jika Tab 1 kemudian dipilih Fragmen B harus sekali lagi ditampilkan. Pada titik ini, dimungkinkan untuk menggunakan tombol kembali untuk menampilkan Fragmen A.

Juga, penting bahwa keadaan untuk setiap tab dipertahankan ketika perangkat diputar.

BR Martin

Kerangka kerja saat ini tidak akan melakukan ini untuk Anda secara otomatis. Anda perlu membuat dan mengelola tumpukan belakang Anda sendiri untuk setiap tab.

Sejujurnya, ini sepertinya hal yang sangat dipertanyakan untuk dilakukan. Saya tidak dapat membayangkannya menghasilkan UI yang layak - jika tombol kembali akan melakukan hal-hal yang berbeda tergantung pada tab saya, terutama jika tombol kembali juga memiliki perilaku normal untuk menutup seluruh aktivitas ketika di bagian atas tumpukan ... kedengarannya buruk.

Jika Anda mencoba untuk membangun sesuatu seperti UI browser web, untuk mendapatkan UX yang alami bagi pengguna akan melibatkan banyak perubahan perilaku halus tergantung pada konteksnya, jadi Anda pasti perlu melakukan back stack Anda sendiri manajemen daripada mengandalkan beberapa implementasi standar dalam kerangka kerja. Sebagai contoh coba perhatikan bagaimana tombol kembali berinteraksi dengan browser standar dalam berbagai cara Anda dapat masuk dan keluar dari itu. (Setiap "jendela" di browser pada dasarnya adalah sebuah tab.)

Saya sangat terlambat untuk pertanyaan ini. Tetapi karena utas ini sangat informatif dan membantu saya, saya pikir lebih baik saya mengirim dua pence saya di sini.

Saya membutuhkan aliran layar seperti ini (Desain minimalis dengan 2 tab dan 2 tampilan di setiap tab),

tabA
    ->  ScreenA1, ScreenA2
tabB
    ->  ScreenB1, ScreenB2

Saya memiliki persyaratan yang sama di masa lalu, dan saya melakukannya menggunakan TabActivityGroup(yang sudah usang pada saat itu juga) dan Kegiatan. Kali ini saya ingin menggunakan Fragmen.

Jadi ini adalah bagaimana saya melakukannya.

1. Buat Kelas Fragmen dasar

public class BaseFragment extends Fragment {
    AppMainTabActivity mActivity;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mActivity = (AppMainTabActivity) this.getActivity();
    }

    public void onBackPressed(){
    }

    public void onActivityResult(int requestCode, int resultCode, Intent data){
    }
}

Semua fragmen di aplikasi Anda dapat memperluas kelas Basis ini. Jika Anda ingin menggunakan fragmen khusus seperti ListFragmentAnda harus membuat kelas dasar untuk itu juga. Anda akan jelas tentang penggunaan onBackPressed()dan onActivityResult()jika Anda membaca posting secara penuh ..

2. Buat beberapa pengidentifikasi Tab, dapat diakses di mana saja dalam proyek

public class AppConstants{
    public static final String TAB_A  = "tab_a_identifier";
    public static final String TAB_B  = "tab_b_identifier";

    //Your other constants, if you have them..
}

tidak ada yang bisa dijelaskan di sini ..

3. Oke, Aktivitas Tab Utama - Silakan lihat komentar dalam kode ..

public class AppMainFragmentActivity extends FragmentActivity{
    /* Your Tab host */
    private TabHost mTabHost;

    /* A HashMap of stacks, where we use tab identifier as keys..*/
    private HashMap<String, Stack<Fragment>> mStacks;

    /*Save current tabs identifier in this..*/
    private String mCurrentTab;

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.app_main_tab_fragment_layout);

        /*  
         *  Navigation stacks for each tab gets created.. 
         *  tab identifier is used as key to get respective stack for each tab
         */
        mStacks             =   new HashMap<String, Stack<Fragment>>();
        mStacks.put(AppConstants.TAB_A, new Stack<Fragment>());
        mStacks.put(AppConstants.TAB_B, new Stack<Fragment>());

        mTabHost                =   (TabHost)findViewById(android.R.id.tabhost);
        mTabHost.setOnTabChangedListener(listener);
        mTabHost.setup();

        initializeTabs();
    }


    private View createTabView(final int id) {
        View view = LayoutInflater.from(this).inflate(R.layout.tabs_icon, null);
        ImageView imageView =   (ImageView) view.findViewById(R.id.tab_icon);
        imageView.setImageDrawable(getResources().getDrawable(id));
        return view;
    }

    public void initializeTabs(){
        /* Setup your tab icons and content views.. Nothing special in this..*/
        TabHost.TabSpec spec    =   mTabHost.newTabSpec(AppConstants.TAB_A);
        mTabHost.setCurrentTab(-3);
        spec.setContent(new TabHost.TabContentFactory() {
            public View createTabContent(String tag) {
                return findViewById(R.id.realtabcontent);
            }
        });
        spec.setIndicator(createTabView(R.drawable.tab_home_state_btn));
        mTabHost.addTab(spec);


        spec                    =   mTabHost.newTabSpec(AppConstants.TAB_B);
        spec.setContent(new TabHost.TabContentFactory() {
            public View createTabContent(String tag) {
                return findViewById(R.id.realtabcontent);
            }
        });
        spec.setIndicator(createTabView(R.drawable.tab_status_state_btn));
        mTabHost.addTab(spec);
    }


    /*Comes here when user switch tab, or we do programmatically*/
    TabHost.OnTabChangeListener listener    =   new TabHost.OnTabChangeListener() {
      public void onTabChanged(String tabId) {
        /*Set current tab..*/
        mCurrentTab                     =   tabId;

        if(mStacks.get(tabId).size() == 0){
          /*
           *    First time this tab is selected. So add first fragment of that tab.
           *    Dont need animation, so that argument is false.
           *    We are adding a new fragment which is not present in stack. So add to stack is true.
           */
          if(tabId.equals(AppConstants.TAB_A)){
            pushFragments(tabId, new AppTabAFirstFragment(), false,true);
          }else if(tabId.equals(AppConstants.TAB_B)){
            pushFragments(tabId, new AppTabBFirstFragment(), false,true);
          }
        }else {
          /*
           *    We are switching tabs, and target tab is already has atleast one fragment. 
           *    No need of animation, no need of stack pushing. Just show the target fragment
           */
          pushFragments(tabId, mStacks.get(tabId).lastElement(), false,false);
        }
      }
    };


    /* Might be useful if we want to switch tab programmatically, from inside any of the fragment.*/
    public void setCurrentTab(int val){
          mTabHost.setCurrentTab(val);
    }


    /* 
     *      To add fragment to a tab. 
     *  tag             ->  Tab identifier
     *  fragment        ->  Fragment to show, in tab identified by tag
     *  shouldAnimate   ->  should animate transaction. false when we switch tabs, or adding first fragment to a tab
     *                      true when when we are pushing more fragment into navigation stack. 
     *  shouldAdd       ->  Should add to fragment navigation stack (mStacks.get(tag)). false when we are switching tabs (except for the first time)
     *                      true in all other cases.
     */
    public void pushFragments(String tag, Fragment fragment,boolean shouldAnimate, boolean shouldAdd){
      if(shouldAdd)
          mStacks.get(tag).push(fragment);
      FragmentManager   manager         =   getSupportFragmentManager();
      FragmentTransaction ft            =   manager.beginTransaction();
      if(shouldAnimate)
          ft.setCustomAnimations(R.anim.slide_in_right, R.anim.slide_out_left);
      ft.replace(R.id.realtabcontent, fragment);
      ft.commit();
    }


    public void popFragments(){
      /*    
       *    Select the second last fragment in current tab's stack.. 
       *    which will be shown after the fragment transaction given below 
       */
      Fragment fragment             =   mStacks.get(mCurrentTab).elementAt(mStacks.get(mCurrentTab).size() - 2);

      /*pop current fragment from stack.. */
      mStacks.get(mCurrentTab).pop();

      /* We have the target fragment in hand.. Just show it.. Show a standard navigation animation*/
      FragmentManager   manager         =   getSupportFragmentManager();
      FragmentTransaction ft            =   manager.beginTransaction();
      ft.setCustomAnimations(R.anim.slide_in_left, R.anim.slide_out_right);
      ft.replace(R.id.realtabcontent, fragment);
      ft.commit();
    }   


    @Override
    public void onBackPressed() {
        if(mStacks.get(mCurrentTab).size() == 1){
          // We are already showing first fragment of current tab, so when back pressed, we will finish this activity..
          finish();
          return;
        }

        /*  Each fragment represent a screen in application (at least in my requirement, just like an activity used to represent a screen). So if I want to do any particular action
         *  when back button is pressed, I can do that inside the fragment itself. For this I used AppBaseFragment, so that each fragment can override onBackPressed() or onActivityResult()
         *  kind of events, and activity can pass it to them. Make sure just do your non navigation (popping) logic in fragment, since popping of fragment is done here itself.
         */
        ((AppBaseFragment)mStacks.get(mCurrentTab).lastElement()).onBackPressed();

        /* Goto previous fragment in navigation stack of this tab */
            popFragments();
    }


    /*
     *   Imagine if you wanted to get an image selected using ImagePicker intent to the fragment. Ofcourse I could have created a public function
     *  in that fragment, and called it from the activity. But couldn't resist myself.
     */
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if(mStacks.get(mCurrentTab).size() == 0){
            return;
        }

        /*Now current fragment on screen gets onActivityResult callback..*/
        mStacks.get(mCurrentTab).lastElement().onActivityResult(requestCode, resultCode, data);
    }
}

4. app_main_tab_fragment_layout.xml (Jika ada yang tertarik.)

<?xml version="1.0" encoding="utf-8"?>
<TabHost
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@android:id/tabhost"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">

    <LinearLayout
        android:orientation="vertical"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent">

        <FrameLayout
            android:id="@android:id/tabcontent"
            android:layout_width="0dp"
            android:layout_height="0dp"
            android:layout_weight="0"/>

        <FrameLayout
            android:id="@+android:id/realtabcontent"
            android:layout_width="fill_parent"
            android:layout_height="0dp"
            android:layout_weight="1"/>

        <TabWidget
            android:id="@android:id/tabs"
            android:orientation="horizontal"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:layout_weight="0"/>

    </LinearLayout>
</TabHost>

5. AppTabAFirstFragment.java (Fragmen pertama di Tab A, serupa untuk semua Tab)

public class AppTabAFragment extends BaseFragment {
    private Button mGotoButton;

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

        mGoToButton =   (Button) view.findViewById(R.id.goto_button);
        mGoToButton.setOnClickListener(listener);

        return view;
    }

    private OnClickListener listener        =   new View.OnClickListener(){
        @Override
        public void onClick(View v){
            /* Go to next fragment in navigation stack*/
            mActivity.pushFragments(AppConstants.TAB_A, new AppTabAFragment2(),true,true);
        }
    }
}

Ini mungkin bukan cara yang paling halus dan benar. Tapi itu berhasil dengan baik dalam kasus saya. Juga saya hanya memiliki persyaratan ini dalam mode potret. Saya tidak pernah harus menggunakan kode ini dalam proyek yang mendukung kedua orientasi. Jadi tidak bisa mengatakan tantangan apa yang saya hadapi di sana ..

EDIT:

Jika ada yang menginginkan proyek penuh, saya telah mendorong proyek sampel ke github .

Kami harus menerapkan perilaku yang persis sama dengan yang Anda gambarkan untuk aplikasi baru-baru ini. Layar dan aliran keseluruhan aplikasi sudah ditentukan sehingga kami harus tetap menggunakannya (ini adalah tiruan aplikasi iOS ...). Untungnya, kami berhasil menyingkirkan tombol kembali di layar :)

Kami meretas solusi menggunakan campuran TabActivity, FragmentActivities (kami menggunakan perpustakaan dukungan untuk fragmen) dan Fragmen. Dalam retrospektif, saya cukup yakin itu bukan keputusan arsitektur terbaik, tetapi kami berhasil membuat hal itu berfungsi. Jika saya harus melakukannya lagi, saya mungkin akan mencoba untuk melakukan solusi berbasis aktivitas yang lebih (tidak ada fragmen), atau mencoba dan hanya memiliki satu Kegiatan untuk tab dan membiarkan semua yang lain dilihat (yang saya temukan jauh lebih banyak dapat digunakan kembali daripada aktivitas keseluruhan).

Jadi persyaratannya adalah memiliki beberapa tab dan layar yang bisa di-nestable di setiap tab:

tab 1
  screen 1 -> screen 2 -> screen 3
tab 2
  screen 4
tab 3
  screen 5 -> 6

dll ...

Jadi katakan: pengguna mulai pada tab 1, menavigasi dari layar 1 ke layar 2 lalu ke layar 3, ia kemudian beralih ke tab 3 dan menavigasi dari layar 4 hingga 6; jika beralih kembali ke tab 1, ia harus melihat layar 3 lagi dan jika ia menekan Kembali ia harus kembali ke layar 2; Kembali lagi dan dia ada di layar 1; beralih ke tab 3 dan dia ada di layar 6 lagi.

Aktivitas utama dalam aplikasi adalah MainTabActivity, yang memperluas TabActivity. Setiap tab dikaitkan dengan suatu aktivitas, katakanlah ActivityInTab1, 2 dan 3. Dan kemudian setiap layar akan menjadi sebuah fragmen:

MainTabActivity
  ActivityInTab1
    Fragment1 -> Fragment2 -> Fragment3
  ActivityInTab2
    Fragment4
  ActivityInTab3
    Fragment5 -> Fragment6

Setiap ActivityInTab hanya memegang satu fragmen pada satu waktu, dan tahu bagaimana cara mengganti satu fragmen dengan yang lain (hampir sama dengan ActvityGroup). Yang keren adalah cukup mudah untuk menjaga tumpukan back terpisah untuk setiap tab dengan cara ini.

Fungsionalitas untuk setiap ActivityInTab cukup sama: tahu cara menavigasi dari satu fragmen ke fragmen lain dan mempertahankan tumpukan belakang, jadi kami menempatkannya di kelas dasar. Sebut saja ActivityInTab:

abstract class ActivityInTab extends FragmentActivity { // FragmentActivity is just Activity for the support library.

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_in_tab);
    }

    /**
     * Navigates to a new fragment, which is added in the fragment container
     * view.
     * 
     * @param newFragment
     */
    protected void navigateTo(Fragment newFragment) {
        FragmentManager manager = getSupportFragmentManager();
        FragmentTransaction ft = manager.beginTransaction();

        ft.replace(R.id.content, newFragment);

        // Add this transaction to the back stack, so when the user presses back,
        // it rollbacks.
        ft.addToBackStack(null);
        ft.commit();
    }

}

Activity_in_tab.xml hanya ini:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/content"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:isScrollContainer="true">
</RelativeLayout>

Seperti yang Anda lihat, tata letak tampilan untuk setiap tab adalah sama. Itu karena itu hanya konten yang disebut FrameLayout yang akan menampung setiap fragmen. Fragmen adalah yang memiliki tampilan layar masing-masing.

Hanya untuk poin bonus, kami juga menambahkan beberapa kode kecil untuk menampilkan dialog konfirmasi ketika pengguna menekan Kembali dan tidak ada lagi fragmen untuk kembali ke:

// In ActivityInTab.java...
@Override
public void onBackPressed() {
    FragmentManager manager = getSupportFragmentManager();
    if (manager.getBackStackEntryCount() > 0) {
        // If there are back-stack entries, leave the FragmentActivity
        // implementation take care of them.
        super.onBackPressed();
    } else {
        // Otherwise, ask user if he wants to leave :)
        showExitDialog();
    }
}

Cukup banyak pengaturannya. Seperti yang Anda lihat, masing-masing FragmentActivity (atau hanya aktivitas di Android> 3) mengurus semua penumpukan kembali dengan FragmentManager itu sendiri.

Aktivitas seperti ActivityInTab1 akan sangat sederhana, itu hanya akan menunjukkan fragmen pertama (yaitu layar):

public class ActivityInTab1 extends ActivityInTab {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        navigateTo(new Fragment1());
    }
}

Kemudian, jika sebuah fragmen perlu bernavigasi ke fragmen lain, ia harus melakukan casting yang tidak menyenangkan ... tapi itu tidak terlalu buruk:

// In Fragment1.java for example...
// Need to navigate to Fragment2.
((ActivityIntab) getActivity()).navigateTo(new Fragment2());

Jadi cukup banyak. Saya cukup yakin ini bukan solusi yang sangat kanonik (dan sebagian besar tentu tidak sangat baik), jadi saya ingin bertanya kepada pengembang Android berpengalaman apa yang akan menjadi pendekatan yang lebih baik untuk mencapai fungsi ini, dan jika ini bukan "bagaimana ini" dilakukan" di Android, saya akan menghargai jika Anda bisa mengarahkan saya ke beberapa link atau materi yang menjelaskan yang satu cara Android untuk pendekatan ini (tab, layar bersarang di tab, dll). Silakan merobek jawaban ini di komentar :)

Sebagai tanda bahwa solusi ini tidak terlalu baik adalah bahwa baru-baru ini saya harus menambahkan beberapa fungsi navigasi ke aplikasi. Beberapa tombol aneh yang harus membawa pengguna dari satu tab ke tab lain dan ke layar bersarang. Melakukan hal itu secara terprogram adalah rasa sakit di pantat, karena siapa-tahu-siapa masalah dan berurusan dengan kapan fragmen dan kegiatan sebenarnya dipakai dan diinisialisasi. Saya pikir itu akan jauh lebih mudah jika layar dan tab itu semua benar-benar hanya Tampilan.

Terakhir, jika Anda perlu selamat dari perubahan orientasi, penting bahwa fragmen Anda dibuat menggunakan setArguments / getArguments. Jika Anda menetapkan variabel contoh di konstruktor fragmen Anda, Anda akan kacau. Tapi untungnya itu sangat mudah diperbaiki: cukup simpan semuanya di setArguments di konstruktor dan kemudian ambil hal-hal itu dengan getArguments di onCreate untuk menggunakannya.

Ini dapat dengan mudah dicapai dengan ChildFragmentManager

Berikut adalah pos tentang ini dengan proyek terkait. Lihatlah,

http://tausiq.wordpress.com/2014/06/06/android-multiple-fragments-stack-in-each-viewpager-tab/

Menyimpan referensi kuat untuk fragmen bukan cara yang benar.

FragmentManager menyediakan putFragment(Bundle, String, Fragment)dan saveFragmentInstanceState(Fragment).

Salah satu sudah cukup untuk menerapkan backstack.

Dengan menggunakan putFragment, alih-alih mengganti Fragmen, Anda melepaskan yang lama dan menambahkan yang baru. Inilah yang dilakukan kerangka kerja untuk mengganti transaksi yang ditambahkan ke backstack. putFragmentmenyimpan indeks ke daftar Fragmen aktif saat ini dan Fragmen tersebut disimpan oleh kerangka kerja selama perubahan orientasi.

Cara kedua, menggunakan saveFragmentInstanceState, menyimpan seluruh status fragmen ke Bundel memungkinkan Anda untuk benar-benar menghapusnya, daripada melepaskannya. Menggunakan pendekatan ini membuat tumpukan belakang lebih mudah untuk dimanipulasi, karena Anda dapat memunculkan Fragmen kapan pun Anda mau.

Saya menggunakan metode kedua untuk usecase ini:

SignInFragment ----> SignUpFragment ---> ChooseBTDeviceFragment
               \                          /
                \------------------------/

Saya tidak ingin pengguna kembali ke layar Daftar, dari yang ketiga, dengan menekan tombol kembali. Saya juga melakukan animasi flip di antara mereka (menggunakan onCreateAnimation), sehingga solusi hacky tidak akan berfungsi, minimal tanpa pengguna jelas melihat ada sesuatu yang tidak benar.

Ini adalah kasus penggunaan yang valid untuk backstack khusus, melakukan apa yang diharapkan pengguna ...

private static final String STATE_BACKSTACK = "SetupActivity.STATE_BACKSTACK";

private MyBackStack mBackStack;

@Override
protected void onCreate(Bundle state) {
    super.onCreate(state);

    if (state == null) {
        mBackStack = new MyBackStack();

        FragmentManager fm = getSupportFragmentManager();
        FragmentTransaction tr = fm.beginTransaction();
        tr.add(R.id.act_base_frg_container, new SignInFragment());
        tr.commit();
    } else {
        mBackStack = state.getParcelable(STATE_BACKSTACK);
    }
}

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putParcelable(STATE_BACKSTACK, mBackStack);
}

private void showFragment(Fragment frg, boolean addOldToBackStack) {
    final FragmentManager fm = getSupportFragmentManager();
    final Fragment oldFrg = fm.findFragmentById(R.id.act_base_frg_container);

    FragmentTransaction tr = fm.beginTransaction();
    tr.replace(R.id.act_base_frg_container, frg);
    // This is async, the fragment will only be removed after this returns
    tr.commit();

    if (addOldToBackStack) {
        mBackStack.push(fm, oldFrg);
    }
}

@Override
public void onBackPressed() {
    MyBackStackEntry entry;
    if ((entry = mBackStack.pop()) != null) {
        Fragment frg = entry.recreate(this);

        FragmentManager fm = getSupportFragmentManager();
        FragmentTransaction tr = fm.beginTransaction();
        tr.replace(R.id.act_base_frg_container, frg);
        tr.commit();

        // Pop it now, like the framework implementation.
        fm.executePendingTransactions();
    } else {
        super.onBackPressed();
    }
}

public class MyBackStack implements Parcelable {

    private final List<MyBackStackEntry> mList;

    public MyBackStack() {
        mList = new ArrayList<MyBackStackEntry>(4);
    }

    public void push(FragmentManager fm, Fragment frg) {
        push(MyBackStackEntry.newEntry(fm, frg);
    }

    public void push(MyBackStackEntry entry) {
        if (entry == null) {
            throw new NullPointerException();
        }
        mList.add(entry);
    }

    public MyBackStackEntry pop() {
        int idx = mList.size() - 1;
        return (idx != -1) ? mList.remove(idx) : null;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        final int len = mList.size();
        dest.writeInt(len);
        for (int i = 0; i < len; i++) {
            // MyBackStackEntry's class is final, theres no
            // need to use writeParcelable
            mList.get(i).writeToParcel(dest, flags);
        }
    }

    protected MyBackStack(Parcel in) {
        int len = in.readInt();
        List<MyBackStackEntry> list = new ArrayList<MyBackStackEntry>(len);
        for (int i = 0; i < len; i++) {
            list.add(MyBackStackEntry.CREATOR.createFromParcel(in));
        }
        mList = list;
    }

    public static final Parcelable.Creator<MyBackStack> CREATOR =
        new Parcelable.Creator<MyBackStack>() {

            @Override
            public MyBackStack createFromParcel(Parcel in) {
                return new MyBackStack(in);
            }

            @Override
            public MyBackStack[] newArray(int size) {
                return new MyBackStack[size];
            }
    };
}

public final class MyBackStackEntry implements Parcelable {

    public final String fname;
    public final Fragment.SavedState state;
    public final Bundle arguments;

    public MyBackStackEntry(String clazz, 
            Fragment.SavedState state,
            Bundle args) {
        this.fname = clazz;
        this.state = state;
        this.arguments = args;
    }

    public static MyBackStackEntry newEntry(FragmentManager fm, Fragment frg) {
        final Fragment.SavedState state = fm.saveFragmentInstanceState(frg);
        final String name = frg.getClass().getName();
        final Bundle args = frg.getArguments();
        return new MyBackStackEntry(name, state, args);
    }

    public Fragment recreate(Context ctx) {
        Fragment frg = Fragment.instantiate(ctx, fname);
        frg.setInitialSavedState(state);
        frg.setArguments(arguments);
        return frg;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(fname);
        dest.writeBundle(arguments);

        if (state == null) {
            dest.writeInt(-1);
        } else if (state.getClass() == Fragment.SavedState.class) {
            dest.writeInt(0);
            state.writeToParcel(dest, flags);
        } else {
            dest.writeInt(1);
            dest.writeParcelable(state, flags);
        }
    }

    protected MyBackStackEntry(Parcel in) {
        final ClassLoader loader = getClass().getClassLoader();
        fname = in.readString();
        arguments = in.readBundle(loader);

        switch (in.readInt()) {
            case -1:
                state = null;
                break;
            case 0:
                state = Fragment.SavedState.CREATOR.createFromParcel(in);
                break;
            case 1:
                state = in.readParcelable(loader);
                break;
            default:
                throw new IllegalStateException();
        }
    }

    public static final Parcelable.Creator<MyBackStackEntry> CREATOR =
        new Parcelable.Creator<MyBackStackEntry>() {

            @Override
            public MyBackStackEntry createFromParcel(Parcel in) {
                return new MyBackStackEntry(in);
            }

            @Override
            public MyBackStackEntry[] newArray(int size) {
                return new MyBackStackEntry[size];
            }
    };
}

Penolakan:

Saya merasa ini adalah tempat terbaik untuk mengirim solusi terkait yang telah saya kerjakan untuk jenis masalah serupa yang tampaknya merupakan barang standar Android. Ini tidak akan menyelesaikan masalah untuk semua orang, tetapi mungkin membantu beberapa orang.

Jika perbedaan utama antara fragmen Anda hanya data yang mencadangkannya (yaitu, tidak banyak perbedaan tata letak yang besar), maka Anda mungkin tidak perlu benar-benar mengganti fragmen, tetapi hanya menukar data yang mendasarinya dan menyegarkan tampilan.

Berikut ini deskripsi dari satu contoh yang mungkin untuk pendekatan ini:

Saya memiliki aplikasi yang menggunakan ListViews. Setiap item dalam daftar adalah orang tua dengan sejumlah anak. Saat Anda mengetuk item, daftar baru harus dibuka dengan anak-anak itu, dalam tab ActionBar yang sama dengan daftar aslinya. Daftar bersarang ini memiliki tata letak yang sangat mirip (beberapa penyesuaian bersyarat di sana-sini mungkin), tetapi datanya berbeda.

Aplikasi ini memiliki beberapa lapisan keturunan di bawah daftar induk awal dan kami mungkin atau mungkin tidak memiliki data dari server pada saat pengguna mencoba mengakses kedalaman tertentu di luar yang pertama. Karena daftar dibuat dari kursor basis data, dan fragmen menggunakan loader kursor dan adaptor kursor untuk mengisi tampilan daftar dengan item daftar, semua yang perlu terjadi ketika klik terdaftar adalah:

1) Buat adaptor baru dengan bidang 'ke' dan 'dari' yang sesuai yang akan cocok dengan tampilan item baru yang ditambahkan ke daftar dan kolom dikembalikan oleh kursor baru.

2) Tetapkan adaptor ini sebagai adaptor baru untuk ListView.

3) Bangun URI baru berdasarkan item yang diklik dan mulai ulang pemuat kursor dengan URI baru (dan proyeksi). Dalam contoh ini, URI dipetakan ke permintaan tertentu dengan argumen pilihan diturunkan dari UI.

4) Ketika data baru telah dimuat dari URI, tukar kursor yang terkait dengan adaptor ke kursor baru, dan daftar kemudian akan di-refresh.

Tidak ada backstack yang terkait dengan ini karena kami tidak menggunakan transaksi, jadi Anda harus membuat sendiri, atau memutar kueri secara terbalik saat mundur dari hierarki. Ketika saya mencoba ini, pertanyaannya cukup cepat sehingga saya hanya menjalankannya lagi di oNBackPressed () hingga saya berada di puncak hierarki, pada titik mana kerangka kerja mengambil alih tombol kembali lagi.

Jika Anda menemukan diri Anda dalam situasi yang sama, pastikan untuk membaca dokumen: http://developer.android.com/guide/topics/ui/layout/listview.html

http://developer.android.com/reference/android/support/v4/app/LoaderManager.LoaderCallbacks.html

Saya harap ini membantu seseorang!

Saya memiliki masalah yang persis sama dan mengimplementasikan proyek github open source yang mencakup tab yang ditumpuk, navigasi kembali ke atas dan diuji dan didokumentasikan dengan baik:

https://github.com/SebastianBaltesObjectCode/PersistentFragmentTabs

Ini adalah kerangka kerja sederhana dan kecil untuk tab navigasi dan pengalihan fragmen dan penanganan navigasi atas dan belakang. Setiap tab memiliki tumpukan fragmen sendiri. Ini menggunakan ActionBarSherlock dan kompatibel kembali ke API level 8.

Ini adalah masalah yang kompleks karena Android hanya menangani 1 back stack, tetapi ini layak. Butuh waktu berhari-hari untuk membuat perpustakaan bernama Tab Stacker yang melakukan persis seperti yang Anda cari: riwayat fragmen untuk setiap tab. Ini adalah open source dan sepenuhnya didokumentasikan, dan dapat dimasukkan dengan mudah dengan gradle. Anda dapat menemukan perpustakaan di github: https://github.com/smart-fun/TabStacker

Anda juga dapat mengunduh aplikasi sampel untuk melihat bahwa perilaku tersebut sesuai dengan kebutuhan Anda:

https://play.google.com/apps/testing/fr.arnaudguyon.tabstackerapp

Jika Anda memiliki pertanyaan jangan ragu untuk mengirim email.

Saya ingin menyarankan solusi saya sendiri jika seseorang mencari dan ingin mencoba dan memilih yang terbaik untuk kebutuhannya.

https://github.com/drusak/tabactivity

Tujuan membuat perpustakaan cukup dangkal - mengimplementasikannya seperti iPhone.

Keuntungan utama:

• gunakan pustaka android.support.design dengan TabLayout;
• setiap tab memiliki tumpukan sendiri menggunakan FragmentManager (tanpa menyimpan referensi fragmen);
• dukungan untuk tautan dalam (ketika Anda perlu membuka tab tertentu dan level fragmen tertentu di dalamnya);
• menyimpan / mengembalikan status tab;
• metode siklus fragmen adaptif dalam tab;
• cukup mudah diimplementasikan untuk kebutuhan Anda.

Solusi sederhana:

Setiap kali Anda mengubah panggilan tampilan tab / root:

fragmentManager.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);

Ini akan menghapus BackStack. Ingat untuk memanggil ini sebelum Anda mengubah fragmen root.

Dan tambahkan fragmen dengan ini:

FragmentTransaction transaction = getFragmentManager().beginTransaction();
NewsDetailsFragment newsDetailsFragment = NewsDetailsFragment.newInstance(newsId);
transaction.add(R.id.content_frame, newsDetailsFragment).addToBackStack(null).commit();

Perhatikan .addToBackStack(null)dan transaction.addmisalnya dapat diubah dengan transaction.replace.

Utas ini sangat sangat menarik dan bermanfaat.
Terima kasih Krishnabhadra untuk penjelasan dan kode Anda, saya menggunakan kode Anda dan sedikit ditingkatkan, memungkinkan untuk bertahan tumpukan, currentTab, dll ... dari perubahan konfigurasi (berputar terutama).
Diuji pada perangkat nyata 4.0.4 dan 2.3.6, tidak diuji pada emulator

Saya mengubah bagian kode ini pada "AppMainTabActivity.java", sisanya tetap sama. Mungkin Krishnabhadra akan menambahkan ini pada kodenya.

Pulihkan data onCreate:

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.app_main_tab_fragment_layout);

    /*  
     *  Navigation stacks for each tab gets created..
     *  tab identifier is used as key to get respective stack for each tab
     */

  //if we are recreating this activity...
    if (savedInstanceState!=null) {
         mStacks = (HashMap<String, Stack<Fragment>>) savedInstanceState.get("stack");
         mCurrentTab = savedInstanceState.getString("currentTab");
    }
    else {
    mStacks = new HashMap<String, Stack<Fragment>>();
    mStacks.put(AppConstants.TAB_A, new Stack<Fragment>());
    mStacks.put(AppConstants.TAB_B, new Stack<Fragment>());

    }

    mTabHost = (TabHost)findViewById(android.R.id.tabhost);
    mTabHost.setup();

    initializeTabs();

  //set the listener the last, to avoid overwrite mCurrentTab everytime we add a new Tab
    mTabHost.setOnTabChangedListener(listener);
}

Simpan variabel dan masukkan ke Bundel:

 //Save variables while recreating
@Override
public void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putSerializable("stack", mStacks);
    outState.putString("currentTab", mCurrentTab);
    //outState.putInt("tabHost",mTabHost);
}

Jika ada CurrentTab sebelumnya, atur ini, buat Tab_A baru:

public void initializeTabs(){
    /* Setup your tab icons and content views.. Nothing special in this..*/
    TabHost.TabSpec spec    =   mTabHost.newTabSpec(AppConstants.TAB_A);

    spec.setContent(new TabHost.TabContentFactory() {
        public View createTabContent(String tag) {
            return findViewById(R.id.realtabcontent);
        }
    });
    spec.setIndicator(createTabView(R.drawable.tab_a_state_btn));
    mTabHost.addTab(spec);


    spec                    =   mTabHost.newTabSpec(AppConstants.TAB_B);
    spec.setContent(new TabHost.TabContentFactory() {
        public View createTabContent(String tag) {
            return findViewById(R.id.realtabcontent);
        }
    });
    spec.setIndicator(createTabView(R.drawable.tab_b_state_btn));
    mTabHost.addTab(spec);

//if we have non default Tab as current, change it
    if (mCurrentTab!=null) {
        mTabHost.setCurrentTabByTag(mCurrentTab);
    } else {
        mCurrentTab=AppConstants.TAB_A;
        pushFragments(AppConstants.TAB_A, new AppTabAFirstFragment(), false,true);
    }
}

Saya harap ini membantu orang lain.

Saya akan merekomendasikan jangan menggunakan backstack berdasarkan HashMap> ada banyak bug dalam mode "jangan simpan aktivitas". Itu tidak akan benar mengembalikan keadaan jika Anda dalam tumpukan fragmen. Dan juga akan di-crack dalam fragmen peta bersarang (dengan pengecualian: Fragmen tidak ada tampilan untuk ID). Coz HashMap> setelah aplikasi latar \ foreground akan menjadi nol

Saya mengoptimalkan kode di atas untuk bekerja dengan backstack fragmen

Itu adalah TabView bagian bawah

Kegiatan utama Kelas

import android.app.Activity;
import android.app.Fragment;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.content.Intent;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.Window;
import android.widget.ImageView;
import android.widget.TabHost;
import android.widget.TextView;

import com.strikersoft.nida.R;
import com.strikersoft.nida.abstractActivity.BaseActivity;
import com.strikersoft.nida.screens.tags.mapTab.MapContainerFragment;
import com.strikersoft.nida.screens.tags.searchTab.SearchFragment;
import com.strikersoft.nida.screens.tags.settingsTab.SettingsFragment;

public class TagsActivity extends BaseActivity {
    public static final String M_CURRENT_TAB = "M_CURRENT_TAB";
    private TabHost mTabHost;
    private String mCurrentTab;

    public static final String TAB_TAGS = "TAB_TAGS";
    public static final String TAB_MAP = "TAB_MAP";
    public static final String TAB_SETTINGS = "TAB_SETTINGS";

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getWindow().requestFeature(Window.FEATURE_ACTION_BAR);
        getActionBar().hide();
        setContentView(R.layout.tags_activity);

        mTabHost = (TabHost) findViewById(android.R.id.tabhost);

        mTabHost.setup();

        if (savedInstanceState != null) {
            mCurrentTab = savedInstanceState.getString(M_CURRENT_TAB);
            initializeTabs();
            mTabHost.setCurrentTabByTag(mCurrentTab);
            /*
            when resume state it's important to set listener after initializeTabs
            */
            mTabHost.setOnTabChangedListener(listener);
        } else {
            mTabHost.setOnTabChangedListener(listener);
            initializeTabs();
        }
    }

    private View createTabView(final int id, final String text) {
        View view = LayoutInflater.from(this).inflate(R.layout.tabs_icon, null);
        ImageView imageView = (ImageView) view.findViewById(R.id.tab_icon);
        imageView.setImageDrawable(getResources().getDrawable(id));
        TextView textView = (TextView) view.findViewById(R.id.tab_text);
        textView.setText(text);
        return view;
    }

    /*
    create 3 tabs with name and image
    and add it to TabHost
     */
    public void initializeTabs() {

        TabHost.TabSpec spec;

        spec = mTabHost.newTabSpec(TAB_TAGS);
        spec.setContent(new TabHost.TabContentFactory() {
            public View createTabContent(String tag) {
                return findViewById(R.id.realtabcontent);
            }
        });
        spec.setIndicator(createTabView(R.drawable.tab_tag_drawable, getString(R.string.tab_tags)));
        mTabHost.addTab(spec);

        spec = mTabHost.newTabSpec(TAB_MAP);
        spec.setContent(new TabHost.TabContentFactory() {
            public View createTabContent(String tag) {
                return findViewById(R.id.realtabcontent);
            }
        });
        spec.setIndicator(createTabView(R.drawable.tab_map_drawable, getString(R.string.tab_map)));
        mTabHost.addTab(spec);


        spec = mTabHost.newTabSpec(TAB_SETTINGS);
        spec.setContent(new TabHost.TabContentFactory() {
            public View createTabContent(String tag) {
                return findViewById(R.id.realtabcontent);
            }
        });
        spec.setIndicator(createTabView(R.drawable.tab_settings_drawable, getString(R.string.tab_settings)));
        mTabHost.addTab(spec);

    }

    /*
    first time listener will be trigered immediatelly after first: mTabHost.addTab(spec);
    for set correct Tab in setmTabHost.setCurrentTabByTag ignore first call of listener
    */
    TabHost.OnTabChangeListener listener = new TabHost.OnTabChangeListener() {
        public void onTabChanged(String tabId) {

            mCurrentTab = tabId;

            if (tabId.equals(TAB_TAGS)) {
                pushFragments(SearchFragment.getInstance(), false,
                        false, null);
            } else if (tabId.equals(TAB_MAP)) {
                pushFragments(MapContainerFragment.getInstance(), false,
                        false, null);
            } else if (tabId.equals(TAB_SETTINGS)) {
                pushFragments(SettingsFragment.getInstance(), false,
                        false, null);
            }

        }
    };

/*
Example of starting nested fragment from another fragment:

Fragment newFragment = ManagerTagFragment.newInstance(tag.getMac());
                TagsActivity tAct = (TagsActivity)getActivity();
                tAct.pushFragments(newFragment, true, true, null);
 */
    public void pushFragments(Fragment fragment,
                              boolean shouldAnimate, boolean shouldAdd, String tag) {
        FragmentManager manager = getFragmentManager();
        FragmentTransaction ft = manager.beginTransaction();
        if (shouldAnimate) {
            ft.setCustomAnimations(R.animator.fragment_slide_left_enter,
                    R.animator.fragment_slide_left_exit,
                    R.animator.fragment_slide_right_enter,
                    R.animator.fragment_slide_right_exit);
        }
        ft.replace(R.id.realtabcontent, fragment, tag);

        if (shouldAdd) {
            /*
            here you can create named backstack for realize another logic.
            ft.addToBackStack("name of your backstack");
             */
            ft.addToBackStack(null);
        } else {
            /*
            and remove named backstack:
            manager.popBackStack("name of your backstack", FragmentManager.POP_BACK_STACK_INCLUSIVE);
            or remove whole:
            manager.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);
             */
            manager.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);
        }
        ft.commit();
    }

    /*
    If you want to start this activity from another
     */
    public static void startUrself(Activity context) {
        Intent newActivity = new Intent(context, TagsActivity.class);
        newActivity.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        context.startActivity(newActivity);
        context.finish();
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        outState.putString(M_CURRENT_TAB, mCurrentTab);
        super.onSaveInstanceState(outState);
    }

    @Override
    public void onBackPressed(){
        super.onBackPressed();
    }
}

tags_activity.xml

<

?xml version="1.0" encoding="utf-8"?>
<TabHost
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@android:id/tabhost"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <LinearLayout
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <FrameLayout
            android:id="@android:id/tabcontent"
            android:layout_width="0dp"
            android:layout_height="0dp"
            android:layout_weight="0"/>
        <FrameLayout
            android:id="@+android:id/realtabcontent"
            android:background="@drawable/bg_main_app_gradient"
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1"/>
        <TabWidget
            android:id="@android:id/tabs"
            android:background="#EAE7E1"
            android:orientation="horizontal"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_weight="0"/>
    </LinearLayout>
</TabHost>

tags_icon.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/tabsLayout"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:background="@drawable/bg_tab_gradient"
    android:gravity="center"
    android:orientation="vertical"
    tools:ignore="contentDescription" >

    <ImageView
        android:id="@+id/tab_icon"
        android:layout_marginTop="4dp"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
    <TextView 
        android:id="@+id/tab_text"
        android:layout_marginBottom="3dp"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textColor="@color/tab_text_color"/>

</LinearLayout>