Existe uma maneira de implementarmos onBackPressed() no Android Fragment semelhante à maneira como implementamos na Atividade Android?

Como o ciclo de vida do fragmento não possui onBackPressed(). Existe algum outro método alternativo para substituir os onBackPressed()fragmentos do Android 3.0?

Eu resolvi dessa maneira substituir onBackPressedna Atividade. Todos os FragmentTransactionsão addToBackStackantes de confirmar:

@Override
public void onBackPressed() {

    int count = getSupportFragmentManager().getBackStackEntryCount();

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

}

Na minha opinião, a melhor solução é:

SOLUÇÃO JAVA

Crie uma interface simples:

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

E na sua atividade

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

Finalmente em seu fragmento:

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

SOLUÇÃO KOTLIN

1 - Criar interface

interface IOnBackPressed {
    fun onBackPressed(): Boolean
}

2 - Prepare sua atividade

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

3 - Implemente no seu fragmento alvo

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

De acordo com a resposta @HaMMeRed, aqui está o pseudocódigo como deve funcionar. Digamos que sua atividade principal seja chamada BaseActivitycom fragmentos filhos (como no exemplo da SlidingMenu lib). Aqui estão os passos:

Primeiro precisamos criar interface e classe que implementa sua interface para ter um método genérico

1. Criar interface de classe OnBackPressedListener

   public interface OnBackPressedListener {
       public void doBack();
   }

2. Crie uma classe que implemente habilidades de OnBackPressedListener

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

3. Desde agora, trabalharemos em nosso código BaseActivitye seus fragmentos

4. Crie um ouvinte privado no topo da sua turma BaseActivity

   protected OnBackPressedListener onBackPressedListener;

5. criar método para definir o ouvinte BaseActivity

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

6. em substituir onBackPressedimplementar algo parecido

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

7. no seu fragmento onCreateViewvocê deve adicionar o nosso ouvinte

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

Agora, quando você clica novamente em fragmento, deve capturar seu método personalizado de volta.

Isso funcionou para mim: 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;
        }
    });
}

Se você quisesse esse tipo de funcionalidade, seria necessário substituí-lo em sua atividade e, em seguida, adicione uma YourBackPressedinterface a todos os seus fragmentos, que você chama no fragmento relevante sempre que o botão Voltar é pressionado.

Editar: gostaria de anexar minha resposta anterior.

Se eu fizesse isso hoje, usaria uma transmissão, ou possivelmente uma transmissão ordenada, se esperasse que outros painéis fossem atualizados em uníssono para o painel de conteúdo principal / principal.

LocalBroadcastManagerna Biblioteca de suporte pode ajudar com isso, e você apenas envia a transmissão onBackPressede assina seus fragmentos que se importam. Penso que o Messaging é uma implementação mais dissociada e seria melhor dimensionada, por isso seria minha recomendação oficial de implementação agora. Basta usar a Intentação do como um filtro para sua mensagem. envie o seu recém-criado ACTION_BACK_PRESSED, envie-o da sua atividade e ouça nos fragmentos relevantes.

Nada disso é fácil de implementar, nem funcionará da maneira ideal.

Os fragmentos têm uma chamada de método onDetach que fará o trabalho.

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

ISSO FAZ O TRABALHO.

Se você estiver usando androidx.appcompat:appcompat:1.1.0ou acima, poderá adicionar um OnBackPressedCallbackao seu fragmento da seguinte maneira

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

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

Basta adicionar addToBackStackenquanto você está fazendo a transição entre seus fragmentos, como abaixo:

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

se você escrever addToBackStack(null), ele cuidará sozinho, mas se você der uma tag, deverá manipulá-la manualmente.

Como esta pergunta e algumas das respostas têm mais de cinco anos, deixe-me compartilhar minha solução. Este é um acompanhamento e modernização da resposta de @oyenigun

ATUALIZAÇÃO: No final deste artigo, adicionei uma implementação alternativa usando uma extensão abstrata de fragmento que não envolverá a atividade, o que seria útil para qualquer pessoa com uma hierarquia de fragmentos mais complexa que envolva fragmentos aninhados que exigem comportamento reverso diferente.

Eu precisava implementar isso porque alguns dos fragmentos que utilizo têm visões menores que eu gostaria de descartar com o botão voltar, como pequenas visões de informações que aparecem, etc., mas isso é bom para quem precisa substituir o comportamento de o botão voltar dentro dos fragmentos.

Primeiro, defina uma interface

public interface Backable {
    boolean onBackPressed();
}

Essa interface, que eu chamo Backable(sou defensora das convenções de nomenclatura), tem um método único onBackPressed()que deve retornar um booleanvalor. Precisamos impor um valor booleano, pois precisamos saber se o pressionamento do botão voltar "absorveu" o evento back. Retornar truesignifica que sim, e nenhuma ação adicional é necessária; caso contrário, falsediz que a ação de retorno padrão ainda deve ocorrer. Essa interface deve ser seu próprio arquivo (de preferência em um pacote separado chamado interfaces). Lembre-se, separar suas classes em pacotes é uma boa prática.

Segundo, encontre o fragmento superior

Eu criei um método que retorna o último Fragmentobjeto na pilha de volta. Eu uso tags ... se você usa IDs, faça as alterações necessárias. Eu tenho esse método estático em uma classe de utilitário que lida com estados de navegação, etc ... mas é claro, coloque-o onde melhor lhe convier. Para edificação, coloquei o meu em uma classe chamada 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;
}

Verifique se a contagem da pilha traseira é maior que 0, caso contrário, ArrayOutOfBoundsExceptionpoderá ser lançada em tempo de execução. Se não for maior que 0, retorne nulo. Mais tarde, verificaremos um valor nulo ...

Terceiro, implemente em um fragmento

Implemente a Backableinterface em qualquer fragmento em que você precise substituir o comportamento do botão Voltar. Adicione o método de implementação.

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

...

    @Override
    public boolean onBackPressed() {

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

}

Na onBackPressed()substituição, coloque qualquer lógica que você precisar. Se você deseja que o botão voltar não apareça a pilha de retorno (o comportamento padrão), retorne verdadeiro , pois seu evento de retorno foi absorvido. Caso contrário, retorne false.

Por fim, em sua atividade ...

Substitua o onBackPressed()método e adicione esta lógica a ele:

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

Colocamos o fragmento atual na pilha de trás, fazemos uma verificação nula e determinamos se ele implementa nossa Backableinterface. Se isso acontecer, determine se o evento foi absorvido. Nesse caso, terminamos onBackPressed()e podemos retornar. Caso contrário, trate-o como uma pressão normal de retorno e chame o super método.

Segunda opção para não envolver a atividade

Às vezes, você não quer que a Atividade lide com isso e precisa lidar diretamente com ela dentro do fragmento. Mas quem disse que você não pode ter fragmentos com uma API de contrapressão? Apenas estenda seu fragmento para uma nova classe.

Crie uma classe abstrata que estenda o fragmento e implemente a View.OnKeyListnerinterface ...

import android.app.Fragment;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.View;

public abstract class BackableFragment extends Fragment implements View.OnKeyListener {

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        view.setFocusableInTouchMode(true);
        view.requestFocus();
        view.setOnKeyListener(this);
    }

    @Override
    public boolean onKey(View v, int keyCode, KeyEvent event) {
        if (event.getAction() == KeyEvent.ACTION_UP) {
            if (keyCode == KeyEvent.KEYCODE_BACK) {
                onBackButtonPressed();
                return true;
            }
        }

        return false;
    }

    public abstract void onBackButtonPressed();
}

Como você pode ver, qualquer fragmento que se estenda BackableFragmentcaptura automaticamente os cliques anteriores usando a View.OnKeyListenerinterface. Basta chamar o onBackButtonPressed()método abstrato de dentro do onKey()método implementado usando a lógica padrão para discernir um pressionamento do botão Voltar. Se você precisar registrar cliques de teclas que não sejam o botão Voltar, chame o supermétodo ao substituir onKey()seu fragmento, caso contrário, você substituirá o comportamento na abstração.

Simples de usar, basta estender e implementar:

public class FragmentChannels extends BackableFragment {

    ...

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

    ...
}

Como o onBackButtonPressed()método na superclasse é abstrato, depois de estendido, você deve implementar onBackButtonPressed(). Ele retorna voidporque só precisa executar uma ação dentro da classe de fragmento e não precisa retransmitir a absorção da impressora de volta para a Atividade. Certifique-se de chamar o onBackPressed()método Activity se o que você estiver fazendo com o botão voltar não exigir manipulação, caso contrário, o botão voltar será desativado ... e você não quer isso!

Advertências Como você pode ver, isso define o ouvinte principal para a visualização raiz do fragmento, e precisaremos focalizá-lo. Se houver textos de edição envolvidos (ou qualquer outra exibição de roubo de foco) em seu fragmento que estenda essa classe (ou outros fragmentos ou exibições internas que tenham a mesma), será necessário lidar com isso separadamente. Há um bom artigo sobre a extensão de um EditText para perder o foco em uma contrapressão.

Espero que alguém ache isso útil. Feliz codificação.

A solução é simples:

1) Se você tem uma classe de fragmento base que todos os fragmentos estendem, adicione esse código à sua classe, caso contrário, crie uma classe de fragmento base

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

2) Na sua classe Activity, substitua onBackPressed da seguinte maneira:

private BaseFragment _currentFragment;

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

3) Na sua classe Fragment, adicione o código desejado:

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

onBackPressed() faça com que o fragmento seja desconectado da atividade.

De acordo com a resposta de @Sterling Diaz, acho que ele está certo. MAS alguma situação estará errada. (por exemplo, Rodar ecrã)

Então, acho que poderíamos detectar se devemos isRemoving()alcançar objetivos.

Você pode escrever em onDetach()ou onDestroyView(). É trabalho.

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

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

Bem, eu fiz assim, e funcionou para mim

Interface simples

FragmentOnBackClickInterface.java

public interface FragmentOnBackClickInterface {
    void onClick();
}

Implementação de exemplo

MyFragment.java

public class MyFragment extends Fragment implements FragmentOnBackClickInterface {

// other stuff

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

substitua onBackPressed na atividade

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

Você deve adicionar interface ao seu projeto como abaixo;

public interface OnBackPressed {

     void onBackPressed();
}

E então, você deve implementar essa interface no seu fragmento;

public class SampleFragment extends Fragment implements OnBackPressed {

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

}

E você pode acionar esse evento onBackPressed em suas atividades, como abaixo;

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

Este é apenas um pequeno código que fará o truque:

 getActivity().onBackPressed();

Espero que ajude alguém :)

Se você usa o EventBus, provavelmente é uma solução muito mais simples:

No seu fragmento:

@Override
public void onAttach(Activity activity) {
    super.onAttach(activity);
    EventBus.getDefault().register(this);
}

@Override
public void onDetach() {
    super.onDetach();
    EventBus.getDefault().unregister(this);
}


// This method will be called when a MessageEvent is posted
public void onEvent(BackPressedMessage type){
    getSupportFragmentManager().popBackStack();
}

e na sua classe Activity você pode definir:

@Override
public void onStart() {
    super.onStart();
    EventBus.getDefault().register(this);
}

@Override
public void onStop() {
    EventBus.getDefault().unregister(this);
    super.onStop();
}

// This method will be called when a MessageEvent is posted
public void onEvent(BackPressedMessage type){
    super.onBackPressed();
}

@Override
public void onBackPressed() {
    EventBus.getDefault().post(new BackPressedMessage(true));
}

BackPressedMessage.java é apenas um objeto POJO

Isso é super limpo e não há problemas de interface / implementação.

esta é a minha solução:

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

e em fragmento:

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

        // some codes

        return true;
    }
});

Usando o componente Navigation, você pode fazer o seguinte :

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

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

no seu fragmento adicione o seguinte, não esqueça de implementar a interface da atividade principal.

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

}

Na minha solução (Kotlin);

Estou usando a função onBackAlternative como um parâmetro em BaseActivity .

BaseActivity

abstract class BaseActivity {

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

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

Eu tenho uma função para definir onBackPressAlternative em 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
     }
}

Então meu onBackPressAlternative está pronto para uso em fragmentos.

Fragmentos secundários

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

Não implemente o método ft.addToBackStack () para que, ao pressionar o botão Voltar, sua atividade seja concluída.

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

Basta seguir estes passos:

Sempre ao adicionar um fragmento,

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

Em seguida, na atividade principal, substitua onBackPressed()

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

Para manipular o botão Voltar no seu aplicativo,

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

É isso aí!

No ciclo de vida da atividade, sempre o botão voltar do Android lida com transações do FragmentManager quando usamos FragmentActivity ou AppCompatActivity.

Para lidar com o backstack, não precisamos manipular sua contagem de backstack ou marcar nada, mas devemos manter o foco ao adicionar ou substituir um fragmento. Encontre os seguintes snippets para lidar com as caixas dos botões voltar,

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

Aqui, não adicionarei pilha traseira ao meu fragmento de página inicial porque é a página inicial do meu aplicativo. Se adicionar addToBackStack ao HomeFragment, o aplicativo aguardará a remoção de todo o problema de atividade, e a tela ficará em branco, mantendo a seguinte condição,

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

Agora, você pode ver o fragmento adicionado anteriormente na acitvity e o aplicativo será fechado ao acessar o HomeFragment. você também pode procurar nos seguintes trechos.

@Override
public void onBackPressed() {

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

Fragmento: Faça um BaseFragment colocando um método:

 public boolean onBackPressed();

Atividade:

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

Sua atividade será executada nos fragmentos anexados e visíveis e chamará BackBackPressed () em cada um deles e abortará se um deles retornar 'verdadeiro' (o que significa que foi tratado, portanto, não há mais ações).

De acordo com as notas de versão do AndroidX , androidx.activity 1.0.0-alpha01é lançado e apresenta ComponentActivityuma nova classe base dos arquivos existentes FragmentActivitye AppCompatActivity. E esta versão nos traz um novo recurso:

Agora você pode registrar uma OnBackPressedCallbackvia addOnBackPressedCallbackpara receber onBackPressed()retornos de chamada sem precisar substituir o método em sua atividade.

Você pode registrar um fragmento em atividade para lidar com a contrapressão:

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

interface BackPressHandler {
    fun onBackPressed(): Boolean
}

uso:

No fragmento:

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

Em Atividade:

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

Fornecer navegação de retorno personalizada manipulando onBackPressed agora é mais fácil com retornos de chamada dentro do fragmento.

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

Se você deseja a ação de retorno padrão com base em alguma condição, pode usar:

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

Dentro do método onCreate do fragmento, adicione o seguinte:

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

Melhor solução,

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

            }
        }
    }
}