如何在Fragments中实现onBackPressed（）？

有没有一种方法可以在Android Fragment中实现onBackPressed()类似于我们在Android Activity中实现的方式？

由于片段生命周期没有onBackPressed() 。 有没有其他的替代方法来onBackPressed() Android 3.0片段中的onBackPressed() ？

Answer 1

我用这种方法解决了在Activity中覆盖onBackPressed 。 所有的FragmentTransaction在commit之前都是addToBackStack ：

 @Override public void onBackPressed() { int count = getFragmentManager().getBackStackEntryCount(); if (count == 0) { super.onBackPressed(); //additional code } else { getFragmentManager().popBackStack(); } } 

Answer 2

根据@HaMMeRed的答案这里是伪代码应该如何工作。 可以说，你的主要活动被称为具有子片段的BaseActivity（就像在SlidingMenu lib例子中）。 这里是步骤：

首先我们需要创build接口和实现它的接口的类来具有generics方法

1. 创build类接口OnBackPressedListener

    public interface OnBackPressedListener { public void doBack(); } 

2. 创build实现OnBackPressedListener技能的OnBackPressedListener

    public class BaseBackPressedListener implements OnBackPressedListener { private final FragmentActivity activity; public BaseBackPressedListener(FragmentActivity activity) { this.activity = activity; } @Override public void doBack() { activity.getSupportFragmentManager().popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE); } } 

3. 从现在开始，我们将在我们的代码BaseActivity及其片段上进行工作

4. 在你的类的BaseActivity之上创build私有的监听BaseActivity

    protected OnBackPressedListener onBackPressedListener; 

5. 创build方法在BaseActivity设置监听BaseActivity

    public void setOnBackPressedListener(OnBackPressedListener onBackPressedListener) { this.onBackPressedListener = onBackPressedListener; } 

6. 在覆盖onBackPressed实现类似的东西

    @Override public void onBackPressed() { if (onBackPressedListener != null) onBackPressedListener.doBack(); else super.onBackPressed(); 

7. 在onCreateView的片段中，你应该添加我们的监听器

    @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { activity = getActivity(); ((BaseActivity)activity).setOnBackPressedListener(new BaseBackPressedListener(activity)); View view = ... ; //stuff with view return view; } 

瞧，现在当你点击回来的片段，你应该赶上你的习惯后面的方法。

Answer 3

如果您需要这种function，您需要在您的活动中重写该function，然后将YourBackPressed界面添加到所有的片段中，只要按下后退button，就可以调用相关片段。

编辑：我想追加我以前的答案。

如果我今天要这样做的话，我会用一个广播，或者如果我希望其他的面板一致地更新到主/主内容面板，我可能会使用一个有序的广播。

支持库中的LocalBroadcastManager可以帮助你做到这一点，你只需在onBackPressed发送广播，然后在你关心的片段中订阅。 我认为消息传递是一个更加分离的实现，并且可以更好地扩展，所以现在就是我的正式实施build议。 只要使用Intent的行动作为您的消息filter。 发送你新创build的ACTION_BACK_PRESSED ，从你的活动发送它，并在相关的片段中听取它。

Answer 4

这对我工作： https : //stackoverflow.com/a/27145007/3934111

 @Override public void onResume() { super.onResume(); if(getView() == null){ return; } getView().setFocusableInTouchMode(true); getView().requestFocus(); getView().setOnKeyListener(new View.OnKeyListener() { @Override public boolean onKey(View v, int keyCode, KeyEvent event) { if (event.getAction() == KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_BACK){ // handle back button's click listener return true; } return false; } }); } 

Answer 5

这些都不容易实施，也不会以最佳方式运作。

碎片有一个方法调用onDetach将完成这项工作。

 @Override public void onDetach() { super.onDetach(); PUT YOUR CODE HERE } 

这将做工作。

Answer 6

只需添加addToBackStack而您正在如下所示的片段之间转换：

 fragmentManager.beginTransaction().replace(R.id.content_frame,fragment).addToBackStack("tag").commit(); 

如果你写addToBackStack(null) ，它会自己处理它，但如果你给一个标签，你应该手动处理它。

Answer 7

解决scheme很简单：

1）如果你有一个基片段类，所有的片段扩展，然后将这个代码添加到它的类，否则创build这样一个基片段类

  /* * called when on back pressed to the current fragment that is returned */ public void onBackPressed() { // add code in super class when override } 

2）在你的Activity类中，重写onBackPressed，如下所示：

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

3）在你的片段类中，添加你想要的代码：

  @Override public void onBackPressed() { setUpTitle(); } 

Answer 8

由于这个问题和一些答案已经超过五年了，让我分享我的解决scheme。 这是对@oyenigun回答的后续和现代化

更新：在这篇文章的底部，我添加了一个使用抽象的Fragment扩展的替代实现，它根本不涉及Activity，对于任何具有更复杂的片段层次结构的人来说都是有用的，这些片段层次结构涉及需要不同后退行为的嵌套片段。

我需要实现这一点，因为我使用的一些片段具有较小的视图，我想忽略后退button，如popup的小信息视图等，但是这对任何需要重写后面的button里面的碎片。

首先，定义一个接口

 public interface Backable { boolean onBackPressed(); } 

这个我称之为Backable接口（我是命名约定的坚持者）有一个方法onBackPressed() ，它必须返回一个boolean值。 我们需要强制布尔值，因为我们需要知道后退button是否吸收了后退事件。 回到true意味着它已经，并且不需要进一步的动作，否则， false说，默认的回退动作仍然必须发生。 这个接口应该是它自己的文件（最好在一个单独的包名为interfaces ）。 记住，把你的课程分成几个包是很好的做法。

其次，find顶部的片段

我创build了一个方法，返回后堆栈中的最后一个Fragment对象。 我使用标签…如果您使用ID，请进行必要的更改。 我在一个处理导航状态的实用程序类中有这个静态方法，但是当然，把它放在最适合你的地方。 为了build立起来，我把它放在一个名为NavUtils的类中。

 public static Fragment getCurrentFragment(Activity activity) { FragmentManager fragmentManager = activity.getFragmentManager(); if (fragmentManager.getBackStackEntryCount() > 0) { String lastFragmentName = fragmentManager.getBackStackEntryAt( fragmentManager.getBackStackEntryCount() - 1).getName(); return fragmentManager.findFragmentByTag(lastFragmentName); } return null; } 

确保后退堆栈数大于0，否则可能会在运行时抛出ArrayOutOfBoundsException 。 如果不大于0，则返回null。 稍后我们将检查一个空值

第三，在片段中实施

在需要覆盖后退button行为的任何片段中实现Backable接口。 添加实现方法。

 public class SomeFragment extends Fragment implements FragmentManager.OnBackStackChangedListener, Backable { ... @Override public boolean onBackPressed() { // Logic here... if (backButtonShouldNotGoBack) { whateverMethodYouNeed(); return true; } return false; } } 

在onBackPressed()覆盖，把你需要的任何逻辑。 如果你想要后退button不popup返回栈（默认行为），返回true ，你的后退事件已被吸收。 否则，返回false。

最后，在你的活动…

重写onBackPressed()方法，并添加这个逻辑：

 @Override public void onBackPressed() { // Get the current fragment using the method from the second step above... Fragment currentFragment = NavUtils.getCurrentFragment(this); // Determine whether or not this fragment implements Backable // Do a null check just to be safe if (currentFragment != null && currentFragment instanceof Backable) { if (((Backable) currentFragment).onBackPressed()) { // If the onBackPressed override in your fragment // did absorb the back event (returned true), return return; } else { // Otherwise, call the super method for the default behavior super.onBackPressed(); } } // Any other logic needed... // call super method to be sure the back button does its thing... super.onBackPressed(); } 

我们在后面的栈中得到当前的片段，然后我们做一个空的检查，并确定它是否实现了我们的Backable接口。 如果是的话，确定事件是否被吸收。 如果是这样，我们完成onBackPressed()并可以返回。 否则，将其视为正常的背压，并调用超级方法。

第二个选项不涉及该活动

有时，你不希望Activity来处理这个，你需要直接在片段中处理它。 但是谁说你不能有一个背压API的碎片？ 只要将你的片段扩展到一个新的类。

创build一个扩展Fragment并实现View.OnKeyListner接口的抽象类…

 import android.app.Fragment; import android.os.Bundle; import android.view.KeyEvent; import android.view.View; public abstract class BackableFragment extends Fragment implements View.OnKeyListener { @Override public void onViewCreated(View view, Bundle savedInstanceState) { super.onViewCreated(view, savedInstanceState); view.setFocusableInTouchMode(true); view.requestFocus(); view.setOnKeyListener(this); } @Override public boolean onKey(View v, int keyCode, KeyEvent event) { if (event.getAction() == KeyEvent.ACTION_UP) { if (keyCode == KeyEvent.KEYCODE_BACK) { onBackButtonPressed(); return true; } } return false; } public abstract void onBackButtonPressed(); } 

正如您所看到的，任何扩展BackableFragment片段BackableFragment将使用View.OnKeyListener接口自动捕获点击。 只需使用标准逻辑从实现的onKey()方法内部调用抽象的onBackButtonPressed()方法即可识别后退button。 如果你需要注册除了后退button以外的按键，只要在覆盖片段中的onKey()时确保调用super方法，否则你将覆盖抽象中的行为。

简单易用，只需扩展和实现：

 public class FragmentChannels extends BackableFragment { ... @Override public void onBackButtonPressed() { if (doTheThingRequiringBackButtonOverride) { // do the thing } else { getActivity().onBackPressed(); } } ... } 

由于超级类中的onBackButtonPressed()方法是抽象的，所以一旦扩展，就必须实现onBackButtonPressed() 。 它返回void因为它只需要在片段类中执行一个动作，而不需要将压力的吸收转移回Activity。 确保你调用Activity的onBackPressed()方法，如果你正在做的后退button不需要处理，否则，后退button将被禁用…而你不想要的！

注意事项正如您所看到的，这将关键侦听器设置为片段的根视图，我们需要关注它。 如果在扩展这个类的片段（或其他内部片段或具有相同视图的片段）中包含编辑文本（或任何其他焦点窃取视图），则需要单独处理。 有一篇关于如何扩展EditText的文章，让我们失去了关注焦点的想法 。

我希望有人认为这有用。 快乐的编码。

Answer 9

如何使用onDestroyView（）？

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

Answer 10

那么我就这样做了，这对我有用

简单的界面

FragmentOnBackClickInterface.java

 public interface FragmentOnBackClickInterface { void onClick(); } 

示例实现

MyFragment.java

 public class MyFragment extends Fragment implements FragmentOnBackClickInterface { // other stuff public void onClick() { // what you want to call onBackPressed? } 

然后在活动中重写onBackPressed

  @Override public void onBackPressed() { int count = getSupportFragmentManager().getBackStackEntryCount(); List<Fragment> frags = getSupportFragmentManager().getFragments(); Fragment lastFrag = getLastNotNull(frags); //nothing else in back stack || nothing in back stack is instance of our interface if (count == 0 || !(lastFrag instanceof FragmentOnBackClickInterface)) { super.onBackPressed(); } else { ((FragmentOnBackClickInterface) lastFrag).onClick(); } } private Fragment getLastNotNull(List<Fragment> list){ for (int i= list.size()-1;i>=0;i--){ Fragment frag = list.get(i); if (frag != null){ return frag; } } return null; } 

Answer 11

如果你使用EventBus，这可能是一个更简单的解决scheme：

在你的片段：

 @Override public void onAttach(Activity activity) { super.onAttach(activity); EventBus.getDefault().register(this); } @Override public void onDetach() { super.onDetach(); EventBus.getDefault().unregister(this); } // This method will be called when a MessageEvent is posted public void onEvent(BackPressedMessage type){ getSupportFragmentManager().popBackStack(); } 

在你的Activity类中你可以定义：

 @Override public void onStart() { super.onStart(); EventBus.getDefault().register(this); } @Override public void onStop() { EventBus.getDefault().unregister(this); super.onStop(); } // This method will be called when a MessageEvent is posted public void onEvent(BackPressedMessage type){ super.onBackPressed(); } @Override public void onBackPressed() { EventBus.getDefault().post(new BackPressedMessage(true)); } 

BackPressedMessage.java只是一个POJO对象

这是超级干净的，没有接口/执行的麻烦。

Answer 12

onBackPressed()会导致Fragment与Activity分离。

根据@Sterling Diaz的回答，我认为他是对的。 但有些情况是错的。 （例如旋转屏幕）

所以，我认为我们可以检测isRemoving()是否达到目标。

你可以写在onDetach()或onDestroyView() 。 这是工作。

 @Override public void onDetach() { super.onDetach(); if(isRemoving()){ // onBackPressed() } } @Override public void onDestroyView() { super.onDestroyView(); if(isRemoving()){ // onBackPressed() } } 

Answer 13

你应该像下面一样为你的项目添加接口;

 public interface OnBackPressed { void onBackPressed(); } 

然后，你应该在你的片段上实现这个接口;

 public class SampleFragment extends Fragment implements OnBackPressed { @Override public void onBackPressed() { //on Back Pressed } } 

你可以在你的活动onBackPressed事件下面触发这个onBackPressed事件。

 public class MainActivity extends AppCompatActivity { @Override public void onBackPressed() { Fragment currentFragment = getSupportFragmentManager().getFragments().get(getSupportFragmentManager().getBackStackEntryCount() - 1); if (currentFragment instanceof OnBackPressed) { ((OnBackPressed) currentFragment).onBackPressed(); } super.onBackPressed(); } } 

Answer 14

这只是一个小的代码，可以做到这一点：

  getActivity().onBackPressed(); 

希望它可以帮助别人:)

Answer 15

创build简单的界面：

 public interface IOnBackPressed { /** * Si vous retouné true le back press ne sera pas pris en compte, sinon l'activité agira naturellement * @return true si votre traitement est prioritaire sinon false */ boolean onBackPressed(); } 

并在你的活动

 public class MyActivity extends Activity { @Override public void onBackPressed() { Fragment fragment = getSupportFragmentManager().findFragmentById(R.id.main_container); if (!(fragment instanceof IOnBackPressed) || !((IOnBackPressed) fragment).onBackPressed()) { super.onBackPressed(); } } ... } 

最后在你的片段：

 public class MyFragment extends Fragment implements IOnBackPressed{ @Override public boolean onBackPressed() { if (myCondition) { //action not popBackStack return true; } else { return false; } } } 

Answer 16

不要实现ft.addToBackStack（）方法，这样当你按下后，你的活动就完成了。

 proAddAccount = new ProfileAddAccount(); FragmentManager fragmentManager = getSupportFragmentManager(); FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction(); fragmentTransaction.replace(R.id.fragment_container, proAddAccount); //fragmentTransaction.addToBackStack(null); fragmentTransaction.commit(); 

Answer 17

只需按照以下步骤操作

总是在添加片段的同时，

 fragmentTransaction.add(R.id.fragment_container, detail_fragment, "Fragment_tag").addToBackStack(null).commit(); 

然后在主要活动中，重写onBackPressed()

 if (getSupportFragmentManager().getBackStackEntryCount() > 0) { getSupportFragmentManager().popBackStack(); } else { finish(); } 

要处理您应用中的后退button，

 Fragment f = getActivity().getSupportFragmentManager().findFragmentByTag("Fragment_tag"); if (f instanceof FragmentName) { if (f != null) getActivity().getSupportFragmentManager().beginTransaction().remove(f).commit() } 

而已！

Answer 18

非常简短和甜蜜的答案：

 getActivity().onBackPressed(); 

我的情况整个情况的解释：

我在MainActivity中有FragmentA，我从FragmentA打开FragmentB（FragmentB是FragmentA的子代或嵌套片段）

  Fragment duedateFrag = new FragmentB(); FragmentTransaction ft = getFragmentManager().beginTransaction(); ft.replace(R.id.container_body, duedateFrag); ft.addToBackStack(null); ft.commit(); 

现在，如果你想从FragmentB去FragmentA，你可以简单的把getActivity().onBackPressed(); 在FragmentB。

Answer 19

最佳解决scheme

 import android.support.v4.app.Fragment; import android.support.v4.app.FragmentManager; import android.support.v7.app.AppCompatActivity; public class BaseActivity extends AppCompatActivity { @Override public void onBackPressed() { FragmentManager fm = getSupportFragmentManager(); for (Fragment frag : fm.getFragments()) { if (frag == null) { super.onBackPressed(); finish(); return; } if (frag.isVisible()) { FragmentManager childFm = frag.getChildFragmentManager(); if (childFm.getFragments() == null) { super.onBackPressed(); finish(); return; } if (childFm.getBackStackEntryCount() > 0) { childFm.popBackStack(); return; } else { fm.popBackStack(); if (fm.getFragments().size() <= 1) { finish(); } return; } } } } } 

Answer 20

在活动生命周期中，当我们使用FragmentActivity或AppCompatActivity时，总是使用android后退button处理FragmentManager事务。

为了处理后台堆栈，我们不需要处理其后台计数或标记任何东西，但是我们应该在添加或replace片段时保持焦点。 请找下面的代码片段来处理后面的button盒，

  public void replaceFragment(Fragment fragment) { FragmentTransaction transaction = getSupportFragmentManager().beginTransaction(); if (!(fragment instanceof HomeFragment)) { transaction.addToBackStack(null); } transaction.replace(R.id.activity_menu_fragment_container, fragment).commit(); } 

在这里，我不会为我的主页添加回栈，因为它是我的应用程序的主页。 如果将addToBackStack添加到HomeFragment，则应用程序将等待删除活动中的所有frament，然后我们将得到空白屏幕，所以我保持以下条件，

 if (!(fragment instanceof HomeFragment)) { transaction.addToBackStack(null); } 

现在，你可以看到之前添加的acitvity片段，app到达HomeFragment时会退出。 你也可以看看下面的代码片段。

 @Override public void onBackPressed() { if (mDrawerLayout.isDrawerOpen(Gravity.LEFT)) { closeDrawer(); } else { super.onBackPressed(); } } 

Answer 21

它只是简单的，如果你有一个活动A，你做了3个片段，如B，C和D.现在，如果你在片段B或C和onBackPressed你想在片段D上每次移动。那么你必须重写onBackPressed()方法，并且当您跳转到任何片段时，则传递一个TAG或您在其中识别主Activity A中的片段的名称 。

我正在举一个你可以很容易理解的例子。

 if (savedInstanceState == null) { getSupportFragmentManager().beginTransaction().add(R.id.container, new C_fragment(),"xyz").commit(); } 

或者如果你正在从片段B移动到片段C ..并在后面按你想来片段D …像下面

 btn.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { getActivity().getSupportFragmentManager().beginTransaction().add(R.id.container, new C_frament(), "xyz").commit(); ((ActionBarActivity) getActivity()).getSupportActionBar().setTitle("Fragment C"); } }); 

现在你只需要重载主activity中的onBackPressed（）方法。

 @Override public void onBackPressed() { FragmentManager fragmentManager =getSupportFragmentManager(); if (((C_fragment) getSupportFragmentManager().findFragmentByTag("xyz")) != null && ((C_fragment) getSupportFragmentManager().findFragmentByTag("xyz")).isVisible()) { Fragment fragment = new D_Fragment(); fragmentManager.beginTransaction().replace(R.id.container, fragment).commit(); getSupportActionBar().setTitle("D fragment "); } else { super.onBackPressed(); } } 

Answer 22

我用另一种方法如下：

• 一个Otto事件公共汽车在活动和它的碎片之间沟通
• 活动中的堆栈包含由调用片段定义的Runnable中包装的自定义回退操作
• 当在控制活动中调用onBackPressed ，它会popup最近的自定义回退动作并执行其Runnable 。 如果堆栈中没有任何东西，则调用默认的super.onBackPressed()

包含示例代码的完整方法在此处作为对其他SO问题的答案。

Answer 23

公共类MyActivity扩展活动{

 protected OnBackPressedListener onBackPressedListener; public interface OnBackPressedListener { void doBack(); } public void setOnBackPressedListener(OnBackPressedListener onBackPressedListener) { this.onBackPressedListener = onBackPressedListener; } @Override public void onBackPressed() { if (onBackPressedListener != null) onBackPressedListener.doBack(); else super.onBackPressed(); } @Override protected void onDestroy() { onBackPressedListener = null; super.onDestroy(); } 

}

in your fragment add the following, dont forget to implement mainactivity's interface.

 public class MyFragment extends Framgent implements MyActivity.OnBackPressedListener { @Override public void onViewCreated(View view, Bundle savedInstanceState) { super.onViewCreated(view, savedInstanceState); ((MyActivity) getActivity()).setOnBackPressedListener(this); } @Override public void doBack() { //BackPressed in activity will call this; } } 

Answer 24

I know it's too late but I had the same problem last week. None of the answers helped me. I then was playing around with the code and this worked, since I already added the fragments.

In your Activity, set an OnPageChangeListener for the ViewPager so that you will know when the user is in the second activity. If he is in the second activity, make a boolean true as follows:

  mSectionsPagerAdapter = new SectionsPagerAdapter(getSupportFragmentManager()); // Set up the ViewPager with the sections adapter. mViewPager = (ViewPager) findViewById(R.id.pager); mViewPager.setAdapter(mSectionsPagerAdapter); mViewPager.setCurrentItem(0); mViewPager.addOnPageChangeListener(new OnPageChangeListener() { @Override public void onPageSelected(int position) { // TODO Auto-generated method stub mSectionsPagerAdapter.instantiateItem(mViewPager, position); if(position == 1) inAnalytics = true; else if(position == 0) inAnalytics = false; } @Override public void onPageScrolled(int position, float arg1, int arg2) { // TODO Auto-generated method stub } @Override public void onPageScrollStateChanged(int arg0) { // TODO Auto-generated method stub } }); 

Now check for the boolean whenever back button is pressed and set the current item to your first Fragment:

 @Override public void onBackPressed() { if(inAnalytics) mViewPager.setCurrentItem(0, true); else super.onBackPressed(); } 

Answer 25

this is my solution:

in MyActivity.java:

 public interface OnBackClickListener { boolean onBackClick(); } private OnBackClickListener onBackClickListener; public void setOnBackClickListener(OnBackClickListener onBackClickListener) { this.onBackClickListener = onBackClickListener; } @Override public void onBackPressed() { if (onBackClickListener != null && onBackClickListener.onBackClick()) { return; } super.onBackPressed(); } 

and in Fragment:

 ((MyActivity) getActivity()).setOnBackClickListener(new MyActivity.OnBackClickListener() { @Override public boolean onBackClick() { if (condition) { return false; } // some codes return true; } }); 

Answer 26

I had the same problem and I created a new listener for it and used in my fragments.

1 – Your activity should have a listener interface and a list of listeners in it

2 – You should implement methods for adding and removing the listeners

3 – You should override the onBackPressed method to check that any of the listeners use the back press or not

 public class MainActivity ... { /** * Back press listener list. Used for notifying fragments when onBackPressed called */ private Stack<BackPressListener> backPressListeners = new Stack<BackPressListener>(); ... /** * Adding new listener to back press listener stack * @param backPressListener */ public void addBackPressListener(BackPressListener backPressListener) { backPressListeners.add(backPressListener); } /** * Removing the listener from back press listener stack * @param backPressListener */ public void removeBackPressListener(BackPressListener backPressListener) { backPressListeners.remove(backPressListener); } // Overriding onBackPressed to check that is there any listener using this back press @Override public void onBackPressed() { // checks if is there any back press listeners use this press for(BackPressListener backPressListener : backPressListeners) { if(backPressListener.onBackPressed()) return; } // if not returns in the loop, calls super onBackPressed super.onBackPressed(); } } 

4 – Your fragment must implement the interface for back press

5 – You need to add the fragment as a listener for back press

6 – You should return true from onBackPressed if the fragment uses this back press

7 – IMPORTANT – You must remove the fragment from the list onDestroy

 public class MyFragment extends Fragment implements MainActivity.BackPressListener { ... @Override public void onAttach(Activity activity) { super.onCreate(savedInstanceState); // adding the fragment to listener list ((MainActivity) activity).addBackPressListener(this); } ... @Override public void onDestroy() { super.onDestroy(); // removing the fragment from the listener list ((MainActivity) getActivity()).removeBackPressListener(this); } ... @Override public boolean onBackPressed() { // you should check that if this fragment is the currently used fragment or not // if this fragment is not used at the moment you should return false if(!isThisFragmentVisibleAtTheMoment) return false; if (isThisFragmentUsingBackPress) { // do what you need to do return true; } return false; } } 

There is a Stack used instead of the ArrayList to be able to start from the latest fragment. There may be a problem also while adding fragments to the back stack. So you need to check that the fragment is visible or not while using back press. Otherwise one of the fragments will use the event and latest fragment will not be closed on back press.

I hope this solves the problem for everyone.

Answer 27

on mainActivity

 protected DrawerHomeActivity.OnBackPressedListener onBackPressedListener; public interface OnBackPressedListener { void doBack(); } public void setOnBackPressedListener(DrawerHomeActivity.OnBackPressedListener onBackPressedListener) { this.onBackPressedListener = onBackPressedListener; } @Override public void onBackPressed() { if (onBackPressedListener != null) { onBackPressedListener.doBack(); } else super.onBackPressed(); } 

on fragment implement base activity/fragment like

 implements DrawerHomeActivity.OnBackPressedListener 

DraweHomeActivity is my base activity write

 ((DrawerHomeActivity) getActivity()).setOnBackPressedListener(this); 

and create method doBack

 @Override public void doBack() { //call base fragment } 

Answer 28

Here is my solution for that issue:

in Activity A:

 @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); if(requestCode == REQUEST_CODE) { if(resultCode == Activity.RESULT_OK) { tvTitle.setText(data.getExtras().getString("title", "")); } } } 

in Activity B:

 @Override public void onBackPressed() { setResult(Activity.RESULT_OK, getIntent()); super.onBackPressed(); } 

activity b holds the fragment.

in fragment:

 private void setText(String text) { Intent intent = new Intent(); intent.putExtra("title", text); getActivity().setIntent(intent); } 

in that way the Intent Object "data" in activity A will get the string from the fragment

Answer 29

I just use findFragmentById and cast to the fragment and call a method that handles onBackpressed. This sample shows checking if this is the first step in order process if it is pop up a dialog fragment to confirm exit order.

 @Override public void onBackPressed() { //check if first fragment in wizard is loaded, if true get abandon confirmation before going back OrderFragment frag =(OrderFragment)getSupportFragmentManager().findFragmentById(R.id.fragContainer); if (frag==null || (frag!=null && frag.getOrderStage()<1)){ AlertDialogFragment.show(getSupportFragmentManager(), R.string.dialog_cancel_order,R.string.dialog_cancel_order_msg, R.string.dialog_cancel_order_pos,R.string.dialog_order_quiz_neg, DIALOG_ID_CANCEL); }else { super.onBackPressed(); } } 

Answer 30

只是使用

  getActivity().onBackPressed();