Cómo implementar onBackPressed () en Fragmentos?

¿Hay alguna manera en la que podamos implementar onBackPressed() en Android Fragment similar a la forma en que implementamos en Android Activity?

Como el ciclo de vida del fragmento no tiene onBackPressed() . ¿Hay algún otro método alternativo para sobre paseo onBackPressed() en fragmentos de Android 3.0?

28 Solutions collect form web for “Cómo implementar onBackPressed () en Fragmentos?”

He resuelto de esta manera la anulación onBackPressed en la actividad. Todos los FragmentTransaction son addToBackStack antes de confirmar:

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

De acuerdo con @HaMMeRed respuesta aquí es pseudocódigo cómo debe funcionar. Digamos que su actividad principal se llama BaseActivity que tiene fragmentos de niño (como en el ejemplo de lib de SlidingMenu). Estos son los pasos:

Primero necesitamos crear interfaz y clase que implementa su interfaz para tener un método genérico

  1. Crear interfaz de clase OnBackPressedListener

     public interface OnBackPressedListener { public void doBack(); } 
  2. Crear clase que implementa las habilidades de 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. Desde ahora, trabajaremos en nuestro código BaseActivity y sus fragmentos

  4. Crear un oyente privado en la parte superior de su clase BaseActivity

     protected OnBackPressedListener onBackPressedListener; 
  5. Crear método para establecer oyente en BaseActivity

     public void setOnBackPressedListener(OnBackPressedListener onBackPressedListener) { this.onBackPressedListener = onBackPressedListener; } 
  6. En override onBackPressed implementar algo así

     @Override public void onBackPressed() { if (onBackPressedListener != null) onBackPressedListener.doBack(); else super.onBackPressed(); 
  7. En su fragmento en onCreateView debe agregar nuestro oyente

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

Voila, ahora cuando haces clic en el fragmento que debe coger su costumbre en el método de espalda.

Si quisieras ese tipo de funcionalidad tendrías que YourBackPressed en tu actividad, y luego añadir una interfaz YourBackPressed a todos tus fragmentos, a los que llamas en el fragmento relevante cada vez que se pulsa el botón de retroceso.

Edit: Me gustaría añadir mi respuesta anterior.

Si lo hiciera hoy, usaría una transmisión, o posiblemente una transmisión ordenada si esperaba que otros paneles se actualizaran al unísono en el panel de contenido principal / principal.

LocalBroadcastManager en la Biblioteca de Soporte puede ayudar con esto, y usted acaba de enviar la emisión en onBackPressed y suscribirse en sus fragmentos que se preocupan. Creo que Messaging es una implementación más desacoplada y escalaría mejor, por lo que sería mi recomendación de implementación oficial ahora. Sólo usa la acción del Intent como un filtro para tu mensaje. Envíe su recién creado ACTION_BACK_PRESSED , envíelo de su actividad y escúchelo en los fragmentos pertinentes.

Esto funcionó para mí: 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; } }); } 

Nada de eso es fácil de implementar ni funcionará de manera óptima.

Fragmentos tienen una llamada de método onDetach que hará el trabajo.

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

ESTO HARÁ EL TRABAJO.

Simplemente agrega addToBackStack mientras estás addToBackStack transición entre tus fragmentos como a continuación:

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

Si escribe addToBackStack(null) , lo manejará por sí mismo pero si le da una etiqueta, debe manejarla manualmente.

La solución es simple:

1) Si tiene una clase de fragmento base que todos los fragmentos se extienden, añada este código a su clase, de lo contrario cree una clase de fragmento de base

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

2) En su clase de actividad, anule la opción onBackPressed de la siguiente manera:

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

3) En su clase de Fragmento, agregue su código deseado:

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

Ya que esta pregunta y algunas de las respuestas tienen más de cinco años, permítanme compartir mi solución. Se trata de un seguimiento y la modernización de la respuesta de @oyenigun

ACTUALIZACIÓN: En la parte inferior de este artículo, he añadido una implementación alternativa utilizando una extensión de fragmento abstracto que no implicará la actividad en absoluto, lo que sería útil para cualquier persona con una jerarquía de fragmentos más compleja que involucra fragmentos anidados que requieren diferentes comportamientos.

Necesitaba implementar esto porque algunos de los fragmentos que utilizo tienen vistas más pequeñas que me gustaría descartar con el botón Atrás, como pequeñas vistas de información que aparecen, etc., pero esto es bueno para cualquier persona que necesite anular el comportamiento de El botón de atrás dentro de los fragmentos.

En primer lugar, defina una interfaz

 public interface Backable { boolean onBackPressed(); } 

Esta interfaz, que yo llamo Backable (soy un stickler para las convenciones de nomenclatura), tiene un solo método onBackPressed() que debe devolver un valor boolean . Necesitamos aplicar un valor booleano porque tendremos que saber si la pulsación del botón de retroceso ha "absorbido" el evento posterior. Devolver true significa que tiene, y no se necesita ninguna otra acción, de lo contrario, false dice que la acción de espalda predeterminada todavía debe tener lugar. Esta interfaz debe ser su propio archivo (preferiblemente en un paquete separado llamado interfaces ). Recuerde, separar sus clases en paquetes es una buena práctica.

En segundo lugar, encontrar el fragmento superior

Creé un método que devuelve el último objeto Fragment en la pila trasera. Yo uso etiquetas … si utiliza ID's, haga los cambios necesarios. Tengo este método estático en una clase de utilidad que se ocupa de los estados de navegación, etc … pero por supuesto, ponerlo donde mejor le convenga. Para la edificación, he puesto el mío en una clase llamada 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; } 

Asegúrese de que el recuento de pila posterior es mayor que 0, de lo contrario, una ArrayOutOfBoundsException podría ser lanzada en tiempo de ejecución. Si no es mayor que 0, devuelve null. Veremos un valor nulo más tarde …

Tercero, implementar en un fragmento

Implementar la interfaz de Backable en cualquier fragmento donde se necesita para anular el comportamiento del botón volver. Agregue el método de implementación.

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

En la onBackPressed() , coloque cualquier lógica que necesite. Si desea que el botón de retroceso no haga estallar la pila trasera (el comportamiento predeterminado), devuelva true , que su evento posterior se ha absorbido. De lo contrario, devuelva false.

Por último, en su Actividad …

onBackPressed() método onBackPressed() y añada esta lógica:

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

Obtenemos el fragmento actual en la pila trasera, luego hacemos una comprobación nula y determinamos si implementa nuestra interfaz de Backable . Si lo hace, determine si el evento fue absorbido. Si es así, hemos terminado con onBackPressed() y podemos devolverlo. De lo contrario, tratarlo como una prensa normal y llamar al método super.

Segunda Opción para no involucrar la Actividad

A veces, usted no quiere que la actividad maneje esto en absoluto, y usted necesita manejarlo directamente dentro del fragmento. ¿Pero quién dice que usted no puede tener Fragmentos con una API de la prensa trasera? Sólo extiende tu fragmento a una nueva clase.

Cree una clase abstracta que extienda Fragmento e implemente la interfaz 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(); } 

Como puede ver, cualquier fragmento que extienda BackableFragment automáticamente captura los clics anteriores usando la interfaz View.OnKeyListener . Simplemente llame al onBackButtonPressed() abstracto onBackButtonPressed() desde el método onBackButtonPressed() implementado usando la lógica estándar para discernir una pulsación de botón de retroceso. Si necesita registrar clics de claves distintos al botón de retroceso, asegúrese de llamar al super método al sobreescribir onKey() en su fragmento, de lo contrario anulará el comportamiento en la abstracción.

Simple de usar, sólo ampliar e implementar:

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

Dado que el método onBackButtonPressed() en la onBackButtonPressed() es abstracto, una vez extendido debe implementar onBackButtonPressed() . Devuelve void porque sólo necesita realizar una acción dentro de la clase de fragmento y no necesita transmitir la absorción de la prensa a la actividad. Asegúrate de llamar al onBackPressed() Activity onBackPressed() si lo que haces con el botón de retroceso no requiere manejo, de lo contrario, el botón de retroceso estará deshabilitado … ¡y no quieres eso!

Advertencias Como puede ver, esto establece el oyente clave en la vista raíz del fragmento, y necesitaremos enfocarlo. Si hay textos de edición implicados (o cualquier otra vista de robo de enfoque) en el fragmento que extiende esta clase, (u otros fragmentos o vistas internas que tengan el mismo), necesitará manejarlo por separado. Hay un buen artículo sobre la extensión de un EditText para perder el foco en una prensa posterior.

Espero que alguien encuentre esto útil. Codificación feliz.

¿Qué tal usar onDestroyView ()?

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

Bueno, lo hice así, y funciona para mí

Interfaz simple

FragmentOnBackClickInterface.java

 public interface FragmentOnBackClickInterface { void onClick(); } 

Ejemplo de implementación

MyFragment.java

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

Entonces solo anule la operación onBackPressed en la actividad

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

Si utiliza EventBus, es probablemente una solución mucho más simple:

En tu Fragmento:

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

Y en su clase de actividad puede definir:

 @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 es solo un objeto POJO

Esto es súper limpio y no hay problemas de interfaz / implementación.

Este es sólo un pequeño código que hará el truco:

  getActivity().onBackPressed(); 

Espero que ayude a alguien 🙂

onBackPressed() causa que Fragment se separe de Activity.

De acuerdo con @ Sterling Díaz respuesta creo que tiene razón. PERO alguna situación estará mal. (Por ejemplo, girar la pantalla)

Por lo tanto, creo que podríamos detectar si isRemoving() para lograr los objetivos.

Puede escribirlo en onDetach() o onDestroyView() . Eso es trabajo.

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

Usted debe agregar la interfaz a su proyecto como abajo;

 public interface OnBackPressed { void onBackPressed(); } 

Y entonces, debe implementar esta interfaz en su fragmento;

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

Y puede activar este evento onBackPressed bajo su evento onBackPressed de actividades como a continuación;

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

No implemente el método ft.addToBackStack () para que al pulsar el botón Atrás, la actividad termine.

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

Sólo tienes que seguir estos pasos:

Siempre mientras agrega un fragmento,

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

A continuación, en la actividad principal, anule onBackPressed()

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

Para manejar el botón Atrás en tu aplicación,

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

¡Eso es!

Respuesta muy corta y dulce:

 getActivity().onBackPressed(); 

Explicación de todo el escenario de mi caso:

Tengo FragmentA en MainActivity, estoy abriendo FragmentB de FragmentA (FragmentB es niño o fragmento anidado de FragmentA)

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

Ahora si quieres ir a FragmentA de FragmentB puedes simplemente poner getActivity().onBackPressed(); En FragmentB.

Mejor solución,

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

En el ciclo de vida de la actividad, el botón de retroceso de android siempre trata las transacciones de FragmentManager cuando utilizamos FragmentActivity o AppCompatActivity.

Para manejar el backstack no necesitamos manejar su conteo de backstack o marcar nada, pero debemos mantener el foco mientras agregamos o reemplazamos un fragmento. Por favor, encuentre los siguientes fragmentos para manejar los casos de botón de retroceso,

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

Aquí, no voy a añadir la pila de nuevo para mi fragmento de casa, ya que es la página de inicio de mi aplicación. Si agrega addToBackStack a HomeFragment entonces la aplicación esperará para eliminar todo el frament en acitivity entonces tendremos pantalla en blanco así que estoy manteniendo la condición siguiente,

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

Ahora, puedes ver el fragmento añadido anteriormente en acitvity y la aplicación saldrá al llegar a HomeFragment. También puede consultar los siguientes fragmentos.

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

Su simple si usted tiene una actividad A y usted hace 3 fragmentos como B, C y D. Ahora si usted está en el fragmento B o C y onBackPressed usted desea moverse en el fragmento D cada vez. Entonces usted tiene que apenas onBackPressed() el onBackPressed() En la actividad principal A y también cuando salta a cualquier fragmento y luego pasa un TAG o nombre de ese fragmento por el cual reconoce ese fragmento en la Actividad principal A.

Estoy dando el ejemplo de aquél por el cual usted puede entender fácilmente que ….

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

O si se está moviendo desde el fragmento B al fragmento C .. y en la parte posterior de la prensa que desea venir en el fragmento D … como a continuación

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

Ahora tienes que sobrescribir el método onBackPressed () en la actividad principal …. como abajo.

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

He utilizado otro enfoque de la siguiente manera:

  • Un autobús de eventos Otto para comunicarse entre la Actividad y sus Fragmentos
  • A Stack in the Activity containing custom back actions wrapped in a Runnable that the calling fragment defines
  • When onBackPressed is called in the controlling Activity, it pops the most recent custom back action and executes its Runnable . If there's nothing on the Stack, the default super.onBackPressed() is called

The full approach with sample code is included here as an answer to this other SO question .

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

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

Public class MyActivity extends Actividad {

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

Solo usa

  getActivity().onBackPressed(); 

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.

En fragmento:

 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

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.

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(); } } 
FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.