Apakah ada cara di mana kita dapat menerapkan onBackPressed()di Android Fragment mirip dengan cara di mana kita menerapkan dalam Aktivitas Android?

Karena siklus hidup Fragmen tidak memiliki onBackPressed(). Apakah ada metode alternatif lain untuk berkendara onBackPressed()di fragmen Android 3.0?

Saya memecahkan dengan cara ini menimpa onBackPresseddalam Kegiatan. Semua FragmentTransactionadalah addToBackStacksebelum komit:

@Override
public void onBackPressed() {

    int count = getSupportFragmentManager().getBackStackEntryCount();

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

}

Menurut saya solusi terbaik adalah:

SOLUSI JAWA

Buat antarmuka sederhana:

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

Dan dalam Aktivitas Anda

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

Akhirnya di Fragmen Anda:

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

SOLUSI KOTLIN

1 - Buat Antarmuka

interface IOnBackPressed {
    fun onBackPressed(): Boolean
}

2 - Siapkan Aktivitas Anda

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

3 - Terapkan dalam Fragmen target Anda

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

Menurut jawaban @HaMMeRed di sini adalah pseudocode bagaimana cara kerjanya. Katakanlah bahwa aktivitas utama Anda disebut BaseActivityyang memiliki fragmen anak (seperti dalam contoh SlidingMenu lib). Berikut langkah-langkahnya:

Pertama kita perlu membuat antarmuka dan kelas yang mengimplementasikan antarmuka untuk memiliki metode generik

1. Buat antarmuka kelas OnBackPressedListener

   public interface OnBackPressedListener {
       public void doBack();
   }
   

2. Buat kelas yang mengimplementasikan keterampilan 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. Sejak sekarang, kami akan mengerjakan kode kami BaseActivitydan bagian-bagiannya

4. Buat pendengar pribadi di atas kelas Anda BaseActivity

   protected OnBackPressedListener onBackPressedListener;

5. buat metode untuk mengatur pendengar BaseActivity

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

6. di override onBackPressedmengimplementasikan sesuatu seperti itu

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

7. dalam fragmen onCreateViewAnda, Anda harus menambahkan pendengar kami

   @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, sekarang ketika Anda mengklik kembali dalam fragmen Anda harus menangkap kebiasaan Anda pada metode kembali.

Ini berfungsi untuk saya: 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;
        }
    });
}

Jika Anda menginginkan fungsionalitas semacam itu, Anda perlu menimpanya dalam aktivitas Anda, dan kemudian menambahkan YourBackPressedantarmuka ke semua fragmen Anda, yang Anda panggil pada fragmen yang relevan setiap kali tombol kembali ditekan.

Sunting: Saya ingin menambahkan jawaban saya sebelumnya.

Jika saya melakukan ini hari ini, saya akan menggunakan siaran, atau mungkin siaran yang dipesan jika saya mengharapkan panel lain untuk memperbarui secara bersamaan ke panel konten utama / master.

LocalBroadcastManagerdi Perpustakaan Dukungan dapat membantu dengan ini, dan Anda hanya mengirim siaran onBackPresseddan berlangganan fragmen Anda yang peduli. Saya pikir Messaging adalah implementasi yang lebih terpisah dan akan skala yang lebih baik, jadi itu akan menjadi rekomendasi implementasi resmi saya sekarang. Cukup gunakan Intenttindakan sebagai filter untuk pesan Anda. kirim yang baru Anda buat ACTION_BACK_PRESSED, kirimkan dari aktivitas Anda dan dengarkan dalam fragmen yang relevan.

Tidak ada yang mudah diimplementasikan dan tidak akan berfungsi secara optimal.

Fragmen memiliki pemanggilan metode onDetach yang akan melakukan pekerjaan.

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

INI AKAN MELAKUKAN PEKERJAAN.

Jika Anda menggunakan androidx.appcompat:appcompat:1.1.0atau di atas maka Anda dapat menambahkan OnBackPressedCallbackfragmen Anda sebagai berikut

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

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

Cukup tambahkan addToBackStacksaat Anda beralih antar fragmen Anda seperti di bawah ini:

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

jika Anda menulis addToBackStack(null), ia akan menanganinya sendiri tetapi jika Anda memberi tag, Anda harus menanganinya secara manual.

karena pertanyaan ini dan beberapa jawabannya sudah lebih dari lima tahun, izinkan saya berbagi solusi. Ini adalah tindak lanjut dan modernisasi jawaban dari @oyenigun

UPDATE: Di bagian bawah artikel ini, saya menambahkan implementasi alternatif menggunakan ekstensi Fragmen abstrak yang tidak akan melibatkan Kegiatan sama sekali, yang akan berguna bagi siapa pun dengan hierarki fragmen yang lebih kompleks yang melibatkan fragmen bersarang yang membutuhkan perilaku punggung yang berbeda.

Saya perlu menerapkan ini karena beberapa fragmen yang saya gunakan memiliki tampilan lebih kecil yang ingin saya abaikan dengan tombol kembali, seperti tampilan informasi kecil yang muncul, dll, tetapi ini bagus untuk siapa saja yang perlu menimpa perilaku tombol kembali di dalam fragmen.

Pertama, tentukan Antarmuka

public interface Backable {
    boolean onBackPressed();
}

Antarmuka ini, yang saya sebut Backable(saya stickler untuk konvensi penamaan), memiliki metode tunggal onBackPressed()yang harus mengembalikan booleannilai. Kita perlu menegakkan nilai boolean karena kita perlu tahu apakah tekan tombol kembali telah "menyerap" acara kembali. Kembali trueberarti sudah, dan tidak ada tindakan lebih lanjut diperlukan, jika tidak, falsemengatakan bahwa tindakan kembali standar masih harus dilakukan. Antarmuka ini harus berupa file sendiri (lebih disukai dalam paket terpisah bernama interfaces). Ingat, memisahkan kelas Anda ke dalam paket adalah praktik yang baik.

Kedua, temukan fragmen atas

Saya membuat metode yang mengembalikan Fragmentobjek terakhir di tumpukan belakang. Saya menggunakan tag ... jika Anda menggunakan ID, buat perubahan yang diperlukan. Saya memiliki metode statis ini di kelas utilitas yang berhubungan dengan status navigasi, dll ... tapi tentu saja, letakkan di tempat yang paling cocok untuk Anda. Untuk perbaikan, saya telah memasukkan milik saya di kelas yang disebut 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;
}

Pastikan jumlah tumpukan kembali lebih besar dari 0, jika tidak, ArrayOutOfBoundsExceptiondapat dilempar saat runtime. Jika tidak lebih besar dari 0, kembalikan nol. Kami akan memeriksa nilai nol nanti ...

Ketiga, Implementasikan dalam Fragmen

Menerapkan Backableantarmuka di bagian mana pun di mana Anda perlu mengganti perilaku tombol kembali. Tambahkan metode implementasi.

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

...

    @Override
    public boolean onBackPressed() {

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

}

Dalam onBackPressed()mengganti, masukkan logika apa pun yang Anda butuhkan. Jika Anda ingin tombol kembali tidak memunculkan tumpukan belakang (perilaku default), kembali benar , bahwa acara kembali Anda telah diserap. Jika tidak, kembalikan salah.

Terakhir, di Aktivitas Anda ...

Ganti onBackPressed()metode dan tambahkan logika ini ke dalamnya:

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

Kami mendapatkan fragmen saat ini di tumpukan belakang, kemudian kami melakukan pemeriksaan nol dan menentukan apakah itu mengimplementasikan Backableantarmuka kami . Jika ya, tentukan apakah acara itu diserap. Jika demikian, kita sudah selesai onBackPressed()dan dapat kembali. Kalau tidak, perlakukan itu sebagai tekan kembali normal dan panggil metode super.

Opsi kedua untuk tidak melibatkan Aktivitas

Kadang-kadang, Anda sama sekali tidak ingin Kegiatan menangani ini, dan Anda perlu menanganinya secara langsung di dalam fragmen. Tetapi siapa yang bilang Anda tidak bisa memiliki Fragmen dengan back press API? Cukup rentangkan fragmen Anda ke kelas baru.

Buat kelas abstrak yang memperluas Fragmen dan mengimplementasikan View.OnKeyListnerantarmuka ...

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

Seperti yang Anda lihat, setiap fragmen yang meluas BackableFragmentakan secara otomatis menangkap kembali klik menggunakan View.OnKeyListenerantarmuka. Panggil saja onBackButtonPressed()metode abstrak dari dalam onKey()metode yang diimplementasikan menggunakan logika standar untuk membedakan tekan tombol kembali. Jika Anda perlu mendaftarkan klik kunci selain tombol kembali, pastikan untuk memanggil supermetode ketika menimpa onKey()fragmen Anda, jika tidak Anda akan menimpa perilaku di abstraksi.

Mudah digunakan, cukup rentangkan dan terapkan:

public class FragmentChannels extends BackableFragment {

    ...

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

    ...
}

Karena onBackButtonPressed()metode di kelas super abstrak, setelah Anda memperluas Anda harus menerapkan onBackButtonPressed(). Ini kembali voidkarena hanya perlu melakukan tindakan dalam kelas fragmen, dan tidak perlu menyampaikan penyerapan pers kembali ke Aktivitas. Pastikan Anda memanggil onBackPressed()metode Aktivitas jika apa pun yang Anda lakukan dengan tombol kembali tidak memerlukan penanganan, jika tidak, tombol kembali akan dinonaktifkan ... dan Anda tidak menginginkan itu!

Peringatan Seperti yang Anda lihat, ini mengatur pendengar kunci ke tampilan root dari fragmen, dan kita harus memfokuskannya. Jika ada teks edit yang terlibat (atau tampilan mencuri fokus lainnya) dalam fragmen Anda yang memperluas kelas ini, (atau fragmen dalam lainnya atau tampilan yang memiliki yang sama), Anda harus mengatasinya secara terpisah. Ada artikel bagus tentang cara memperpanjang EditText untuk kehilangan fokus pada tekanan balik.

Saya harap seseorang menemukan ini berguna. Selamat coding.

Solusinya sederhana:

1) Jika Anda memiliki kelas fragmen dasar yang diperluas oleh semua fragmen, kemudian tambahkan kode ini ke kelasnya, jika tidak, buat kelas fragmen basis seperti itu

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

2) Di kelas Aktivitas Anda, ganti onBackPressed sebagai berikut:

private BaseFragment _currentFragment;

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

3) Di kelas Fragmen Anda, tambahkan kode yang Anda inginkan:

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

onBackPressed() menyebabkan Fragmen terlepas dari Aktivitas.

Menurut @Sterling Diaz menjawab, saya pikir dia benar. TAPI beberapa situasi akan salah. (mis. Layar Putar)

Jadi, saya pikir kita bisa mendeteksi apakah isRemoving()akan mencapai tujuan.

Anda dapat menulisnya di onDetach()atau onDestroyView(). Itu bekerja.

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

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

Yah saya melakukannya seperti ini, dan itu bekerja untuk saya

Antarmuka yang sederhana

FragmentOnBackClickInterface.java

public interface FragmentOnBackClickInterface {
    void onClick();
}

Contoh implementasi

MyFragment.java

public class MyFragment extends Fragment implements FragmentOnBackClickInterface {

// other stuff

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

lalu timpa saja diBackPressed dalam aktivitas

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

Anda harus menambahkan antarmuka ke proyek Anda seperti di bawah ini;

public interface OnBackPressed {

     void onBackPressed();
}

Dan kemudian, Anda harus mengimplementasikan antarmuka ini pada fragmen Anda;

public class SampleFragment extends Fragment implements OnBackPressed {

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

}

Dan Anda dapat memicu acara onBackPressed ini di bawah aktivitas Anda di acaraBackPressed seperti di bawah ini;

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

Ini hanya kode kecil yang akan melakukan trik:

 getActivity().onBackPressed();

Semoga ini bisa membantu seseorang :)

Jika Anda menggunakan EventBus, itu mungkin solusi yang jauh lebih sederhana:

Dalam Fragmen Anda:

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

dan di kelas Aktivitas Anda, Anda dapat mendefinisikan:

@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 hanyalah objek POJO

Ini sangat bersih dan tidak ada kerumitan antarmuka / implementasi.

ini solusi saya:

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

dan dalam Fragmen:

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

        // some codes

        return true;
    }
});

Menggunakan komponen Navigasi, Anda dapat melakukannya seperti ini :

Jawa

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

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

dalam fragmen Anda tambahkan berikut ini, jangan lupa untuk mengimplementasikan antarmuka mainaktivitas.

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

}

Dalam solusi saya (Kotlin);

Saya menggunakan fungsi onBackAlternative sebagai parameter pada BaseActivity .

BaseActivity

abstract class BaseActivity {

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

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

Saya memiliki fungsi untuk mengatur onBackPressAlternative di 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
     }
}

Kemudian onBackPressAlternative saya siap digunakan pada fragmen.

Sub Fragmen

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

Jangan menerapkan metode ft.addToBackStack () sehingga ketika Anda menekan tombol kembali aktivitas Anda akan selesai.

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

Ikuti saja langkah-langkah ini:

Selalu sambil menambahkan fragmen,

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

Kemudian di aktivitas utama, timpa onBackPressed()

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

Untuk menangani tombol kembali di aplikasi Anda,

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

Itu dia!

Dalam siklus hidup aktivitas, selalu tombol android kembali berurusan dengan transaksi FragmentManager ketika kami menggunakan FragmentActivity atau AppCompatActivity.

Untuk menangani backstack, kita tidak perlu menangani count backstack atau menandai apa pun, tetapi kita harus tetap fokus sambil menambahkan atau mengganti sebuah fragmen. Silakan temukan cuplikan berikut untuk menangani case tombol kembali,

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

Di sini, saya tidak akan menambahkan tumpukan kembali untuk fragmen rumah saya karena itu adalah halaman rumah aplikasi saya. Jika menambahkan addToBackStack ke HomeFragment maka aplikasi akan menunggu untuk menghapus semua framen dalam kegiatan maka kita akan mendapatkan layar kosong jadi saya menjaga kondisi berikut,

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

Sekarang, Anda dapat melihat fragmen yang ditambahkan sebelumnya pada aktivitas dan aplikasi akan keluar ketika mencapai HomeFragment. Anda juga dapat melihat cuplikan berikut.

@Override
public void onBackPressed() {

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

Fragmen: Buat metode BaseFragment menempatkan:

 public boolean onBackPressed();

Aktivitas:

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

Aktivitas Anda akan berjalan di atas fragmen yang terlampir dan terlihat dan memanggilBackPressed () pada masing-masing dari mereka dan membatalkan jika salah satu dari mereka mengembalikan 'benar' (artinya telah ditangani, jadi tidak ada tindakan lebih lanjut).

Menurut catatan rilis AndroidX , androidx.activity 1.0.0-alpha01dirilis dan memperkenalkan ComponentActivity, kelas dasar baru yang ada FragmentActivitydan AppCompatActivity. Dan rilis ini memberi kita fitur baru:

Anda sekarang dapat mendaftarkan OnBackPressedCallbackvia addOnBackPressedCallbackuntuk menerima onBackPressed()panggilan balik tanpa perlu mengganti metode dalam aktivitas Anda.

Anda dapat mendaftarkan fragmen dalam aktivitas untuk menangani kembali pers:

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

interface BackPressHandler {
    fun onBackPressed(): Boolean
}

pemakaian:

Dalam Fragmen:

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

Dalam Aktivitas:

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

Menyediakan navigasi belakang khusus dengan menangani diBackPressed sekarang lebih mudah dengan panggilan balik di dalam fragmen.

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

Jika Anda ingin tindakan kembali default berdasarkan beberapa kondisi, Anda dapat menggunakan:

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

Di dalam metode onCreate fragmen tambahkan yang berikut:

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

Solusi terbaik,

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

            }
        }
    }
}