添加到后台堆栈时如何保持片段状态？

Posted 2023-04-15

【中文标题】添加到后台堆栈时如何保持片段状态？

【英文标题】：How can I maintain fragment state when added to the back stack?

【发布时间】：2012-07-06 08:58:10

【问题描述】：

我编写了一个在两个片段之间切换的虚拟活动。当您从 FragmentA 转到 FragmentB 时，FragmentA 被添加到后堆栈。但是，当我返回 FragmentA（通过按回）时，会创建一个全新的 FragmentA，并且它所处的状态会丢失。我感觉我和this 的问题一样，但我已经包含了一个完整的代码示例来帮助根除这个问题：

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

添加了一些日志消息：

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

它从不调用 FragmentA.onSaveInstanceState 并且在您回击时创建一个新的 FragmentA。但是，如果我在 FragmentA 上并锁定屏幕，则会调用 FragmentA.onSaveInstanceState。太奇怪了......我期望添加到后台堆栈的片段不需要重新创建是错误的吗？ docs 是这样说的：

然而，如果您在移除片段时调用 addToBackStack()， 然后片段停止并在用户导航时恢复 返回。

【问题讨论】：

@Jan-Henk 必须获取的东西呢？例如，ListView 的滚动位置。附加滚动侦听器和更新实例变量似乎太多了。

@JakeWharton 我同意这应该更容易，但据我所知，没有办法解决这个问题，因为当从后台堆栈恢复片段时会调用 onCreateView。但我可能是错的:)

onCreate 不会被调用。那么显然它是在重复使用同一个实例但再次调用 onCreateView ？瘸。我想我可以缓存 onCreateView 的结果，如果再次调用 onCreateView 就返回现有视图。

正是我一直在寻找的时间。你能发布你是如何使用实例变量实现这一点的吗？

所以我最近在github.com/frostymarvelous/Folio 开始了自己的实现，遇到了一个问题。在开始 OOM 崩溃之前，我能够创建大约 5 个复杂的页面/片段。这就是把我带到这里的原因。隐藏和显示是不够的。视图太占内存了。

【参考方案1】：

如果您从后台堆栈返回片段，它不会重新创建片段，而是重新使用相同的实例并在片段生命周期中以onCreateView() 开头，请参阅Fragment lifecycle。

所以如果你想存储状态你应该使用实例变量并且不依赖onSaveInstanceState()。

【讨论】：

当前版本的文档与此声明相矛盾。流程图说明了您所说的内容，但页面主要区域中的文本显示 onCreateView() 仅在显示片段的 first 时调用：developer.android.com/guide/components/fragments.html我现在正在解决这个问题，而且我没有看到从后台堆栈返回片段时调用的任何方法。 (Android 4.2)

试图记录它的行为。显示片段时始终调用 onCreateView()。

@ColinM。有什么解决办法吗？

这对我不起作用。返回片段时，我的实例变量为空！如何保存状态？

那么如果我们不应该中继保存实例应该如何保存片段状态和数据？

【参考方案2】：

与苹果的UINavigationController和UIViewController相比，谷歌在Android软件架构上做得并不好。而且Android关于Fragment的文档也没有多大帮助。

从 FragmentA 进入 FragmentB 时，现有的 FragmentA 实例不会被销毁。当您在 FragmentB 中按 Back 并返回到 FragmentA 时，我们不会创建新的 FragmentA 实例。将调用现有 FragmentA 实例的 onCreateView()。

关键是我们不应该在 FragmentA 的onCreateView() 中再次膨胀视图，因为我们正在使用现有的 FragmentA 的实例。我们需要保存并重用 rootView。

以下代码运行良好。它不仅保持片段状态，还减少了 RAM 和 CPU 负载（因为我们只在必要时膨胀布局）。我不敢相信 Google 的示例代码和文档从未提及它，而是 always inflate layout。

版本 1（不要使用版本 1。使用版本 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;
    

-----2005 年 5 月 3 日更新：--------

正如 cmets 所提到的，有时_rootView.getParent() 在onCreateView 中为空，这会导致崩溃。版本 2 删除了 onDestroyView() 中的 _rootView，正如 dell116 所建议的那样。在 Android 4.0.3、4.4.4、5.1.0 上测试。

第 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();
    

警告！！！

这是一个 HACK！虽然我在我的应用中使用它，但你需要仔细测试和阅读 cmets。

【讨论】：

持有对整个片段根视图的引用是 IMO 的一个坏主意。如果您不断将多个片段添加到后台堆栈并且所有片段都持有其根视图（这具有相当大的内存占用），那么您很有可能最终会出现 OutOfMemoryError，因为所有片段都持有根视图引用并且 GC 不能收集它。我认为更好的方法是始终膨胀视图（并让 Android 系统处理其视图创建/销毁）并 onActivityCreated/onViewCreated 检查您的数据是否为空。如果是，则加载它，否则将数据设置为视图。

不要这样做！ 创建 Fragment 的视图层次结构时，它包含对当时持有该 Fragment 的 Activity 的内部引用。当配置发生更改时，通常会重新创建 Activity。重新使用旧布局将僵尸 Activity 连同它还引用的任何对象一起保留在内存中。像这样浪费内存会影响性能，并使您的应用在不在前台时立即终止。

@AllDayAmazing 这是一个很好的观点。老实说，我现在很困惑。任何人都可以尝试解释为什么持有对片段的 rootview 的引用是不行的，但只为 rootview 的任何孩子持有引用（无论如何都有对 rootview 的引用）是可以的？

远离这个，除非你想浪费 5 个小时来找出你的代码出了什么问题.....然后才发现这是原因。现在我必须重构一堆东西，因为我使用了这个 hack。如果您想在将另一个片段的 UI 带入视图（甚至在顶部）时保持片段的 UI 完好无损，则使用 fragmentTransaction.add 会更好。 fragmentTransaction.replace() 旨在破坏片段的视图......不要与系统对抗。

@VinceYuan - 我在 Android 5.1 上使用最新的 v7-appcompat 库进行了测试，这留下了 6 个应该在我的活动的 FragmentManager 中删除的片段实例。即使 GC 会正确处理它（我不相信它会），这也会对您的应用程序以及整个设备的内存造成不必要的压力。只需使用 .add() 即可完全消除对所有这些 hacky 代码的需求。这样做完全违背了使用 FragmentTransaction.replace() 的初衷。

【参考方案3】：

我想有一种替代方法可以实现您正在寻找的东西。 我并不是说它是一个完整的解决方案，但它在我的案例中起到了作用。

我所做的不是替换我刚刚添加的目标片段的片段。 所以基本上你将使用add() 方法而不是replace()。

我还做了什么。 我隐藏了我当前的片段并将其添加到 backstack。

因此它将新片段重叠在当前片段上而不破坏其视图。（检查它的onDestroyView() 方法没有被调用。加上将它添加到backstate 给我恢复片段的优势。

代码如下：

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

AFAIK 系统仅在视图被销毁或未创建时调用onCreateView()。 但是在这里我们通过不将其从内存中删除来保存视图。所以它不会创建新视图。

当您从目标片段返回时，它会弹出最后一个 FragmentTransaction 删除顶部片段，这将使最顶部（SourceFragment 的）视图出现在屏幕上。

评论：正如我所说，这不是一个完整的解决方案，因为它不会删除 Source 片段的视图，因此占用的内存比平时多。但是，还是要达到目的。此外，我们使用了一种完全不同的隐藏视图机制，而不是替换它，这是非传统的。

所以这不是你如何维护状态，而是你如何维护视图。

【讨论】：

在我的情况下，通过添加片段而不是替换在片段中使用轮询或任何其他类型的 Web 请求时会导致问题。添加片段 B 时，我想在片段 A 中暂停此轮询。对此有什么想法吗？

您如何在 FirstFragment 中使用轮询？您必须手动执行此操作，因为两个片段都保留在内存中。因此您可以使用它们的实例来执行必要的操作。这就是线索，在主活动中生成一个事件，当您添加第二个片段时该事件会执行某些操作。希望这会有所帮助。

谢谢你的线索=）。我已经完成了。但这是唯一的方法吗？以及合适的方式？此外，当我按下主页按钮并再次启动应用程序时，所有片段都会再次激活。假设通过这种方式在 Fragment B 中输入。 Activity AFragment A --> Fragment B 当我按下主页按钮后再次启动应用程序时，两个片段的 onResume() 都被调用，因此它们开始轮询。我该如何控制？

不幸的是你不能，系统不能以这种方式以正常行为工作，它会将两个片段视为活动的直接孩子。虽然它的目的是保持片段状态，但其他正常的事情很难管理。最近我发现了所有这些问题，现在我的建议是不要这样做。对不起。

当然，最后我会说在你找到任何其他解决方案之前不要采用这种方法。因为它很难管理。

【参考方案4】：

我会建议一个非常简单的解决方案。

获取 View 引用变量并在 OnCreateView 中设置视图。检查该变量中是否已经存在视图，然后返回相同的视图。

   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;
    

【讨论】：

如果我们没有删除 onDestroy() 中的 'fragmentView' 变量，就有可能发生内存泄漏

@ArunPM 那么如何在 onDestroy() 中删除 fragmentView ？ if (_rootView.getParent() != null) ((ViewGroup)_rootView.getParent()).removeView(_rootView); 适合清空内存？

@MehmetGür 我多次使用此解决方案。到目前为止，我没有收到任何内存泄漏错误。但是，如果您愿意，可以使用 ArunPM 解决方案。我认为他是在告诉在 OnDestroy() 方法中将 fragmentView 设置为 null。

我使用LeakCanary 来检测内存泄漏及其引发的泄漏问题。但是正如@Mandeep Sigh 在评论中提到的，我们可以通过在onDestroy() 方法中将null 分配给fragmentView 变量来克服这个问题。

据我所知，当片段被破坏时，与片段关联的视图在onDestroyView() 中被清除。我们的备份视图变量（此处为fragmentView ）不会发生这种清除，并且当片段返回堆叠/销毁时会导致内存泄漏。您可以在 LeakCanery 简介中的 [常见内存泄漏原因] (square.github.io/leakcanary/fundamentals/…) 中找到相同的参考资料。

【参考方案5】：

我在包含地图的 Fragment 中遇到了这个问题，该地图有太多设置细节无法保存/重新加载。 我的解决方案是基本上一直保持这个 Fragment 处于活动状态（类似于@kaushal 提到的）。

假设你有当前的 Fragment A 并且想要显示 Fragment B。 总结后果：

replace() - 移除 Fragment A 并用 Fragment B 替换它。 Fragment A 将在再次被带到前面时重新创建 add() - （创建并）添加一个 Fragment B，它与 Fragment A 重叠，而 Fragment A 在后台仍然处于活动状态 remove() - 可用于移除 Fragment B 并返回到 A. Fragment B 将在稍后调用时重新创建

因此，如果您想“保存”两个片段，只需使用 hide()/show() 切换它们。

优点：保持多个 Fragment 运行的简单方法缺点：您使用更多内存来保持所有 Fragment 运行。可能会遇到问题，例如显示许多大位图

【讨论】：

你能告诉我当我们移除片段 b 并返回到 A 时，片段 A 中调用了哪个方法？当我们删除片段 B 时，我想采取一些行动。

【参考方案6】：

onSaveInstanceState() 仅在配置更改时调用。

由于从一个片段更改为另一个片段没有配置更改，因此没有对onSaveInstanceState() 的调用。什么状态没有被保存？可以指定吗？

如果您在 EditText 中输入一些文本，它将自动保存。任何没有任何ID的UI项都是不保存视图状态的项。

【讨论】：

onSaveInstanceState() 也会在系统因为缺少资源而销毁 Activity 时被调用。

【参考方案7】：

first：只需使用FragmentTransaction 类的add 方法代替replace 方法，然后您必须通过addToBackStack 方法将secondFragment 添加到堆栈中

second : 在返回点击时你必须调用 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();                                
        
;

【参考方案8】：

这里，因为onSaveInstanceState 在你将片段添加到后台堆栈时不会调用片段。当在onDestroyView 和onDestroy 之间调用onSaveInstanceState 时，返回堆栈中的片段生命周期开始onCreateView 和结束onDestroyView。我的解决方案是在onCreate 中创建实例变量和初始化。示例代码：

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

并在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

【参考方案9】：

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

【参考方案10】：

我的问题是类似的，但我克服了我没有保持片段活着。假设您有一个包含 2 个片段的活动 - F1 和 F2。 F1 最初启动并假设包含一些用户信息，然后在某些情况下 F2 弹出要求用户填写 附加属性 - 他们的电话号码。接下来，您希望该电话号码弹回 F1 并完成注册，但您意识到所有以前的用户信息都丢失了，并且您没有他们以前的数据。该片段是从头开始重新创建的，即使您将此信息保存在 onSaveInstanceState 中，捆绑包也会在 onActivityCreated 中返回 null。

解决方案： 在调用活动中将所需信息保存为实例变量。然后将该实例变量传递到您的片段中。

@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
        
    

继续我的示例：在显示 F2 之前，我使用回调将用户数据保存在实例变量中。然后我启动F2，用户填写电话号码并按保存。我在活动中使用另一个回调，收集此信息并替换我的片段 F1，这次它具有我可以使用的捆绑数据。

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

    

更多关于回调的信息可以在这里找到：https://developer.android.com/training/basics/fragments/communicating.html

【参考方案11】：

使用以下代码替换片段：

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

Activity 的 onBackPressed() 是：

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

【参考方案12】：

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

【讨论】：

感谢您提供此代码 sn-p，它可能会提供一些有限的即时帮助。 proper explanation would greatly improve its long-term value 通过展示为什么这是一个很好的解决问题的方法，并将使其对未来有其他类似问题的读者更有用。请edit您的回答添加一些解释，包括您所做的假设。

【参考方案13】：

在堆栈中找到旧片段并在堆栈中存在时加载它的完美解决方案。

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

像这样使用它

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

【参考方案14】：

Kotlin 和 ViewBinding 解决方案

我正在为 FragmentTransaction 使用 replace() 和 backstack() 方法。问题是 backstack() 方法调用了先前 Fragment 的 onCreateView 导致重新构建 Fragment UI。这是一个解决方案：

private lateinit var binding: FragmentAdRelevantDetailsBinding

override fun onCreateView(
    inflater: LayoutInflater, container: ViewGroup?,savedInstanceState: Bundle?
): View 
    if (!this::binding.isInitialized)
        binding = FragmentAdRelevantDetailsBinding.inflate(layoutInflater, container, false)
    return binding.root

【参考方案15】：

正确调用Fragment生命周期方法并使用onSavedInstanceState()可以解决问题。

即正确调用 onCreate()、onCreateView()、onViewCreated() 和 onSavedInstanceState() 并将 Bundle 保存在 onSaveInstanceState() 中并在 onCreate() 方法中重新调用。

我不知道如何，但它对我有用，没有任何错误。

如果有人能解释一下，将不胜感激。

    public class DiagnosisFragment extends Fragment 
        private static final String TITLE = "TITLE";
        private String mTitle;
        private List mList = null;
        private ListAdapter adapter;
        public DiagnosisFragment()
        public DiagnosisFragment(List list, String title)
            mList = list;
            mTitle = title;
    
        
        @Override
        public void onCreate(@Nullable Bundle savedInstanceState) 
            super.onCreate(savedInstanceState);
            if(savedInstanceState != null)
                mList = savedInstanceState.getParcelableArrayList(HEALTH_ITEMS);
                mTitle = savedInstanceState.getString(TITLE);
                itemId = savedInstanceState.getInt(ID);
                mChoiceMode = savedInstanceState.getInt(CHOICE_MODE);
            
            getActivity().setTitle(mTitle);
            adapter = (ListAdapter) new HealthAdapter(mList, getContext()).load(itemId);
        
        @Nullable
        @Override
        public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) 
            return inflater.inflate(R.layout.diagnosis_fragment, container, false);
        
        @Override
        public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) 
            super.onViewCreated(view, savedInstanceState);
            ListView lv = view.findViewById(R.id.subLocationsSymptomsList);
            lv.setAdapter(adapter);
        
    
        @Override
        public void onSaveInstanceState(@NonNull Bundle outState) 
            outState.putParcelableArrayList(HEALTH_ITEMS, (ArrayList) mList);
            outState.putString(TITLE, mTitle);