Cliquer deux fois sur le bouton retour pour quitter une activité

Question

J'ai remarqué ce modèle dans beaucoup d'applications et de jeux Android récemment : lorsque l'on clique sur le bouton retour pour "quitter" l'application, un message d'erreur s'affiche. Toast s'affiche avec un message similaire à "Please click BACK again to exit".

Je me demandais, car je le vois de plus en plus souvent, s'il s'agit d'une fonctionnalité intégrée à laquelle on peut accéder d'une manière ou d'une autre dans une activité ? J'ai consulté le code source de nombreuses classes, mais je n'ai rien trouvé à ce sujet.

Bien sûr, je peux penser à plusieurs façons de réaliser la même fonctionnalité assez facilement (le plus simple est probablement de garder un booléen dans l'activité qui indique si l'utilisateur a déjà cliqué une fois...) mais je me demandais s'il y avait déjà quelque chose ici.

EDIT : Comme l'a mentionné @LAS_VEGAS, je ne voulais pas vraiment dire "sortie" dans le sens traditionnel. (c'est-à-dire terminé) Je voulais dire "revenir à ce qui était ouvert avant le lancement de l'activité de démarrage de l'application", si cela a un sens :)

Answer 1

Dans Java Activity :

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(Looper.getMainLooper()).postDelayed(new Runnable() {

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

Dans Kotlin Activity :

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(Looper.getMainLooper()).postDelayed(Runnable { doubleBackToExitPressedOnce = false }, 2000)
    }

Je pense que ce gestionnaire permet de réinitialiser la variable après 2 secondes.

Answer 2

Sudheesh B Nair Le site de l'association a une bonne réponse (et acceptée) à la question, mais je pense qu'il devrait y avoir une meilleure alternative, par exemple ;

Qu'y a-t-il de mal à mesurer le temps passé et à vérifier si TIME_INTERVAL milisecondes (disons 2000) écoulées depuis la dernière pression arrière. L'exemple de code suivant utilise System.currentTimeMillis(); pour enregistrer l'heure onBackPressed() s'appelle ;

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

---

Retour sur la réponse acceptée critique ; Utilisation d'un flag pour indiquer si elle a été pressée en dernier TIME_INTERVAL (disons 2000) millisecondes et set - reset est via Handler 's postDelayed() la méthode a été la première chose qui m'est venue à l'esprit. Mais la postDelayed() doit être annulée lors de la clôture de l'activité, en supprimant l'action Runnable .

Afin d'enlever le Runnable il ne doit pas être déclaré anonyme et être déclarée comme membre avec le Handler également. Puis removeCallbacks() méthode de Handler peut être appelé de manière appropriée.

L'exemple suivant en 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);
}

---

Merci à @NSouth pour sa contribution ; Afin de prévenir message de toast apparaissant même après la fermeture de l'application, Toast peut être déclaré comme un membre - disons mExitToast - et peut être annulé via mExitToast.cancel(); juste avant super.onBackPressed(); appeler.

Answer 3

J'ai pensé que je pourrais partager la façon dont j'ai procédé, j'ai simplement ajouté mon activité :

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

Et ça fonctionne exactement comme je le veux. Y compris la réinitialisation de l'état à chaque fois que l'activité est reprise.

Answer 4

Diagramme de flux de processus :

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

Answer 5

Sur la base de la bonne réponse et des suggestions dans les commentaires, j'ai créé une démo qui fonctionne parfaitement et supprime les callbacks du gestionnaire 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 cela vous sera utile !