フラグメントを使用してAndroidの各タブに個別のバックスタック

Question

Androidアプリでナビゲーション用のタブを実装しようとしています。 TabActivityとActivityGroupは廃止されているため、代わりにFragmentsを使用して実装したいと思います。

各タブに1つのフラグメントを設定し、タブをクリックしたときにフラグメントを切り替える方法を知っています。しかし、各タブに個別のバックスタックを設定するにはどうすればよいですか？

たとえば、フラグメントAとBはタブ1の下にあり、フラグメントCとDはタブ2の下にあります。アプリを起動すると、フラグメントAが表示され、タブ1が選択されます。次に、フラグメントAをフラグメントBに置き換えます。タブ2を選択すると、フラグメントCが表示されます。タブ1が選択されている場合、フラグメントBが再び表示されるはずです。この時点で、戻るボタンを使用してフラグメントAを表示できるはずです。

また、デバイスを回転させたときに各タブの状態が維持されることが重要です。

BRマーティン

Answer 1

現在、フレームワークはこれを自動的に行いません。タブごとに独自のバックスタックを構築および管理する必要があります。

正直に言うと、これは本当に疑わしいことのように思えます。それがまともなUIになることを想像することはできません-バックキーが私がいるタブに応じて異なることをする場合、特にバックキーもトップのときにアクティビティ全体を閉じるという通常の動作を持っている場合スタック...厄介に聞こえます。

WebブラウザーUIのようなものを構築しようとしている場合、ユーザーにとって自然なUXを取得するには、コンテキストに応じて多くの微妙な動作調整が必要になるため、独自のバックスタックを行う必要があります。フレームワークのデフォルト実装に依存するのではなく、管理。たとえば、バックキーがさまざまな方法で標準ブラウザとやり取りする方法に注意を払ってみてください。 （ブラウザの各「ウィンドウ」は基本的にタブです。）

Answer 2

私はこの質問にひどく遅れています。しかし、このスレッドは私にとって非常に有益で役に立ちましたので、ここに2ペンスを投稿した方が良いと思いました。

このような画面フロー（各タブに2つのタブと2つのビューがある最小限のデザイン）が必要でした。

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

過去にも同じ要件がありましたが、TabActivityGroup（当時は廃止されました）とアクティビティを使用してそれを行いました。今回はフラグメントを使用したかった。

これが私がやった方法です。

1.ベースフラグメントクラスを作成する

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){
    }
}

アプリのすべてのフラグメントは、この基本クラスを拡張できます。 ListFragmentなどの特別なフラグメントを使用する場合は、そのための基本クラスも作成する必要があります。投稿全体を読むと、onBackPressed()とonActivityResult()の使用法が明確になります。

2.プロジェクトのどこからでもアクセスできるタブ識別子を作成します

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

ここで説明することはありません。

3. OK、メインタブアクティビティ-コードのコメントをご覧ください。

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（誰かが興味がある場合）

<?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（タブAの最初のフラグメント、すべてのタブに類似）

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

これは最も洗練された正しい方法ではないかもしれません。しかし、私の場合はうまく機能しました。また、この要件はポートレートモードでしかありませんでした。両方の方向をサポートするプロジェクトでこのコードを使用する必要はありませんでした。そこで、私がどんな種類の課題に直面しているかは言えません。

編集：

完全なプロジェクトが必要な場合は、サンプルプロジェクトを github にプッシュしました。

Answer 3

最近アプリについて説明したのとまったく同じ動作を実装する必要がありました。画面とアプリケーションの全体的なフローは既に定義されているため、それに固執する必要がありました（iOSアプリのクローンです...）。幸いなことに、画面上の戻るボタンを取り除くことができました:)

TabActivity、FragmentActivities（フラグメントのサポートライブラリを使用していた）、およびFragmentsの混合物を使用してソリューションをハッキングしました。振り返ってみると、それが最良のアーキテクチャ決定ではなかったと確信していますが、私たちはなんとか動作させることができました。もう一度やらなければならなかった場合は、おそらくアクティビティベースのソリューション（フラグメントなし）を試みるか、タブ用にアクティビティを1つだけにして残りをすべてビューにしようとします（これがはるかに多いと思います）アクティビティ全体よりも再利用可能）。

そのため、要件は各タブにいくつかのタブとネスト可能な画面を持つことでした：

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

等...

たとえば、ユーザーはタブ1で開始し、画面1から画面2、次に画面3に移動し、タブ3に切り替えて画面4から6に移動します。タブ1に戻ると、画面3が再び表示され、戻るを押すと画面2に戻ります。再び戻って、彼は画面1にいます。タブ3に切り替えると、彼は再び画面6にいます。

アプリケーションのメインアクティビティはMainTabActivityであり、TabActivityを拡張します。各タブはアクティビティに関連付けられています（ActivityInTab1、2、3など）。そして、各画面はフラグメントになります。

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

各ActivityInTabは、一度に1つのフラグメントのみを保持し、1つのフラグメントを別のフラグメントに置き換える方法を知っています（ActvityGroupとほぼ同じです）。クールなのは、この方法でタブごとに別々のバックスタックを保持するのが非常に簡単なことです。

各ActivityInTabの機能はまったく同じでした。あるフラグメントから別のフラグメントにナビゲートし、バックスタックを維持する方法を知っているので、それを基本クラスに入れます。それを単に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は次のとおりです。

<?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>

ご覧のとおり、各タブのビューレイアウトは同じでした。それは、各フラグメントを保持するコンテンツと呼ばれるFrameLayoutだけだからです。フラグメントは、各画面のビューを持つものです。

ボーナスポイントだけのために、ユーザーが[戻る]を押したときに確認ダイアログを表示する小さなコードを追加しました。これ以上戻るフラグメントはありません。

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

それがほとんどセットアップです。ご覧のように、各FragmentActivity（または単にAndroid> 3のActivity）は、独自のFragmentManagerですべてのバックスタックを処理しています。

ActivityInTab1のようなアクティビティは本当にシンプルで、最初のフラグメント（つまり画面）を表示するだけです。

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

次に、フラグメントが別のフラグメントにナビゲートする必要がある場合、少し厄介なキャストを行う必要があります...しかし、それほど悪くはありません：

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

これでほぼ完了です。私はこれが非常に標準的な（そしてほとんど確かにあまり良くない）ソリューションではないことを確信しているので、ベテランのAndroid開発者にこの機能を実現するためのより良いアプローチを尋ねたいです。これはAndroidの「方法」ではありません。the Androidこれにアプローチする方法を説明するリンクまたは資料を教えていただければ幸いです（タブ、タブ内のネストされた画面など）。コメントでこの回答を自由に分解してください:)

このソリューションがあまり良くない兆候として、最近、アプリケーションにナビゲーション機能を追加する必要がありました。ユーザーをあるタブから別のタブに、そしてネストされた画面に移動させる、奇妙なボタン。誰が知っているか、誰が問題であるか、フラグメントとアクティビティが実際にインスタンス化および初期化される場合に対処するため、プログラムでそれを行うのは苦痛です。これらの画面とタブがすべて単なるビューであれば、もっと簡単だったと思います。

---

最後に、方向の変更に耐える必要がある場合は、setArguments/getArgumentsを使用してフラグメントを作成することが重要です。フラグメントのコンストラクターでインスタンス変数を設定すると、混乱してしまいます。しかし幸いなことに、それは本当に簡単に修正できます。コンストラクタのsetArgumentsにすべてを保存し、onCreateのgetArgumentsでそれらを取得して使用します。

Answer 4

フラグメントへの強い参照を保存するのは正しい方法ではありません。

FragmentManagerは、 putFragment(Bundle, String, Fragment) および saveFragmentInstanceState(Fragment) を提供します。

バックスタックを実装するには、どちらでも十分です。

---

フラグメントを置き換える代わりに、putFragmentを使用して、古いフラグメントをデタッチし、新しいフラグメントを追加します。これは、バックスタックに追加される置換トランザクションに対してフレームワークが行うことです。 putFragmentは、アクティブなフラグメントの現在のリストへのインデックスを保存します。これらのフラグメントは、方向の変更中にフレームワークによって保存されます。

2番目の方法は、saveFragmentInstanceStateを使用して、フラグメント状態全体をバンドルに保存し、デタッチするのではなく、実際に削除できるようにします。このアプローチを使用すると、いつでもフラグメントをポップできるため、バックスタックの操作が容易になります。

---

このユースケースでは2番目の方法を使用しました。

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

ユーザーが3番目の画面から[戻る]ボタンを押して[サインアップ]画面に戻るのは望ましくありません。また、それらの間でアニメーションを反転します（onCreateAnimationを使用）。そのため、ハッキーソリューションは機能しません。

これは、カスタムバックスタックの有効な使用例であり、ユーザーが期待することを実行します...

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

Answer 5

これは、ChildFragmentManagerを使用して簡単に実現できます。

これについては、関連するプロジェクトと一緒に投稿します。見て、

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

Answer 6

Androidは1つのバックスタックしか処理しないため、これは複雑な問題ですが、これは実現可能です。あなたが探していることを正確に行うタブスタッカーと呼ばれるライブラリを作成するのに数日かかりました：各タブのフラグメント履歴。これはオープンソースであり、完全に文書化されており、gradleに簡単に含めることができます。ライブラリはgithubで見つけることができます： https://github.com/smart-fun/TabStacker

サンプルアプリをダウンロードして、動作がニーズに対応していることを確認することもできます。

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

質問がある場合は、メールをドロップすることをheしないでください。

Answer 7

免責事項：

---

これは、かなり標準的なAndroidのようなものである同様のタイプの問題に対して取り組んだ関連ソリューションを投稿するのに最適な場所だと思います。すべての人の問題を解決するわけではありませんが、一部の人には役立つかもしれません。

---

フラグメント間の主な違いがそれらをバックアップするデータのみである場合（つまり、大きなレイアウトの違いはそれほど多くない場合）、実際にフラグメントを置き換える必要はなく、基礎となるデータを交換してビューを更新するだけです。

このアプローチの可能な例の説明を以下に示します。

ListViewを使用するアプリがあります。リスト内の各アイテムは、いくつかの子を持つ親です。アイテムをタップすると、元のリストと同じActionBarタブ内で、それらの子を含む新しいリストを開く必要があります。これらのネストされたリストは、非常によく似たレイアウト（いくつかの条件付き調整があるかもしれません）を持っていますが、データは異なります。

このアプリには、最初の親リストの下に子孫の層がいくつかあり、ユーザーが最初の深さを超える特定の深さにアクセスしようとするまでに、サーバーからのデータがある場合とない場合があります。リストはデータベースカーソルから構築され、フラグメントはカーソルローダーとカーソルアダプターを使用してリストビューにリスト項目を表示するため、クリックが登録されたときに発生する必要があるのは次のとおりです。

1）リストに追加される新しいアイテムビューと新しいカーソルによって返される列に一致する適切な「to」フィールドと「from」フィールドを持つ新しいアダプターを作成します。

2）このアダプターをListViewの新しいアダプターとして設定します。

3）クリックされたアイテムに基づいて新しいURIを構築し、新しいURI（およびプロジェクション）でカーソルローダーを再起動します。この例では、URIは特定のクエリにマップされ、UIから選択引数が渡されます。

4）新しいデータがURIからロードされたら、アダプターに関連付けられたカーソルを新しいカーソルに交換すると、リストが更新されます。

トランザクションを使用していないため、これに関連するバックスタックはありません。したがって、独自のビルドを作成するか、階層からバックアウトするときにクエリを逆に再生する必要があります。これを試したとき、クエリは十分高速で、oNBackPressed（）で階層の最上位に戻るまでフレームワークが再び実行され、フレームワークが戻るボタンを再び引き継ぎます。

同様の状況に陥った場合は、ドキュメントを必ずお読みください： http://developer.Android.com/guide/topics/ui/layout/listview.html

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

これが誰かの助けになることを願っています！

Answer 8

私はまったく同じ問題を抱えており、スタックされたタブ、バックアップとアップのナビゲーションをカバーし、十分にテストされ、文書化されているオープンソースのgithubプロジェクトを実装しました。

https://github.com/SebastianBaltesObjectCode/PersistentFragmentTabs

これは、ナビゲーションタブとフラグメントの切り替えと上下ナビゲーションの処理のためのシンプルで小さなフレームワークです。各タブには、独自のフラグメントのスタックがあります。 ActionBarSherlockを使用し、APIレベル8と互換性があります。

Answer 9

誰かが探していて、自分のニーズに最適なものを選択したい場合に備えて、私自身の解決策を提案したいと思います。

https://github.com/drusak/tabactivity

ライブラリを作成する目的は非常に平凡です-iPhoneのように実装します。

主な利点：

• tabLayoutでAndroid.support.designライブラリを使用します。
• 各タブには、FragmentManagerを使用した独自のスタックがあります（フラグメントの参照を保存しません）。
• ディープリンクのサポート（特定のタブと特定のフラグメントのレベルを開く必要がある場合）;
• タブの状態の保存/復元。
• タブ内のフラグメントの適応型ライフサイクルメソッド。
• ニーズに合わせて簡単に実装できます。

Answer 10

簡単な解決策：

タブ/ルートビューの呼び出しを変更するたびに：

fragmentManager.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);

BackStackをクリアします。ルートフラグメントを変更する前にこれを呼び出すことを忘れないでください。

そしてこれでフラグメントを追加します：

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

.addToBackStack(null)およびtransaction.addは、たとえばtransaction.replaceで変更します。