En cliquant sur le bouton de retour deux fois pour quitter une activité

Sudheesh B Nair's a une belle (et accepté) réponse sur la question, qui, je pense, devraient avoir une meilleure solution de rechange comme;

Quel est le problème avec la mesure du temps passé et de vérifier si TIME_INTERVAL milisecondes (2000) ont passé depuis la dernière sauvegarde de la presse. L'exemple de code suivant utilise System.currentTimeMillis(); pour stocker le temps onBackPressed() est appelé;

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

De retour sur accepté de répondre à critique; à l'Aide d'un flag d'indiquer si elle a été pressée dans la dernière TIME_INTERVAL (2000) millisecondes et set - reset est via Handler's postDelayed() méthode a été la première chose à venir dans mon esprit. Mais le postDelayed() action doit être annulée lorsqu'une activité est en cours de fermeture, le retrait de la Runnable.

Afin de supprimer les Runnable, il ne doit pas être déclaré anonyme, et être déclaré en tant que membre avec le Handler aswell. Puis removeCallbacks() méthode de Handler peut être appelé de manière appropriée.

L'exemple suivant est la démonstration;

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

Grâce à @NSouth pour contribuer; afin de prévenir toast message apparaissent, même après la fermeture de l'application, Toast peut être déclarée en tant que membre - dire mExitToast - et peut être annulé par mExitToast.cancel(); juste avant super.onBackPressed(); appel.

Diagramme De Flux De Processus:

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

Basée sur la réponse correcte et suggestions dans les commentaires, j'ai créé une démo qui fonctionne tout à fait bien et supprime le gestionnaire des rappels après avoir été utilisés.

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

}

J'espère que ce sera utile !!

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

Déclarer La Variableprivate boolean doubleBackToExitPressedOnce = false;

Collez ceci dans votre Activité Principale et cela va résoudre votre problème

Ce n'est pas une fonctionnalité intégrée. Je pense qu'il n'est même recommandé de comportement. Les applications Android ne sont pas destinés à la sortie:

Pourquoi ne pas les applications Android de fournir une "Sortie" de l'option?

1. Déclarer un mondial Toast variable de Classe MainActivity. exemple: Toast exitToast;
2. L'initialiser dans onCreate méthode de vue. exemple:
   exitToast = Toast.makeText(getcontexteapplication ()", Appuyez sur retour pour quitter", Toast.LENGTH_SHORT);

3. Enfin créer un onBackPressedMethod comme Suit:

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

Cela fonctionne correctement, je l'ai testé. et je pense que c'est beaucoup plus simple.

Récemment, j'ai eu besoin de mettre en œuvre ce bouton retour fonctionnalité dans une application de la mine. Les réponses à la question d'origine ont été utiles, mais j'ai dû prendre plus de deux points en considération:

1. À certains points dans le temps, le bouton de retour est désactivé
2. L'activité principale est l'aide de fragments en combinaison avec une pile de retour

Sur la base des réponses et des commentaires, j'ai créé le code suivant:

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

Le code ci-dessus suppose que la bibliothèque de prise en charge est utilisé. Si vous utilisez des fragments, mais pas le soutien de la bibliothèque, vous voulez remplacer getSupportFragmentManager() par getFragmentManager().

Supprimer le premier if, si le bouton retour n'est jamais annulée. Supprimer la deuxième if, si vous n'utilisez pas de fragments ou d'un fragment de la pile de retour

Aussi, il est important d'être conscient que la méthode onBackPressed est pris en charge depuis Android 2.0. Vérifier cette page pour élaborer une description. Pour faire le dos de presse de la fonctionnalité de travailler sur des versions plus anciennes, ajoutez la méthode suivante à votre activité:

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

Je sais que c'est une très vieille question, mais c'est la façon la plus simple de faire ce que vous voulez.

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

Je sais que ce n'est pas la meilleure méthode, mais il fonctionne très bien!

Cela aide aussi quand vous avez pile précédent de l'activité stockée dans la pile.

J'ai modifié Sudheesh la réponse de

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

Voici tout le code de travail. Et aussi n'oubliez pas de supprimer les rappels de sorte qu'il ne provoque une fuite de mémoire dans l'application. 🙂

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

Quand HomeActivity contiennent de navigation tiroir et double backPressed() fonction de la sortie de l'app.
(N'oubliez pas de initilize global variable booléenne doubleBackToExitPressedOnce = false;)
nouveau gestionnaire, au bout de 2 sec définir doubleBackPressedOnce variable à 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);
        }
    }
}

Quelques Améliorations dans Sudheesh B Nair réponse, j'ai remarqué qu'il va attendre que gestionnaire, même en appuyant deux fois sur retour immédiatement, afin d'annuler gestionnaire comme indiqué ci-dessous. J'ai annulée pour des toasts aussi, pour éviter d'affichage après l'application de sortie.

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

C'est la même chose de l'accepté et le plus voté réponse, mais ce ciselée utilisé snack-bar au lieu de pain grillé.

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

Pour l'activité dont l'un est d'avoir de Navigation Tiroir, Utilisez le code suivant pour 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();
            }
        }
    }

Ici est d'une autre façon... à l'aide de la CountDownTimer méthode

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

    }

Normalement j'ajoutez un commentaire, mais ma réputation ne permet pas ceci.
Voici donc mes deux cents:

Dans Kotlin vous pouvez utiliser les coroutines à retarder la mise à false:

private var doubleBackPressed = false
private var toast : Toast ?= null

override fun onCreate(savedInstanceState: Bundle?) {
    toast = Toast.maketext(this, "Press back again to exit", Toast.LENGTH_SHORT)
}

override fun onBackPressed() {
    if (doubleBackPressed) {
        toast?.cancel()
        super.onBackPressed()
        return
    }
    this.doubleBackPressed = true
    toast?.show()
    GlobalScope.launch {
        delay(2000)
        doubleBackPressed = false
    }
}

Vous aurez à importer:

import kotlinx.coroutines.launch
import kotlinx.coroutines.delay
import kotlinx.coroutines.GlobalScope

 private static final int TIME_DELAY = 2000;
    private static long back_pressed;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    @Override
    public void onBackPressed() {
        if (back_pressed + TIME_DELAY > System.currentTimeMillis()) {
            super.onBackPressed();
        } else {
            Toast.makeText(getBaseContext(), "Press once again to exit!",
                    Toast.LENGTH_SHORT).show();
        }
        back_pressed = System.currentTimeMillis();
    }

Vous pouvez également utiliser la visibilité d'un Toast, de sorte que vous n'avez pas besoin que Gestionnaire/postDelayed ultra solution.

Toast doubleBackButtonToast;

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

    doubleBackButtonToast = Toast.makeText(this, "Double tap back to exit.", Toast.LENGTH_SHORT);
}

@Override
public void onBackPressed() {
    if (doubleBackButtonToast.getView().isShown()) {
        super.onBackPressed();
    }

    doubleBackButtonToast.show();
}

Dans Kotlin sur le retour appuyez sur cette touche pour quitter l'application, vous pouvez utiliser:

Définir une variable globale:

private var doubleBackToExitPressedOnce = false

Remplacer onBackPressed:

override fun onBackPressed() {
        if (doubleBackToExitPressedOnce) {
            super.onBackPressed()
            return
        }

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

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

Ici est une façon de le faire à l'aide de RxJava:

override fun onCreate(...) {
    backPresses.timeInterval(TimeUnit.MILLISECONDS, Schedulers.io())
            .skip(1) //Skip initial event; delay will be 0.
            .onMain()
            .subscribe {
                if (it.time() < 7000) super.onBackPressed() //7000 is the duration of a Toast with length LENGTH_LONG.
            }.addTo(compositeDisposable)

    backPresses.throttleFirst(7000, TimeUnit.MILLISECONDS, Schedulers.io())
            .subscribe { Toast.makeText(this, "Press back again to exit.", LENGTH_LONG).show() }
            .addTo(compositeDisposable)
}

override fun onBackPressed() = backPresses.onNext(Unit)

Meilleure Solution avec des Toasts

En Java

private Toast exitToast;

@Override
public void onBackPressed() {
    if (exitToast == null || exitToast.getView() == null || exitToast.getView().getWindowToken() == null) {
        exitToast = Toast.makeText(this, "Press again to exit", Toast.LENGTH_LONG);
        exitToast.show();
    } else {
        exitToast.cancel();
        super.onBackPressed();
    }
}

Dans Kotlin

private var exitToast: Toast? = null

override fun onBackPressed() {
    if (exitToast == null || exitToast!!.view == null || exitToast!!.view.windowToken == null) {
        exitToast = Toast.makeText(this, "Press again to exit", Toast.LENGTH_LONG)
        exitToast!!.show()
    } else {
        exitToast!!.cancel()
        super.onBackPressed()
    }
}