Gibt es eine Möglichkeit, wie wir onBackPressed()in Android Fragment implementieren können, ähnlich wie wir es in Android Activity implementieren?

Da haben die Fragment Lebenszyklus nicht onBackPressed(). Gibt es eine andere alternative Methode, um onBackPressed()Android 3.0-Fragmente zu überschreiben?

Ich habe auf diese Weise das Überschreiben onBackPressedin der Aktivität gelöst . Alle FragmentTransactionsind addToBackStackvor dem Festschreiben:

@Override
public void onBackPressed() {

    int count = getSupportFragmentManager().getBackStackEntryCount();

    if (count == 0) {
        super.onBackPressed();
        //additional code
    } else {
        getSupportFragmentManager().popBackStack();
    }

}

Meiner Meinung nach ist die beste Lösung:

JAVA-LÖSUNG

Erstellen Sie eine einfache Schnittstelle:

public interface IOnBackPressed {
    /**
     * If you return true the back press will not be taken into account, otherwise the activity will act naturally
     * @return true if your processing has priority if not false
     */
    boolean onBackPressed();
}

Und in deiner Aktivität

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

Endlich in deinem Fragment:

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

KOTLIN-LÖSUNG

1 - Schnittstelle erstellen

interface IOnBackPressed {
    fun onBackPressed(): Boolean
}

2 - Bereiten Sie Ihre Aktivität vor

class MyActivity : AppCompatActivity() {
    override fun onBackPressed() {
        val fragment =
            this.supportFragmentManager.findFragmentById(R.id.main_container)
        (fragment as? IOnBackPressed)?.onBackPressed()?.not()?.let {
            super.onBackPressed()
        }
    }
}

3 - Implementieren Sie in Ihrem Zielfragment

class MyFragment : Fragment(), IOnBackPressed {
    override fun onBackPressed(): Boolean {
        return if (myCondition) {
            //action not popBackStack
            true
        } else {
            false
        }
    }
}

Laut @HaMMeRed ist die Antwort hier Pseudocode, wie es funktionieren soll. Nehmen wir an, Ihre Hauptaktivität heißt BaseActivityuntergeordnete Fragmente (wie im Beispiel SlidingMenu lib). Hier sind die Schritte:

Zuerst müssen wir eine Schnittstelle und eine Klasse erstellen, die ihre Schnittstelle implementiert, um eine generische Methode zu haben

1. Klassenschnittstelle erstellen OnBackPressedListener

   public interface OnBackPressedListener {
       public void doBack();
   }

2. Erstellen Sie eine Klasse, die Fähigkeiten von implementiert 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. Seitdem werden wir an unserem Code BaseActivityund seinen Fragmenten arbeiten

4. Erstellen Sie einen privaten Listener über Ihrer Klasse BaseActivity

   protected OnBackPressedListener onBackPressedListener;

5. Methode zum Einstellen des Listeners erstellen BaseActivity

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

6. in override so onBackPressedetwas implementieren

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

7. In Ihrem Fragment in onCreateViewsollten Sie unseren Listener hinzufügen

   @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, wenn Sie jetzt in Fragment zurückklicken, sollten Sie Ihre benutzerdefinierte On-Back-Methode abfangen.

Dies hat bei mir funktioniert: 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;
        }
    });
}

Wenn Sie diese Art von Funktionalität wünschen, müssen Sie sie in Ihrer Aktivität überschreiben und dann YourBackPressedallen Ihren Fragmenten eine Schnittstelle hinzufügen , die Sie bei jedem Drücken der Zurück-Taste auf das entsprechende Fragment aufrufen.

Bearbeiten: Ich möchte meine vorherige Antwort anhängen.

Wenn ich dies heute tun würde, würde ich eine Sendung oder möglicherweise eine bestellte Sendung verwenden, wenn ich erwarten würde, dass andere Panels im Einklang mit dem Master- / Hauptinhaltspanel aktualisiert werden.

LocalBroadcastManagerin der Support-Bibliothek kann dabei helfen, und Sie senden einfach die Sendung ein onBackPressedund abonnieren Ihre Fragmente, die Sie interessieren. Ich denke, dass Messaging eine entkoppelte Implementierung ist und besser skaliert werden kann, daher wäre es jetzt meine offizielle Implementierungsempfehlung. Verwenden Sie einfach die IntentAktion von 'als Filter für Ihre Nachricht. Senden Sie Ihre neu erstellten ACTION_BACK_PRESSED, senden Sie sie aus Ihrer Aktivität und warten Sie in den entsprechenden Fragmenten darauf.

Nichts davon ist einfach zu implementieren und funktioniert auch nicht optimal.

Fragmente haben einen Methodenaufruf onDetach, der die Arbeit erledigt.

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

Dies wird den Job machen.

Wenn Sie androidx.appcompat:appcompat:1.1.0oder höher verwenden, können Sie OnBackPressedCallbackIhrem Fragment wie folgt ein hinzufügen

requireActivity()
    .onBackPressedDispatcher
    .addCallback(this, object : OnBackPressedCallback(true) {
        override fun handleOnBackPressed() {
            Log.d(TAG, "Fragment back pressed invoked")
            // Do custom work here    

            // if you want onBackPressed() to be called as normal afterwards
            if (isEnabled) {
                isEnabled = false
                requireActivity().onBackPressed()
            }
        }
    }
)

Siehe https://developer.android.com/guide/navigation/navigation-custom-back

Fügen addToBackStackSie einfach Folgendes hinzu, während Sie zwischen Ihren Fragmenten wechseln:

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

Wenn Sie schreiben addToBackStack(null), wird es von selbst behandelt, aber wenn Sie ein Tag geben, sollten Sie es manuell behandeln.

Da diese Frage und einige der Antworten älter als fünf Jahre sind, möchte ich meine Lösung mitteilen. Dies ist eine Fortsetzung und Modernisierung der Antwort von @oyenigun

AKTUALISIEREN: Am Ende dieses Artikels habe ich eine alternative Implementierung hinzugefügt, die eine abstrakte Fragmenterweiterung verwendet, die die Aktivität überhaupt nicht einbezieht. Dies ist nützlich für alle Benutzer mit einer komplexeren Fragmenthierarchie, die verschachtelte Fragmente umfasst, die ein anderes Back-Verhalten erfordern.

Ich musste dies implementieren, da einige der von mir verwendeten Fragmente kleinere Ansichten haben, die ich mit der Schaltfläche "Zurück" schließen möchte, z. B. kleine Informationsansichten, die angezeigt werden usw. Dies ist jedoch gut für alle, die das Verhalten von überschreiben müssen der Zurück-Knopf in Fragmenten.

Definieren Sie zunächst eine Schnittstelle

public interface Backable {
    boolean onBackPressed();
}

Diese Schnittstelle, die ich aufrufe Backable(ich bin ein Stickler für Namenskonventionen), hat eine einzige Methode onBackPressed(), die einen booleanWert zurückgeben muss. Wir müssen einen booleschen Wert erzwingen, da wir wissen müssen, ob das Drücken der Zurück-Taste das Back-Ereignis "absorbiert" hat. Zurückgeben truebedeutet, dass dies der Fall ist und keine weitere Aktion erforderlich ist. Andernfalls muss falsedie Standard-Zurückaktion weiterhin ausgeführt werden. Diese Schnittstelle sollte eine eigene Datei sein (vorzugsweise in einem separaten Paket mit dem Namen interfaces). Denken Sie daran, dass es eine gute Praxis ist, Ihre Klassen in Pakete zu unterteilen.

Zweitens finden Sie das obere Fragment

Ich habe eine Methode erstellt, die das letzte FragmentObjekt im Backstack zurückgibt. Ich verwende Tags ... Wenn Sie IDs verwenden, nehmen Sie die erforderlichen Änderungen vor. Ich habe diese statische Methode in einer Utility-Klasse, die sich mit Navigationszuständen usw. befasst, aber natürlich platzieren Sie sie dort, wo sie am besten zu Ihnen passt. Zur Erbauung habe ich meine in eine Klasse namens gesetzt 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;
}

Stellen Sie sicher, dass die Anzahl der Backstacks größer als 0 ist, da dies sonst ArrayOutOfBoundsExceptionzur Laufzeit ausgelöst werden kann. Wenn es nicht größer als 0 ist, geben Sie null zurück. Wir werden später nach einem Nullwert suchen ...

Drittens in einem Fragment implementieren

Implementieren Sie die BackableSchnittstelle in dem Fragment, in dem Sie das Verhalten der Zurück-Schaltfläche überschreiben müssen. Fügen Sie die Implementierungsmethode hinzu.

public class SomeFragment extends Fragment implements 
        FragmentManager.OnBackStackChangedListener, Backable {

...

    @Override
    public boolean onBackPressed() {

        // Logic here...
        if (backButtonShouldNotGoBack) {
            whateverMethodYouNeed();
            return true;
        }
        return false;
    }

}

onBackPressed()Geben Sie beim Überschreiben die gewünschte Logik ein. Wenn Sie möchten, dass die Zurück-Schaltfläche den Back-Stack nicht öffnet (Standardverhalten), geben Sie true zurück , damit Ihr Back-Ereignis absorbiert wurde. Andernfalls geben Sie false zurück.

Zuletzt in Ihrer Aktivität ...

Überschreiben Sie die onBackPressed()Methode und fügen Sie diese Logik hinzu:

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

Wir erhalten das aktuelle Fragment im Backstack, führen dann eine Nullprüfung durch und stellen fest, ob es unsere BackableSchnittstelle implementiert . Wenn dies der Fall ist, stellen Sie fest, ob das Ereignis absorbiert wurde. Wenn ja, sind wir fertig onBackPressed()und können zurückkehren. Andernfalls behandeln Sie es als normales Zurückdrücken und rufen Sie die Supermethode auf.

Zweite Option, die Aktivität nicht einzubeziehen

Manchmal möchten Sie nicht, dass die Aktivität dies überhaupt behandelt, und Sie müssen sie direkt innerhalb des Fragments behandeln. Aber wer sagt, dass Sie keine Fragmente mit einer Backpress-API haben können? Erweitern Sie einfach Ihr Fragment auf eine neue Klasse.

Erstellen Sie eine abstrakte Klasse, die Fragment erweitert und die View.OnKeyListnerSchnittstelle implementiert ...

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

Wie Sie sehen können, erfasst jedes erweiterte Fragment BackableFragmentautomatisch Rückklicks über die View.OnKeyListenerBenutzeroberfläche. Rufen Sie einfach die abstrakte onBackButtonPressed()Methode innerhalb der implementierten onKey()Methode mit der Standardlogik auf, um einen Zurück-Tastendruck zu erkennen. Wenn Sie andere Tastenklicks als die Schaltfläche "Zurück" registrieren müssen, rufen Sie die superMethode beim Überschreiben onKey()in Ihrem Fragment auf. Andernfalls wird das Verhalten in der Abstraktion überschrieben .

Einfach zu bedienen, einfach erweitern und implementieren:

public class FragmentChannels extends BackableFragment {

    ...

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

    ...
}

Da die onBackButtonPressed()Methode in der Superklasse abstrakt ist, müssen Sie sie implementieren, sobald Sie sie erweitern onBackButtonPressed(). Es kehrt zurück, voidweil es nur eine Aktion innerhalb der Fragmentklasse ausführen muss und die Absorption der Presse nicht an die Aktivität zurücksenden muss. Stellen Sie sicher, dass Sie die Aktivitätsmethode aufrufen onBackPressed(), wenn für alles, was Sie mit der Zurück-Schaltfläche tun, keine Behandlung erforderlich ist. Andernfalls wird die Zurück-Schaltfläche deaktiviert ... und das möchten Sie nicht!

Vorsichtsmaßnahmen Wie Sie sehen können, wird der Key Listener auf die Stammansicht des Fragments gesetzt, und wir müssen es fokussieren. Wenn in Ihrem Fragment Bearbeitungstexte (oder andere Ansichten, die den Fokus stehlen) enthalten sind, die diese Klasse erweitern (oder andere innere Fragmente oder Ansichten, die dieselbe haben), müssen Sie dies separat behandeln. Es gibt einen guten Artikel über die Erweiterung eines EditText , um den Fokus auf ein Zurückdrücken zu verlieren.

Ich hoffe, jemand findet das nützlich. Viel Spaß beim Codieren.

Die Lösung ist einfach:

1) Wenn Sie eine Basisfragmentklasse haben, die alle Fragmente erweitern, fügen Sie diesen Code zu ihrer Klasse hinzu, andernfalls erstellen Sie eine solche Basisfragmentklasse

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

2) Überschreiben Sie in Ihrer Aktivitätsklasse onBackPressed wie folgt:

private BaseFragment _currentFragment;

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

3) Fügen Sie in Ihrer Fragment-Klasse den gewünschten Code hinzu:

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

onBackPressed() bewirkt, dass sich das Fragment von der Aktivität löst.

Laut der Antwort von @Sterling Diaz denke ich, dass er Recht hat. ABER eine Situation wird falsch sein. (zB Bildschirm drehen)

Ich denke also, wir könnten herausfinden, ob wir isRemoving()Ziele erreichen sollen.

Sie können es bei onDetach()oder schreiben onDestroyView(). Es ist Arbeit.

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

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

Nun, ich habe es so gemacht und es funktioniert für mich

Einfache Schnittstelle

FragmentOnBackClickInterface.java

public interface FragmentOnBackClickInterface {
    void onClick();
}

Beispielimplementierung

MyFragment.java

public class MyFragment extends Fragment implements FragmentOnBackClickInterface {

// other stuff

public void onClick() {
       // what you want to call onBackPressed?
}

dann überschreiben Sie einfach onBackPressed in Aktivität

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

Sie sollten Ihrem Projekt eine Schnittstelle wie unten hinzufügen.

public interface OnBackPressed {

     void onBackPressed();
}

Und dann sollten Sie diese Schnittstelle auf Ihrem Fragment implementieren.

public class SampleFragment extends Fragment implements OnBackPressed {

    @Override
    public void onBackPressed() {
        //on Back Pressed
    }

}

Und Sie können dieses onBackPressed-Ereignis unter Ihren Aktivitäten onBackPressed-Ereignis wie unten auslösen.

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

Dies ist nur ein kleiner Code, der den Trick macht:

 getActivity().onBackPressed();

Hoffe es hilft jemandem :)

Wenn Sie EventBus verwenden, ist dies wahrscheinlich eine weitaus einfachere Lösung:

In deinem Fragment:

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

und in Ihrer Aktivitätsklasse können Sie Folgendes definieren:

@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 ist nur ein POJO-Objekt

Dies ist super sauber und es gibt keine Probleme mit der Schnittstelle / Implementierung.

Das ist meine Lösung:

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

und in Fragment:

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

        // some codes

        return true;
    }
});

Mit der Navigationskomponente können Sie dies folgendermaßen tun :

Java

public class MyFragment extends Fragment {

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // This callback will only be called when MyFragment is at least Started.
    OnBackPressedCallback callback = new OnBackPressedCallback(true /* enabled by default */) {
        @Override
        public void handleOnBackPressed() {
            // Handle the back button event
        }
    });
    requireActivity().getOnBackPressedDispatcher().addCallback(this, callback);

    // The callback can be enabled or disabled here or in handleOnBackPressed()
}
...
}

Kotlin

class MyFragment : Fragment() {

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    // This callback will only be called when MyFragment is at least Started.
    val callback = requireActivity().onBackPressedDispatcher.addCallback(this) {
        // Handle the back button event
    }

    // The callback can be enabled or disabled here or in the lambda
}
...
}

Wie wäre es mit onDestroyView ()?

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

@Override
public void onResume() {
    super.onResume();

    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
                replaceFragmentToBackStack(getActivity(), WelcomeFragment.newInstance(bundle), tags);

                return true;
            }

            return false;
        }
    });
}

public class MyActivity extends Activity {

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

Fügen Sie in Ihrem Fragment Folgendes hinzu. Vergessen Sie nicht, die Schnittstelle von mainactivity zu implementieren.

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

}

In meiner Lösung (Kotlin);

Ich verwende die Funktion onBackAlternative als Parameter für BaseActivity .

BaseActivity

abstract class BaseActivity {

    var onBackPressAlternative: (() -> Unit)? = null

    override fun onBackPressed() {
        if (onBackPressAlternative != null) {
            onBackPressAlternative!!()
        } else {
            super.onBackPressed()
        }
    }
}

Ich habe eine Funktion zum Setzen von onBackPressAlternative auf BaseFragment .

BaseFragment

abstract class BaseFragment {

     override fun onStart() {
        super.onStart()
        ...
        setOnBackPressed(null) // Add this
     }

      //Method must be declared as open, for overriding in child class
     open fun setOnBackPressed(onBackAlternative: (() -> Unit)?) {
         (activity as BaseActivity<*, *>).onBackPressAlternative = onBackAlternative
     }
}

Dann kann mein onBackPressAlternative für Fragmente verwendet werden.

Unterfragmente

override fun setOnBackPressed(onBackAlternative: (() -> Unit)?) {
    (activity as BaseActivity<*, *>).onBackPressAlternative = {
        // TODO Your own custom onback function 
    }
}

Implementieren Sie die Methode ft.addToBackStack () nicht, damit Ihre Aktivität beendet wird, wenn Sie die Zurück-Taste drücken.

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

Befolgen Sie einfach diese Schritte:

Immer beim Hinzufügen eines Fragments,

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

Überschreiben Sie dann in der Hauptaktivität onBackPressed()

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

Um die Zurück-Schaltfläche in Ihrer App zu handhaben,

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

Das ist es!

Im Aktivitätslebenszyklus behandelt die Android-Schaltfläche "Zurück" immer FragmentManager-Transaktionen, wenn FragmentActivity oder AppCompatActivity verwendet werden.

Um den Backstack zu handhaben, müssen wir nicht die Anzahl der Backstacks behandeln oder irgendetwas markieren, aber wir sollten den Fokus behalten, während wir ein Fragment hinzufügen oder ersetzen. Hier finden Sie die folgenden Ausschnitte, um die Fälle mit den Zurück-Tasten zu behandeln:

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

Hier füge ich keinen Backstack für mein Home-Fragment hinzu, da es sich um die Homepage meiner Anwendung handelt. Wenn Sie addToBackStack zu HomeFragment hinzufügen, wartet die App darauf, alle Framente in der Aktivität zu entfernen. Dann wird ein leerer Bildschirm angezeigt, sodass ich die folgende Bedingung behalte:

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

Jetzt können Sie das zuvor hinzugefügte Fragment auf acitvity sehen und die App wird beendet, wenn Sie HomeFragment erreichen. Sie können sich auch die folgenden Schnipsel ansehen.

@Override
public void onBackPressed() {

    if (mDrawerLayout.isDrawerOpen(Gravity.LEFT)) {
        closeDrawer();
    } else {
        super.onBackPressed();
    }
}

Fragment: Erstellen Sie ein BaseFragment, indem Sie eine Methode platzieren:

 public boolean onBackPressed();

Aktivität:

@Override
public void onBackPressed() {
    List<Fragment> fragments = getSupportFragmentManager().getFragments();
    if (fragments != null) {
        for (Fragment fragment : fragments) {
            if (!fragment.isVisible()) continue;

            if (fragment instanceof BaseFragment && ((BaseFragment) fragment).onBackPressed()) {
                return;
            }
        }
    }

    super.onBackPressed();
}

Ihre Aktivität wird über die angehängten und sichtbaren Fragmente ausgeführt und ruft onBackPressed () für jedes von ihnen auf und bricht ab, wenn eines von ihnen 'true' zurückgibt (was bedeutet, dass es behandelt wurde, also keine weiteren Aktionen).

Nach dem AndroidX Release Notes , androidx.activity 1.0.0-alpha01wird freigegeben und führt ComponentActivityeine neue Basisklasse der bestehenden FragmentActivityund AppCompatActivity. Und diese Version bringt uns eine neue Funktion:

Sie können jetzt ein OnBackPressedCallbackVia registrieren addOnBackPressedCallback, um onBackPressed()Rückrufe zu erhalten, ohne die Methode in Ihrer Aktivität überschreiben zu müssen.

Sie können Fragmente in Aktivitäten registrieren, um das Zurückdrücken zu handhaben:

interface BackPressRegistrar {
    fun registerHandler(handler: BackPressHandler)
    fun unregisterHandler(handler: BackPressHandler)
}

interface BackPressHandler {
    fun onBackPressed(): Boolean
}

Verwendungszweck:

Im Fragment:

private val backPressHandler = object : BackPressHandler {
    override fun onBackPressed(): Boolean {
        showClosingWarning()
        return false
    }
}

override fun onResume() {
    super.onResume()
    (activity as? BackPressRegistrar)?.registerHandler(backPressHandler)
}

override fun onStop() {
    (activity as? BackPressRegistrar)?.unregisterHandler(backPressHandler)
    super.onStop()
}

In Aktivität:

class MainActivity : AppCompatActivity(), BackPressRegistrar {


    private var registeredHandler: BackPressHandler? = null
    override fun registerHandler(handler: BackPressHandler) { registeredHandler = handler }
    override fun unregisterHandler(handler: BackPressHandler) { registeredHandler = null }

    override fun onBackPressed() {
        if (registeredHandler?.onBackPressed() != false) super.onBackPressed()
    }
}

Das Bereitstellen einer benutzerdefinierten Rückennavigation durch Handling von onBackPressed ist jetzt mit Rückrufen innerhalb des Fragments einfacher.

class MyFragment : Fragment() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val onBackPressedCallback = object : OnBackPressedCallback(true) {
            override fun handleOnBackPressed() {
                if (true == conditionForCustomAction) {
                    myCustomActionHere()
                } else  NavHostFragment.findNavController(this@MyFragment).navigateUp();    
        }
    }
    requireActivity().onBackPressedDispatcher.addCallback(
        this, onBackPressedCallback
    )
    ...
}

Wenn Sie die Standard-Rückaktion basierend auf einer bestimmten Bedingung möchten, können Sie Folgendes verwenden:

 NavHostFragment.findNavController(this@MyFragment).navigateUp();

Fügen Sie in der onCreate-Methode des Fragments Folgendes hinzu:

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    OnBackPressedCallback callback = new OnBackPressedCallback(true) {
        @Override
        public void handleOnBackPressed() {
            //Handle the back pressed
        }
    };
    requireActivity().getOnBackPressedDispatcher().addCallback(this, callback);
}

Beste Lösung,

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

            }
        }
    }
}