Biz uygulamak hangi bir yolu var mı onBackPressed()biz Android Aktivite uygulamak hangi tarzına benzer Android Fragment?

Fragment yaşam döngüsünde yoktur onBackPressed(). onBackPressed()Android 3.0 parçalarında aşırı sürüş için başka bir yöntem var mı ?

Bu şekilde onBackPressedAktivitede geçersiz kılma sorununu çözdüm . Tüm FragmentTransactionşunlardır addToBackStackgerçekleştirmeden önce:

@Override
public void onBackPressed() {

    int count = getSupportFragmentManager().getBackStackEntryCount();

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

}

Bence en iyi çözüm:

JAVA ÇÖZÜM

Basit arayüz oluşturun:

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

Ve Faaliyetinizde

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

Sonunda Parçanızda:

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

KOTLIN ÇÖZÜMÜ

1 - Arayüz Oluştur

interface IOnBackPressed {
    fun onBackPressed(): Boolean
}

2 - Faaliyetinizi Hazırlayın

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

3 - Hedef Parçanıza uygulayın

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

@HaMMeRed cevabına göre buradaki sözde kod nasıl çalışmalı. Diyelim ki BaseActivityalt bölümleri olan ana etkinliğiniz çağrılıyor (SlidingMenu lib örneğinde olduğu gibi). İşte adımlar:

Öncelikle, jenerik bir metoda sahip olmak için arayüzünü uygulayan arayüz ve sınıf oluşturmamız gerekiyor

1. Sınıf arayüzü oluştur OnBackPressedListener

   public interface OnBackPressedListener {
       public void doBack();
   }

2. Becerilerini uygulayan bir sınıf yaratın 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. Artık kodumuz BaseActivityve kodları üzerinde çalışacağız.

4. Sınıfınızın üstünde özel dinleyici oluşturun BaseActivity

   protected OnBackPressedListener onBackPressedListener;

5. dinleyiciyi ayarlamak için yöntem oluştur BaseActivity

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

6. geçersiz onBackPressedkılmada böyle bir şey uygulayın

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

7. senin fragmanında içinde onCreateViewbizim dinleyici eklemek gerekir

   @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, şimdi parçaya geri tıkladığınızda, özel sırt yönteminizi yakalamalısınız.

Bu benim için çalıştı: 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;
        }
    });
}

Bu tür bir işlevsellik istiyorsanız, etkinliğinizde geçersiz kılmanız ve ardından YourBackPressed geri düğmesine her basıldığında ilgili parçayı çağırdığınız tüm parçalarınıza arabirim gerekir.

Düzenleme: Önceki cevabımı eklemek istiyorum.

Bunu bugün yapsaydım, diğer panellerin ana / ana içerik paneliyle uyumlu olarak güncellenmesini beklesem bir yayın veya muhtemelen sıralı bir yayın kullanırdım.

LocalBroadcastManagerDestek Kitaplığı'ndaki bu konuda size yardımcı olabilirsiniz ve sadece yayını gönderip onBackPressedilgilenen parçalarınıza abone olursunuz. Messaging'in daha ayrıştırılmış bir uygulama olduğunu ve daha iyi ölçekleneceğini düşünüyorum, bu yüzden şimdi resmi uygulama önerim olacak. IntentMesajınızın filtresi olarak 'eylemini kullanın . yeni oluşturulanını gönderACTION_BACK_PRESSED gönderin, aktivitenizden gönderin ve ilgili parçalarda dinleyin.

Bunların hiçbirinin uygulanması kolay değildir ve en uygun şekilde çalışmaz.

Parçalar, işi yapacak bir yöntem çağrısı onDetach'a sahiptir.

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

BU İŞİ YAPACAK.

androidx.appcompat:appcompat:1.1.0Veya üstünü kullanıyorsanız OnBackPressedCallback, parçanıza aşağıdaki gibi bir

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

Bkz. Https://developer.android.com/guide/navigation/navigation-custom-back

addToBackStackAşağıdaki gibi parçalarınız arasında geçiş yaparken ekleyin :

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

yazarsanız addToBackStack(null), bunu kendi başına halleder, ancak bir etiket verirseniz, manuel olarak ele almalısınız.

Bu soru ve bazı cevaplar beş yaşın üzerinde olduğundan çözümümü paylaşmama izin verin. Bu @oyenigun'un cevabı için bir takip ve modernizasyon

GÜNCELLEME: Bu makalenin en altına, Etkinliği hiç içermeyen soyut bir Fragment uzantısı kullanarak alternatif bir uygulama ekledim.

Bunu kullanmam gerekiyordu, çünkü kullandığım bazı parçaların, geri açılan küçük bilgi görünümleri gibi geri düğmesiyle kapatmak istediğim daha küçük görünümleri var, ancak bu, davranışını geçersiz kılması gereken herkes için iyi parçaların içindeki geri düğmesi.

İlk olarak, bir Arayüz tanımlayın

public interface Backable {
    boolean onBackPressed();
}

Aradığım bu arabirimin Backable(adlandırma kuralları için bir stickler olduğum), onBackPressed()bir booleandeğer döndürmesi gereken tek bir yöntemi var . Bir boolean değeri uygulamamız gerekir, çünkü geri düğmesine basmanın geri olayı "absorbe edip etmediğini" bilmemiz gerekir. Geri dönmek true, bunun olduğu ve başka bir işlem yapılması gerekmediği anlamına gelir, aksi takdirde, falsevarsayılan geri işlemin yine de yapılması gerektiğini söyler. Bu arayüz kendi dosyası olmalıdır (tercihen ayrı bir pakette interfaces). Unutmayın, sınıflarınızı paketlere ayırmak iyi bir uygulamadır.

İkincisi, üst parçayı bulun

FragmentArka yığındaki son nesneyi döndüren bir yöntem oluşturdum . Etiketleri kullanıyorum ... kimlikler kullanıyorsanız, gerekli değişiklikleri yapın. Navigasyon durumları, vb ile ilgilenen bir yardımcı program sınıfında bu statik yöntem var ... ama tabii ki, size en uygun yere koy. Eğitim için, benimkini adlı bir sınıfa koydum 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;
}

Arka yığın sayısının 0'dan büyük olduğundan emin olun, aksi takdirde ArrayOutOfBoundsExceptionçalışma zamanında bir fırlatma yapılabilir. 0'dan büyük değilse null değerini döndürün. Daha sonra boş bir değer olup olmadığını kontrol edeceğiz ...

Üçüncüsü, Bir Parçada Uygulama

Uygulamak Backablegeri düğmesi davranışı geçersiz gereken yere hangisi parçası içinde arayüz. Uygulama yöntemini ekleyin.

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

...

    @Override
    public boolean onBackPressed() {

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

}

In onBackPressed()geçersiz kılma, nasıl istersen mantık koydu. Geri düğmesi istiyorsanız değil arka yığını (varsayılan davranış) pop, dönmek gerçek sırt olay absorbe edildiğini,. Aksi takdirde, false değerini döndürün.

Son olarak, Faaliyetinizde ...

onBackPressed()Yöntemi geçersiz kılın ve bu mantığı buna ekleyin:

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

Mevcut parçayı arka yığın halinde alıyoruz, sonra boş bir kontrol yapıyoruz ve Backablearayüzümüzü uygulayıp uygulamadığını tespit ediyoruz . Varsa, olayın emilip emilmediğini belirleyin. Eğer öyleyse, işimiz bitti onBackPressed()ve geri dönebiliriz. Aksi takdirde, normal bir geri basma gibi davranın ve süper yöntemi çağırın.

Etkinliği Dahil Etmemek İçin İkinci Seçenek

Bazen, Aktivitenin bunu hiç ele almasını istemezsiniz ve doğrudan parça içinde ele almanız gerekir. Peki geri bastırma API'sı olan Fragmanlara sahip olamayacağınızı kim söylüyor ? Parçanızı yeni bir sınıfa genişletmeniz yeterlidir.

Fragment'ı genişleten ve View.OnKeyListnerarabirimi uygulayan soyut bir sınıf oluşturun ...

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

Gördüğünüz gibi, uzayan herhangi bir parça arayüzü BackableFragmentkullanarak otomatik olarak geri tıklamaları yakalayacaktır View.OnKeyListener. Sadece bir geri düğmesine basın ayırt etmek için standart mantık kullanarak onBackButtonPressed()uygulanan onKey()yöntem içinde soyut yöntemi çağırmak . Geri düğmesi dışındaki tuş tıklamalarını kaydetmeniz gerekiyorsa super, parçanızda geçersiz kılınırken yöntemi çağırdığınızdan emin olun onKey(), aksi takdirde soyutlamadaki davranışı geçersiz kılarsınız.

Kullanımı basit, sadece genişletip uygulayın:

public class FragmentChannels extends BackableFragment {

    ...

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

    ...
}

Yana onBackButtonPressed()süper sınıfındaki yöntem soyut, sen uzatmak kez uygulamalıdır onBackButtonPressed(). Geri dönüyor, voidçünkü sadece parça sınıfı içinde bir eylem gerçekleştirmesi gerekiyor ve basının emilimini tekrar Faaliyete aktarması gerekmiyor. Geri düğmesi ile ne yaparsanız yapın işlem gerektirmiyorsa , Etkinlik yöntemini çağırdığınızdan emin olunonBackPressed() , aksi takdirde geri düğmesi devre dışı bırakılır ... ve bunu istemezsiniz!

Uyarılar Gördüğünüz gibi, bu anahtar dinleyiciyi parçanın kök görünümüne ayarlar ve odaklamamız gerekir. Parçanızda bu sınıfı genişleten (veya aynı iç kısımlara veya aynı görünümlere sahip) düzenleme metinleri (veya başka bir odak çalma görünümü) varsa, bunu ayrı olarak ele almanız gerekir. Arka baskıya odaklanmamak için bir EditText'i genişletmeyle ilgili iyi bir makale var .

Umarım birisi bunu faydalı bulur. Mutlu kodlama.

Çözüm basit:

1) Tüm parçaların genişlettiği bir temel parça sınıfınız varsa, bu kodu sınıfına ekleyin, aksi takdirde böyle bir temel parça sınıfı oluşturun

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

2) Activity sınıfınızda, onBackPressed'i aşağıdaki gibi geçersiz kılın:

private BaseFragment _currentFragment;

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

3) Parça sınıfınıza istediğiniz kodu ekleyin:

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

onBackPressed() Parçanın Etkinlikten ayrılmasına neden olur.

@Sterling Diaz cevabına göre haklı olduğunu düşünüyorum. AMA bazı durumlar yanlış olacak. (örn. Ekranı Döndür)

Dolayısıyla, isRemoving()hedeflere ulaşıp ulaşamayacağımızı tespit edebileceğimizi düşünüyorum .

Sen de bunu yazabilir onDetach()veya onDestroyView(). Bu iş.

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

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

Bunu böyle yaptım ve benim için çalışıyor

Basit arayüz

FragmentOnBackClickInterface.java

public interface FragmentOnBackClickInterface {
    void onClick();
}

Örnek uygulama

MyFragment.java

public class MyFragment extends Fragment implements FragmentOnBackClickInterface {

// other stuff

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

sonra yalnızca etkinlikte onBackPressed'i geçersiz kılın

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

Projenize aşağıdaki gibi bir arayüz eklemelisiniz;

public interface OnBackPressed {

     void onBackPressed();
}

Ve sonra, bu arayüzü parçanıza uygulamalısınız;

public class SampleFragment extends Fragment implements OnBackPressed {

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

}

Ve bu onBackPressed olayını aşağıdaki gibi onBackPressed olayındaki faaliyetleriniz altında tetikleyebilirsiniz;

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

Bu sadece hile yapacak küçük bir kod:

 getActivity().onBackPressed();

Umarım birine yardımcı olur :)

EventBus kullanıyorsanız, muhtemelen çok daha basit bir çözümdür:

Parçanızda:

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

Etkinlik sınıfınızda şunları tanımlayabilirsiniz:

@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 sadece bir POJO nesnesidir

Bu süper temiz ve hiçbir arayüz / uygulama güçlük.

bu benim çözümüm:

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

ve Fragment'ta:

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

        // some codes

        return true;
    }
});

Kullanılması Navigasyon bileşenini bunu yapabilirsiniz böyle :

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

OnDestroyView () kullanmaya ne dersiniz?

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

parçanızda aşağıdakileri ekleyin, mainactivity'nin arayüzünü uygulamayı unutmayın.

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

}

Benim çözümümde (Kotlin);

Ben bir parametre olarak onBackAlternative fonksiyonunu kullanıyorum BaseActivity .

BaseActivity

abstract class BaseActivity {

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

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

Ben kümesi için bir işlevi vardır onBackPressAlternative üzerinde 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
     }
}

Sonra onBackPressAlternative'im parçalar üzerinde kullanıma hazır.

Alt Parçalar

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

Ft.addToBackStack () yöntemini uygulamayın, böylece geri düğmesine bastığınızda etkinliğiniz sona erer.

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

Şu adımları uygulamanız yeterlidir:

Her zaman bir parça eklerken,

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

Ardından ana aktivitede geçersiz kılın onBackPressed()

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

Uygulamanızdaki geri düğmesini işlemek için,

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

Bu kadar!

Etkinlik yaşam döngüsünde, FragmentActivity veya AppCompatActivity kullandığımızda her zaman android geri düğmesi FragmentManager işlemleri ile ilgilenir.

Backstack'i işlemek için backstack sayısını işlememize veya hiçbir şeyi etiketlememize gerek yoktur, ancak bir parça eklerken veya değiştirirken odaklanmaya devam etmeliyiz. Geri düğmesi kutularını işlemek için lütfen aşağıdaki parçacıkları bulun,

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

Burada, uygulamamın ana sayfası olduğu için ev parçam için geri yığın eklemeyeceğim. HomeFragment'a addToBackStack eklerseniz, uygulama tüm kokuyu kaldırmak için bekler, ardından boş ekran alırız, bu yüzden aşağıdaki koşulu koruyorum,

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

Şimdi, daha önce eklenen acitvity parçasını görebilirsiniz ve HomeFragment'a ulaştığınızda uygulama çıkacaktır. aşağıdaki snippet'lere de bakabilirsiniz.

@Override
public void onBackPressed() {

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

Parça: Bir yöntem yerleştirerek bir BaseFragment yapın:

 public boolean onBackPressed();

Aktivite:

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

Etkinliğiniz ekli ve görünür parçalar üzerinde çalışacak ve her birinde onBackPressed () yöntemini çağıracak ve bunlardan biri 'true' değerini döndürürse iptal edilecektir (yani ele alındığı için başka işlem yapılmaz).

Göre AndroidX sürüm notları , androidx.activity 1.0.0-alpha01serbest ve tanıtır edilir ComponentActivity, mevcut yeni bir temel sınıf FragmentActivityveAppCompatActivity . Ve bu sürüm bize yeni bir özellik getiriyor:

Artık bir kayıt olabilirsiniz OnBackPressedCallbackyoluyla addOnBackPressedCallbackalmak onBackPressed()için aktivitesinde yöntemini geçersiz gerek kalmadan geri aramalar.

Parçayı geri basmak için parçayı aktiviteye kaydedebilirsiniz:

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

interface BackPressHandler {
    fun onBackPressed(): Boolean
}

kullanımı:

Fragman:

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

Faaliyette:

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

OnBackPressed'i kullanarak özel geri gezinme sağlamak parçanın içindeki geri aramalarla artık daha kolay.

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

Bazı koşullara dayalı olarak varsayılan geri işlem istiyorsanız, aşağıdakileri kullanabilirsiniz:

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

Parçanın onCreate yönteminin içine aşağıdakileri ekleyin:

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

En iyi çözüm,

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

            }
        }
    }
}