Android 当添加到后堆栈时,如何维护片段状态?
我编写了一个虚拟活动,在两个片段之间切换。当您从FragmentA转到FragmentB时,FragmentA将添加到后堆栈中。然而,当我返回FragmentA时(通过按back),一个全新的FragmentA被创建,它所处的状态丢失。我觉得我想要的是和问题一样的东西,但我已经包含了一个完整的代码示例来帮助解决问题:Android 当添加到后堆栈时,如何维护片段状态?,android,android-fragments,back-stack,Android,Android Fragments,Back Stack,我编写了一个虚拟活动,在两个片段之间切换。当您从FragmentA转到FragmentB时,FragmentA将添加到后堆栈中。然而,当我返回FragmentA时(通过按back),一个全新的FragmentA被创建,它所处的状态丢失。我觉得我想要的是和问题一样的东西,但我已经包含了一个完整的代码示例来帮助解决问题: public class FooActivity extends Activity { @Override public void onCreate(Bundle savedI
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
07-0514:28:59.722 D/OMG(1260):FooActivity.onCreate
07-05 14:28:59.742 D/OMG(1260):片段a.onCreateView
07-05 14:28:59.742 D/OMG(1260):FooActivity.onResume
07-05 14:29:12.842 D/OMG(1260):FooActivity.nextFragment
07-05 14:29:12.852 D/OMG(1260):片段B.onCreateView
07-05 14:29:16.792 D/OMG(1260):FragmentA.onCreateView
它从不调用FragmentA.onSaveInstanceState,当你回击时,它会创建一个新的FragmentA。但是,如果我在FragmentA上并且锁定了屏幕,FragmentA.onSaveInstanceState确实会被调用。这么奇怪…我期望添加到后堆栈的片段不需要重新创建,这是不是错了?下面是他们所说的:
然而,如果在删除片段时调用addToBackStack(),
然后,该片段被停止,如果用户进行导航,该片段将被恢复
回来
如果从后堆栈返回片段,它不会重新创建片段,而是重新使用相同的实例,并在片段生命周期中从
onCreateView()
开始,请参阅
因此,如果要存储状态,则应使用实例变量,而不是依赖于
onSaveInstanceState()
如果从后堆栈返回片段,它不会重新创建片段,而是重新使用相同的实例,并在片段生命周期中从onCreateView()
开始,请参阅
因此,如果您想存储状态,您应该使用实例变量,而不是依赖于
onSaveInstanceState()
我想有另一种方法可以实现您想要的。
我不认为这是一个完整的解决方案,但在我的情况下,它达到了目的
我所做的不是替换刚才添加的目标片段。
因此,基本上您将使用add()
方法代替replace()
我还做了什么。
我隐藏当前片段并将其添加到backback
因此,它在不破坏其视图的情况下将新片段与当前片段重叠。(请检查其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)视图显示在屏幕上
评论:正如我所说,这不是一个完整的解决方案,因为它不会删除源片段的视图,因此会占用比平时更多的内存。但是,仍然可以达到这个目的。此外,我们正在使用一种完全不同的隐藏视图的机制,而不是替换它,这是一种非传统的机制
因此,这不是你如何维护状态的问题,而是你如何维护视图的问题。我想有另一种方法可以实现你想要的。 我不认为这是一个完整的解决方案,但在我的情况下,它达到了目的 我所做的不是替换刚才添加的目标片段。 因此,基本上您将使用
add()
方法代替replace()
我还做了什么。
我隐藏当前片段并将其添加到backback
因此,它在不破坏其视图的情况下将新片段与当前片段重叠。(请检查其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)视图显示在屏幕上
评论:正如我所说,这不是一个完整的解决方案,因为它不会删除源片段的视图,因此会占用比平时更多的内存。但是,仍然可以达到这个目的。此外,我们正在使用一种完全不同的隐藏视图的机制,而不是替换它,这是一种非传统的机制
因此,真正的问题不在于如何维护状态,而在于如何维护视图。与苹果的
UINavigationController
和UIViewController
相比,谷歌在安卓软件架构方面做得并不好。安卓关于Fragment
的文档也没有多大帮助
当您从FragmentA输入FragmentB时,现有FragmentA实例不会被销毁。当您在FragmentB中按Back并返回FragmentA时,我们不会创建新的FragmentA实例。将调用现有FragmentA实例的onCreateView()
关键是我们不应该在FragmentA的onCreateView()
中再次膨胀视图,因为我们正在使用现有FragmentA的实例。我们需要保存并重用rootView。
下面的代码工作得很好。它不仅保持了片段状态,而且还减少了RAM和CPU负载(因为我们只在必要时扩大布局)。我不敢相信Google的示例代码和文档从来没有提到过它
第1版(D)
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();
}
}
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();
}
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();
}
}
@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
}
}
}
@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();
}
}
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();
}
};
Fragment fragment = new AddPaymentFragment();
getSupportFragmentManager().beginTransaction().replace(R.id.frame, fragment, "Tag_AddPayment")
.addToBackStack("Tag_AddPayment")
.commit();
@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);
/**
* 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);
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;
}