Disable back button in android

Question

How to disable back button in android while logging out the application?

Secundines

Can you be little more clear on the question? If you are looking for overwriting the back button default behavior then refer this question here. #2000602 – Searchlight

Please don't do this unless you have a good reason, as breaking the expected model of operation very slightly hurts the entire platform – Empanel

You would want to do it if you have to deal with a stupid Samsung S4 where the back button is touch sensitive (not physical), right on the edge of the phone, which is already so touch sensitive that a palm resting against the side will go back. – Farming

It is against Android Quality and Design guide, role UX-N1. – Cultigen

Answer 1

Override the onBackPressed method and do nothing if you meant to handle the back button on the device.

@Override
public void onBackPressed() {
   if (shouldAllowBack()) {
       super.onBackPressed();
   } else {
       doSomething();
   }
}

Searchlight

This is much better and cleaner than overriding the key handling methods, and has the same effect. Great answer! – Adulthood

Great solution dude. Is there any way to do like this with home button? – Akim

This is great! I actually wanted to always return to my main activity when pressing back from any other activity, and overriding this method lets me do that very easily. – Katlaps

Oops I forget to remove super.onBackPressed(). – Androsterone

Answer 2

If looking for a higher api level 2.0 and above this will work great

@Override
public void onBackPressed() {
    // Do Here what ever you want do on back press;
}

If looking for android api level upto 1.6.

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
     if (keyCode == KeyEvent.KEYCODE_BACK) {
     //preventing default implementation previous to android.os.Build.VERSION_CODES.ECLAIR
     return true;
     }
     return super.onKeyDown(keyCode, event);    
}

Write above code in your Activity to prevent back button pressed

Byrom

This method is more backwards compatible than using onbackpressed due to onbackpressed's api level requirement – Reilly

Great answer. Although I don't need it for my project, I appreciate that you provided both the old and new methods. This should be marked as correct answer. +1 – Katlaps

@Javanator the second one wouldn't work for me (for API level 16 for example), but the first one works like a charm – Dougall

Answer 3

You can do this simple way Don't call super.onBackPressed()

Note:- Don't do this unless and until you have strong reason to do it.

@Override
public void onBackPressed() {
// super.onBackPressed();
// Not calling **super**, disables back button in current screen.
}

Commonplace

An explanation as to "why not" would be great. Thanks. – Hebdomadal

Not calling .super is important! – Photomechanical

@almostabeginner because not calling super will invalidate the normal use of back button. users will freak out when a normally-working button stops working. they may think the app is buggy or the phone is malfunctioning etc. your app will be the culprit in the end. – Chronometer

Answer 4

Simply override the onBackPressed() method.

@Override
public void onBackPressed() { }

Lepidus

Answer 5

I am using it.............

 @Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if(keyCode==KeyEvent.KEYCODE_BACK)
        Toast.makeText(getApplicationContext(), "back press",      
     Toast.LENGTH_LONG).show();

    return false;
       // Disable back button..............
}

Rutan

Answer 6

Just override the onBackPressed() method and no need to call the super class of onBackPressed method or others..

@Override
public void onBackPressed()
{
   
}

Or pass your current activity into the onBackPressed() method.

@Override
public void onBackPressed()
{
   startActivity(new Intent(this, myActivity.class));  
   finish();
}

Replace your require activity name to myActivity.

if you are using fragment then first of all call the callParentMethod() method

public void callParentMethod(){
    context.onBackPressed(); // instead of context use getActivity or something related
}

Then call the empty method

@Override
public void onBackPressed()
{

}

Updated implementation for activity:

onBackPressedDispatcher.addCallback(this) {
    // Handle the back button event
}

Updated implementation for fragment:

requireActivity().onBackPressedDispatcher.addCallback(this) {
       // Handle the back button event
}

Blanka

Answer 7

If you want to make sure your android client application is logged out from some server before your Activity gets killed --> log out with a service on its own thread (that's what you're supposed to do anyway).

Disabling the back button won't solve anything for you. You'll still have the same problem when the user receives a phone call for instance. When a phone call is received, your activity has about as much chances of getting killed before it gets a reliable answer back from the network.

That's why you should let a service wait on its own thread for the answer from the network, and then make it try again if it doesn't succeed. The android service is not only much less likely to get killed before it gets an answer back, but should it really get killed before finishing the job, it can always get revived by AlarmManager to try again.

Jussive

Answer 8

Disable back buttton in android

@Override
public void onBackPressed() {
    return;
}

Triolein

Answer 9

You can override the onBackPressed() method in your activity and remove the call to super class.

@Override
public void onBackPressed() {
  //remove call to the super class
  //super.onBackPressed();
}

Alluvium

Answer 10

if you are using FragmentActivity. then do like this

first call This inside your Fragment.

public void callParentMethod(){
    getActivity().onBackPressed();
}

and then Call onBackPressed method in side your parent FragmentActivity class.

@Override
public void onBackPressed() {
  //super.onBackPressed();
  //create a dialog to ask yes no question whether or not the user wants to exit
  ...
}

Revolutionary

Answer 11

Just using this code: If you want backpressed disable, you dont use super.OnBackPressed();

@Override
public void onBackPressed() {

}

Criswell

Answer 12

If you want to disable your app while logging out, you can pop up a non-cancellable dialog.

Galleon

Answer 13

Apart form these two methods from answer above.

onBackPressed() (API Level 5, Android 2.0)

onKeyDown() (API Level 1, Android 1.0)

You can also override the dispatchKeyEvent()(API Level 1, Android 1.0) like this,

dispatchKeyEvent() (API Level 1, Android 1.0)

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    // TODO Auto-generated method stub
    if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
        return true;
    }
    return super.dispatchKeyEvent(event);
}

Sherburn

Answer 14

As Android have added gesture feature of swipe for back from Android 13

Android 13 and above

From Android 13 and above onBackPress is deprecated. So for above Android 13 you need to use onBackPressedDispatcher. First you need to add callBack in onCreate of Activity preferred add just after setContentView or binding view

JAVA

getOnBackPressedDispatcher().addCallback(this, new OnBackPressedCallback(true) { // true: for prevent back and do something in handleOnBackPressed
        @Override
        public void handleOnBackPressed() {
            // Do Something
        }
    });

Kotlin

onBackPressedDispatcher.addCallback(object: OnBackPressedCallback(true) {// true: for prevent back and do something in handleOnBackPressed
            override fun handleOnBackPressed() {
                // Do Something
            }
        })

Below Android 13

Java

@Override
public void onBackPressed() {
   if (shouldAllowBack()) { // true for allow back
       super.onBackPressed();
   } else {
       //do Something
   }
}

Kotlin

override fun onBackPressed() {
    if (shouldAllowBack()) { // true for allow back
        super.onBackPressed()
    } else {
        //do Something
    }
}

Sheldon

inside the handleOnBackPressed() how do I call the default behaviour to happen after I'm done with my logic? – Nestorius

You can use onBackPressedDispatcher.onBackPressed() whenever you want back pressed. – Sheldon

Answer 15

You just need to override the method for back button. You can leave the method empty if you want so that nothing will happen when you press back button. Please have a look at the code below:

@Override
public void onBackPressed() 
{
   // Your Code Here. Leave empty if you want nothing to happen on back press.
}

Yongyoni

Answer 16

remove super.onBackPressed() from public void onBackPressed() work great. its tested in android 9

Irs

Answer 17

For me just overriding onBackPressed() did not work but explicit pointing which activity it should start worked well:

@Override
public void onBackPressed(){
  Intent intent = new Intent(this, ActivityYouWanToGoBack.class);
  startActivity(intent);
}

Son

Answer 18

Try this:

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
 if (keyCode == KeyEvent.KEYCODE_BACK) {

   return true;
 }
   return super.onKeyDown(keyCode, event);    
}

Hydria

Answer 19

Android 13 Kotlin

onBackPressedDispatcher.addCallback(object: OnBackPressedCallback(true) {
            /* override back pressing */
            override fun handleOnBackPressed() {
                //Your code here
            }
        })

Agone

Answer 20

With jetpack compose we can use:

setContent {
   BackHandler {}
...
}

Nutlet