Dwukrotne kliknięcie przycisku Wstecz, aby zakończyć działanie

Ostatnio zauważyłem ten wzór w wielu aplikacjach i grach na Androida: po kliknięciu przycisku Wstecz, aby „wyjść” z aplikacji, Toastpojawia się komunikat podobny do tego: „Kliknij ponownie BACK, aby wyjść”.

Zastanawiam się, ponieważ coraz częściej to widzę, czy jest to wbudowana funkcja, do której można uzyskać dostęp w ramach działania? Patrzyłem na kod źródłowy wielu klas, ale nie mogę nic na ten temat znaleźć.

Oczywiście mogę dość łatwo wymyślić kilka sposobów na uzyskanie tej samej funkcjonalności (najłatwiej jest zachować wartość logiczną w działaniu, która wskazuje, czy użytkownik kliknął już raz ...), ale zastanawiałem się, czy coś już tu jest .

EDYCJA : Jak wspomniałem @LAS_VEGAS, tak naprawdę nie miałem na myśli „wyjścia” w tradycyjnym znaczeniu. (tj. zakończone) Miałem na myśli „powrót do tego, co było otwarte przed uruchomieniem działania aplikacji”, jeśli ma to sens :)

W aktywności Java:

boolean doubleBackToExitPressedOnce = false;

@Override
public void onBackPressed() {
    if (doubleBackToExitPressedOnce) {
        super.onBackPressed();
        return;
    }

    this.doubleBackToExitPressedOnce = true;
    Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT).show();

    new Handler().postDelayed(new Runnable() {

        @Override
        public void run() {
            doubleBackToExitPressedOnce=false;                       
        }
    }, 2000);
} 

W działalności Kotlin:

private var doubleBackToExitPressedOnce = false
override fun onBackPressed() {
        if (doubleBackToExitPressedOnce) {
            super.onBackPressed()
            return
        }

        this.doubleBackToExitPressedOnce = true
        Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT).show()

        Handler().postDelayed(Runnable { doubleBackToExitPressedOnce = false }, 2000)
    }

Myślę, że ten moduł obsługi pomaga zresetować zmienną po 2 sekundach.

Sudheesh B Nair ma miłą (i zaakceptowaną) odpowiedź na pytanie, które moim zdaniem powinno mieć lepszą alternatywę, taką jak;

Co jest złego w mierzeniu czasu i sprawdzaniu, czy minęły TIME_INTERVALmilisekundy (powiedzmy 2000) od ostatniego naciśnięcia wstecz. Wywoływany jest następujący przykładowy kod System.currentTimeMillis();do przechowywania czasu onBackPressed();

private static final int TIME_INTERVAL = 2000; // # milliseconds, desired time passed between two back presses.
private long mBackPressed;

@Override
public void onBackPressed()
{
    if (mBackPressed + TIME_INTERVAL > System.currentTimeMillis()) 
    { 
        super.onBackPressed(); 
        return;
    }
    else { Toast.makeText(getBaseContext(), "Tap back button in order to exit", Toast.LENGTH_SHORT).show(); }

    mBackPressed = System.currentTimeMillis();
}

Powrót do przyjętej krytyki odpowiedzi ; Używanie flagdo wskazania, czy został wciśnięty w ostatnim TIME_INTERVAL(powiedzmy 2000) milisekund i set - Reset jest poprzez Handler„s postDelayed()metoda była pierwszą rzeczą, aby przyjść w moim umyśle. Ale postDelayed()akcja powinna zostać anulowana, gdy aktywność się zamyka, usuwając Runnable.

Aby go usunąć Runnable, nie można go ogłosić anonimowym i należy go również zgłosić jako członka wraz z Handlerzapisem. Następnie można odpowiednio wywołać removeCallbacks()metodęHandler

Poniższa próbka to demonstracja;

private boolean doubleBackToExitPressedOnce;
private Handler mHandler = new Handler();

private final Runnable mRunnable = new Runnable() {
    @Override
    public void run() {
        doubleBackToExitPressedOnce = false;                       
    }
};

@Override 
protected void onDestroy() 
{ 
    super.onDestroy();

    if (mHandler != null) { mHandler.removeCallbacks(mRunnable); }
}

@Override
public void onBackPressed() {
    if (doubleBackToExitPressedOnce) {
        super.onBackPressed();
        return;
    }

    this.doubleBackToExitPressedOnce = true;
    Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT).show();

    mHandler.postDelayed(mRunnable, 2000);
}

Dzięki @NSouth za wkład; Aby zapobiec pojawianiu się wiadomości toast nawet po zamknięciu aplikacji, Toastmożna ją zadeklarować jako członka - powiedzmy mExitToast- i można ją anulować mExitToast.cancel();bezpośrednio przed super.onBackPressed();połączeniem.

Pomyślałem, że w końcu podzielę się tym, jak to zrobiłem, dodałem w swojej działalności:

private boolean doubleBackToExitPressedOnce = false;

@Override
protected void onResume() {
    super.onResume();
    // .... other stuff in my onResume ....
    this.doubleBackToExitPressedOnce = false;
}

@Override
public void onBackPressed() {
    if (doubleBackToExitPressedOnce) {
        super.onBackPressed();
        return;
    }
    this.doubleBackToExitPressedOnce = true;
    Toast.makeText(this, R.string.exit_press_back_twice_message, Toast.LENGTH_SHORT).show();
}

I to działa dokładnie tak, jak chcę. Łącznie z resetowaniem stanu przy każdym wznowieniu działania.

Schemat przebiegu procesu:

Kod Java:

private long lastPressedTime;
private static final int PERIOD = 2000;

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
        switch (event.getAction()) {
        case KeyEvent.ACTION_DOWN:
            if (event.getDownTime() - lastPressedTime < PERIOD) {
                finish();
            } else {
                Toast.makeText(getApplicationContext(), "Press again to exit.",
                        Toast.LENGTH_SHORT).show();
                lastPressedTime = event.getEventTime();
            }
            return true;
        }
    }
    return false;
}

Wśród tych wszystkich odpowiedzi jest bardzo najprostszy sposób.

Po prostu napisz następujący kod w onBackPressed()metodzie.

long back_pressed;

@Override
public void onBackPressed() {
    if (back_pressed + 1000 > System.currentTimeMillis()){
        super.onBackPressed();
    }
    else{
        Toast.makeText(getBaseContext(),
                "Press once again to exit!", Toast.LENGTH_SHORT)
                .show();
    }
    back_pressed = System.currentTimeMillis();
}

Musisz zdefiniować back_pressedobiekt jak longw działaniu.

Moje rozwiązanie z użyciem paska przekąskowego:

Snackbar mSnackbar;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    final LinearLayout layout = findViewById(R.id.layout_main);
    mSnackbar = Snackbar.make(layout, R.string.press_back_again, Snackbar.LENGTH_SHORT);
}

@Override
public void onBackPressed() {
    if (mSnackbar.isShown()) {
        super.onBackPressed();
    } else {
        mSnackbar.show();
    }
}

Prosty i stylowy.

W oparciu o poprawną odpowiedź i sugestie w komentarzach, stworzyłem demo, które działa absolutnie dobrze i usuwa wywołania programu obsługi po użyciu.

MainActivity.java

package com.mehuljoisar.d_pressbacktwicetoexit;

import android.os.Bundle;
import android.os.Handler;
import android.app.Activity;
import android.widget.Toast;

public class MainActivity extends Activity {

    private static final long delay = 2000L;
    private boolean mRecentlyBackPressed = false;
    private Handler mExitHandler = new Handler();
    private Runnable mExitRunnable = new Runnable() {

        @Override
        public void run() {
            mRecentlyBackPressed=false;   
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    @Override
    public void onBackPressed() {

        //You may also add condition if (doubleBackToExitPressedOnce || fragmentManager.getBackStackEntryCount() != 0) // in case of Fragment-based add
        if (mRecentlyBackPressed) {
            mExitHandler.removeCallbacks(mExitRunnable);
            mExitHandler = null;
            super.onBackPressed();
        }
        else
        {
            mRecentlyBackPressed = true;
            Toast.makeText(this, "press again to exit", Toast.LENGTH_SHORT).show();
            mExitHandler.postDelayed(mExitRunnable, delay);
        }
    }

}

Mam nadzieję, że będzie to pomocne !!

 public void onBackPressed() {
    if (doubleBackToExitPressedOnce) {
        super.onBackPressed();
        return;
    }

    this.doubleBackToExitPressedOnce = true;
    Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT).show();

    new Handler().postDelayed(new Runnable() {

        @Override
        public void run() {
            doubleBackToExitPressedOnce=false;
        }
    }, 2000);

Deklaruj zmiennąprivate boolean doubleBackToExitPressedOnce = false;

Wklej to w swojej głównej działalności, a to rozwiąże problem

Nie jest dobrym pomysłem używanie Runnable po wyjściu z aplikacji, ostatnio wymyśliłem znacznie prostszy sposób rejestrowania i porównywania okresu między dwoma kliknięciami przycisku BACK. Przykładowy kod w następujący sposób:

private static long back_pressed_time;
private static long PERIOD = 2000;

@Override
public void onBackPressed()
{
        if (back_pressed_time + PERIOD > System.currentTimeMillis()) super.onBackPressed();
        else Toast.makeText(getBaseContext(), "Press once again to exit!", Toast.LENGTH_SHORT).show();
        back_pressed_time = System.currentTimeMillis();
}

To sprawi, że wyjdziesz z aplikacji podwójnym kliknięciem przycisku BACK w pewnym okresie opóźnienia, który wynosi 2000 milisekund w próbce.

Zaakceptowana odpowiedź jest najlepsza, ale jeśli używasz Android Design Support Library, możesz użyć SnackBardla lepszych widoków.

   boolean doubleBackToExitPressedOnce = false;

    @Override
    public void onBackPressed() {
        if (doubleBackToExitPressedOnce) {
            super.onBackPressed();
            return;
        }

        this.doubleBackToExitPressedOnce = true;

        Snackbar.make(findViewById(R.id.photo_album_parent_view), "Please click BACK again to exit", Snackbar.LENGTH_SHORT).show();

        new Handler().postDelayed(new Runnable() {

            @Override
            public void run() {
                doubleBackToExitPressedOnce=false;
            }
        }, 2000);
    }

To nie jest wbudowana funkcjonalność. Myślę, że to nawet nie jest zalecane zachowanie. Aplikacje na Androida nie są przeznaczone do wyjścia:

Dlaczego aplikacje na Androida nie oferują opcji „Wyjdź”?

1. Zadeklaruj globalną zmienną Toast dla klasy MainActivity. przykład: Toast exitToast;
2. Zainicjuj go w metodzie widoku onCreate. przykład: exitToast = Toast.makeText (getApplicationContext (), „Naciśnij ponownie, aby wyjść”, Toast.LENGTH_SHORT);

3. Na koniec utwórz onBackPressedMethod w następujący sposób:

   @Override
   public void onBackPressed() {
   
       if (exitToast.getView().isShown()) {
           exitToast.cancel();
           finish();
       } else {
           exitToast.show();
       }
   }

Działa to poprawnie, przetestowałem. i myślę, że jest to o wiele prostsze.

Odpowiedź Zefnusa przy użyciu System.currentTimeMillis () jest najlepsza (+1). Sposób, w jaki to zrobił to nie lepsze niż to, ale nadal opublikowania go dodać do powyższych pomysłów.

Jeśli toast nie jest widoczny po naciśnięciu przycisku Wstecz, toast jest wyświetlany, a jeśli jest widoczny (tył został już naciśnięty jeden raz w ostatnim Toast.LENGTH_SHORTczasie), to wychodzi.

exitToast = Toast.makeText(this, "Press again to exit", Toast.LENGTH_SHORT);
.
.
@Override
public void onBackPressed() {
   if (exitToast.getView().getWindowToken() == null) //if toast is currently not visible
      exitToast.show();  //then show toast saying 'press againt to exit'
   else {                                            //if toast is visible then
      finish();                                      //or super.onBackPressed();
      exitToast.cancel();
   }
}

Ostatnio musiałem zaimplementować tę funkcję przycisku Wstecz w mojej aplikacji. Odpowiedzi na pierwotne pytanie były przydatne, ale musiałem wziąć pod uwagę jeszcze dwa punkty:

1. W niektórych momentach przycisk Wstecz jest wyłączony
2. Główną czynnością jest używanie fragmentów w połączeniu z tylnym stosem

Na podstawie odpowiedzi i komentarzy stworzyłem następujący kod:

private static final long BACK_PRESS_DELAY = 1000;

private boolean mBackPressCancelled = false;
private long mBackPressTimestamp;
private Toast mBackPressToast;

@Override
public void onBackPressed() {
    // Do nothing if the back button is disabled.
    if (!mBackPressCancelled) {
        // Pop fragment if the back stack is not empty.
        if (getSupportFragmentManager().getBackStackEntryCount() > 0) {
            super.onBackPressed();
        } else {
            if (mBackPressToast != null) {
                mBackPressToast.cancel();
            }

            long currentTimestamp = System.currentTimeMillis();

            if (currentTimestamp < mBackPressTimestamp + BACK_PRESS_DELAY) {
                super.onBackPressed();
            } else {
                mBackPressTimestamp = currentTimestamp;

                mBackPressToast = Toast.makeText(this, getString(R.string.warning_exit), Toast.LENGTH_SHORT);
                mBackPressToast.show();
            }
        }
    }
}

Powyższy kod zakłada, że ​​używana jest biblioteka obsługi. Jeśli używasz fragmenty, ale nie z biblioteki wsparcia, chcesz zastąpić getSupportFragmentManager()przez getFragmentManager().

Usuń pierwszy if, jeśli przycisk Wstecz nigdy nie jest anulowany. Usuń drugi if, jeśli nie używasz fragmentów lub stosu fragmentów

Ważne jest również, aby pamiętać, że metoda onBackPressedjest obsługiwana od Androida 2.0. Sprawdź tę stronę, aby uzyskać szczegółowy opis. Aby funkcja back press działała również w starszych wersjach, dodaj następującą metodę do swojej aktywności:

@Override
public boolean onKeyDown(int keyCode, KeyEvent event)  {
    if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.ECLAIR
            && keyCode == KeyEvent.KEYCODE_BACK
            && event.getRepeatCount() == 0) {
        // Take care of calling this method on earlier versions of
        // the platform where it doesn't exist.
        onBackPressed();
    }

    return super.onKeyDown(keyCode, event);
}

W java

private Boolean exit = false; 

if (exit) {
onBackPressed(); 
}

 @Override
public void onBackPressed() {
    if (exit) {
        finish(); // finish activity
    } else {
        Toast.makeText(this, "Press Back again to Exit.",
                Toast.LENGTH_SHORT).show();
        exit = true;
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                exit = false;
            }
        }, 3 * 1000);

    }
}

W kotlinie

 private var exit = false

 if (exit) {
        onBackPressed()
         }

 override fun onBackPressed(){
           if (exit){
               finish() // finish activity
           }else{
            Toast.makeText(this, "Press Back again to Exit.",
                    Toast.LENGTH_SHORT).show()
            exit = true
            Handler().postDelayed({ exit = false }, 3 * 1000)

        }
    }

Wiem, że to bardzo stare pytanie, ale jest to najłatwiejszy sposób na robienie tego, co chcesz.

@Override
public void onBackPressed() {
   ++k; //initialise k when you first start your activity.
   if(k==1){
      //do whatever you want to do on first click for example:
      Toast.makeText(this, "Press back one more time to exit", Toast.LENGTH_LONG).show();
   }else{
      //do whatever you want to do on the click after the first for example:
      finish(); 
   }
}

Wiem, że to nie jest najlepsza metoda, ale działa dobrze!

W tym celu wdrożyłem następującą funkcję:

private long onRecentBackPressedTime;
@Override
public void onBackPressed() {
    if (System.currentTimeMillis() - onRecentBackPressedTime > 2000) {
       onRecentBackPressedTime = System.currentTimeMillis();
       Toast.makeText(this, "Please press BACK again to exit", Toast.LENGTH_SHORT).show();
       return;
     }
   super.onBackPressed();
}

Pomaga to również wtedy, gdy poprzednia aktywność stosu jest zapisana w stosie.

Zmodyfikowałem odpowiedź Sudheesh

boolean doubleBackToExitPressedOnce = false;

@Override
public void onBackPressed() {
    if (doubleBackToExitPressedOnce) {
        //super.onBackPressed();

  Intent intent = new Intent(Intent.ACTION_MAIN);
                    intent.addCategory(Intent.CATEGORY_HOME);
                    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);//***Change Here***
                    startActivity(intent);
                    finish();
                    System.exit(0);
        return;
    }

    this.doubleBackToExitPressedOnce = true;
    Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT).show();

    new Handler().postDelayed(new Runnable() {

        @Override
        public void run() {
            doubleBackToExitPressedOnce=false;                       
        }
    }, 2000);
} 

@Override public void onBackPressed() {
   Log.d("CDA", "onBackPressed Called");
   Intent intent = new Intent();
   intent.setAction(Intent.ACTION_MAIN);
   intent.addCategory(Intent.CATEGORY_HOME);

   startActivity(intent);
}

Myślę, że jest to nieco lepsza metoda niż Zefnus . Wywołaj System.currentTimeMillis () tylko jeden raz i pomiń return;:

long previousTime;

@Override
public void onBackPressed()
{
    if (2000 + previousTime > (previousTime = System.currentTimeMillis())) 
    { 
        super.onBackPressed();
    } else {
        Toast.makeText(getBaseContext(), "Tap back button in order to exit", Toast.LENGTH_SHORT).show();
    }
}

Oto pełny działający kod. Nie zapomnij również usunąć wywołań zwrotnych, aby nie spowodowało to wycieku pamięci w aplikacji. :)

private boolean backPressedOnce = false;
private Handler statusUpdateHandler;
private Runnable statusUpdateRunnable;

public void onBackPressed() {
        if (backPressedOnce) {
            finish();
        }

        backPressedOnce = true;
        final Toast toast = Toast.makeText(this, "Press again to exit", Toast.LENGTH_SHORT);
        toast.show();

        statusUpdateRunnable = new Runnable() {
            @Override
            public void run() {
                backPressedOnce = false;
                toast.cancel();  //Removes the toast after the exit.
            }
        };

        statusUpdateHandler.postDelayed(statusUpdateRunnable, 2000);
}

@Override
protected void onDestroy() {
    super.onDestroy();
    if (statusUpdateHandler != null) {
        statusUpdateHandler.removeCallbacks(statusUpdateRunnable);
    }
}

Tutaj uogólniłem napisanie kodu dla liczby zliczeń N. Kod jest podobnie napisany dla opcji Enable Developer w telefonie z systemem Android. Nawet ty możesz tego użyć, aby włączyć funkcje podczas testowania aplikacji przez programistę.

 private Handler tapHandler;
 private Runnable tapRunnable;
 private int mTapCount = 0;
 private int milSecDealy = 2000;

onCreate(){
 ...
tapHandler = new Handler(Looper.getMainLooper());

 }

Wywołaj askToExit () w opcji backpress lub wylogowania.

private void askToExit() {
   if (mTapCount >= 2) {
    releaseTapValues();
    /* ========= Exit = TRUE  =========  */
   }

   mTapCount++;
   validateTapCount();
  }


  /* Check with null to avoid create multiple instances of the runnable */
  private void validateTapCount() {
   if (tapRunnable == null) {
    tapRunnable = new Runnable() {
     @Override
     public void run() {
      releaseTapValues();
      /* ========= Exit = FALSE  =========  */
     }
    };
    tapHandler.postDelayed(tapRunnable, milSecDealy);
   }
  }

  private void releaseTapValues() {
   /* Relase the value  */
   if (tapHandler != null) {
    tapHandler.removeCallbacks(tapRunnable);
    tapRunnable = null; /* release the object */
    mTapCount = 0; /* release the value */
   }
  }


  @Override
  protected void onDestroy() {
   super.onDestroy();
   releaseTapValues();
  }

używam tego

import android.app.Activity;
import android.support.annotation.StringRes;
import android.widget.Toast;

public class ExitApp {

    private static long lastClickTime;

    public static void now(Activity ctx, @StringRes int message) {
        now(ctx, ctx.getString(message), 2500);
    }

    public static void now(Activity ctx, @StringRes int message, long time) {
        now(ctx, ctx.getString(message), time);
    }

    public static void now(Activity ctx, String message, long time) {
        if (ctx != null && !message.isEmpty() && time != 0) {
            if (lastClickTime + time > System.currentTimeMillis()) {
                ctx.finish();
            } else {
                Toast.makeText(ctx, message, Toast.LENGTH_SHORT).show();
                lastClickTime = System.currentTimeMillis();
            }
        }
    }

}

użyj w przypadkuonBackPressed

@Override
public void onBackPressed() {
   ExitApp.now(this,"Press again for close");
}

lub ExitApp.now(this,R.string.double_back_pressed)

do zmiany sekund potrzeba zamknięcia, określonych milisekund

ExitApp.now(this,R.string.double_back_pressed,5000)

Gdy HomeActivity zawiera szufladę nawigacji i funkcję backPressed (), aby wyjść z aplikacji. (Nie zapomnij zainicjować zmiennej globalnej boolean doubleBackToExitPressedOnce = false;) nowy moduł obsługi po 2 sekundach ustaw zmienną doubleBackPressedOnce na false

@Override
public void onBackPressed() {
    DrawerLayout drawer = findViewById(R.id.drawer_layout);
    if (drawer.isDrawerOpen(GravityCompat.END)) {
        drawer.closeDrawer(GravityCompat.END);
    } else {
        if (doubleBackToExitPressedOnce) {
            super.onBackPressed();
            moveTaskToBack(true);
            return;
        } else {
            this.doubleBackToExitPressedOnce = true;
            Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT).show();
            new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    doubleBackToExitPressedOnce = false;
                }
            }, 2000);
        }
    }
}

boolean doubleBackToExitPressedOnce = false;

@Override
public void onBackPressed() {
    if (doubleBackToExitPressedOnce) {
        super.onBackPressed();
        return;
    }

    this.doubleBackToExitPressedOnce = true;

    Snackbar.make(findViewById(R.id.photo_album_parent_view), "Please click BACK again to exit", Snackbar.LENGTH_SHORT).show();

    new Handler().postDelayed(new Runnable() {

        @Override
        public void run() {
            doubleBackToExitPressedOnce=false;
        }
    }, 2000);
}

Kilka ulepszeń w odpowiedzi Sudheesh B Naira, zauważyłem, że będzie czekał na moduł obsługi, nawet natychmiast naciskając dwukrotnie, więc anuluj moduł obsługi, jak pokazano poniżej. Anulowałem także toast, aby nie wyświetlał się po zamknięciu aplikacji.

 boolean doubleBackToExitPressedOnce = false;
        Handler myHandler;
        Runnable myRunnable;
        Toast myToast;

    @Override
        public void onBackPressed() {
            if (doubleBackToExitPressedOnce) {
                myHandler.removeCallbacks(myRunnable);
                myToast.cancel();
                super.onBackPressed();
                return;
            }

            this.doubleBackToExitPressedOnce = true;
            myToast = Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT);
            myToast.show();

            myHandler = new Handler();

            myRunnable = new Runnable() {

                @Override
                public void run() {
                    doubleBackToExitPressedOnce = false;
                }
            };
            myHandler.postDelayed(myRunnable, 2000);
        }

To jest tak samo jak zaakceptowana i najczęściej głosowana odpowiedź, ale ten wycięty użył Snackbar zamiast Toast.

boolean doubleBackToExitPressedOnce = false;

    @Override
    public void onBackPressed() {
        if (doubleBackToExitPressedOnce) {
            super.onBackPressed();
            return;
        }

        this.doubleBackToExitPressedOnce = true;
        Snackbar.make(content, "Please click BACK again to exit", Snackbar.LENGTH_SHORT)
                .setAction("Action", null).show();


        new Handler().postDelayed(new Runnable() {

            @Override
            public void run() {
                doubleBackToExitPressedOnce=false;
            }
        }, 2000);
    }

W moim przypadku polegam na Snackbar#isShown()lepsze UX.

private Snackbar exitSnackBar;

@Override
public void onBackPressed() {
    if (isNavDrawerOpen()) {
        closeNavDrawer();
    } else if (getSupportFragmentManager().getBackStackEntryCount() == 0) {
        if (exitSnackBar != null && exitSnackBar.isShown()) {
            super.onBackPressed();
        } else {
            exitSnackBar = Snackbar.make(
                    binding.getRoot(),
                    R.string.navigation_exit,
                    2000
            );
            exitSnackBar.show();
        }
    } else {
        super.onBackPressed();
    }
}

W przypadku działania, które ma szufladę nawigacji , użyj następującego kodu dla OnBackPressed ()

boolean doubleBackToExitPressedOnce = false;

@Override
    public void onBackPressed() {
        DrawerLayout drawer = (DrawerLayout) findViewById(R.id.drawer_layout);
        if (drawer.isDrawerOpen(GravityCompat.START)) {
            drawer.closeDrawer(GravityCompat.START);
        } else {
            if (doubleBackToExitPressedOnce) {
                if (getFragmentManager().getBackStackEntryCount() ==0) {
                    finishAffinity();
                    System.exit(0);
                } else {
                    getFragmentManager().popBackStackImmediate();
                }
                return;
            }

            if (getFragmentManager().getBackStackEntryCount() ==0) {
                this.doubleBackToExitPressedOnce = true;
                Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT).show();

                new Handler().postDelayed(new Runnable() {

                    @Override
                    public void run() {
                        doubleBackToExitPressedOnce = false;
                    }
                }, 2000);
            } else {
                getFragmentManager().popBackStackImmediate();
            }
        }
    }

Oto inny sposób ... przy użyciu metody CountDownTimer

private boolean exit = false;
@Override
public void onBackPressed() {
        if (exit) {
            finish();
        } else {
            Toast.makeText(this, "Press back again to exit",
                    Toast.LENGTH_SHORT).show();
            exit = true;
            new CountDownTimer(3000,1000) {

                @Override
                public void onTick(long l) {

                }

                @Override
                public void onFinish() {
                    exit = false;
                }
            }.start();
        }

    }