Durch zweimaliges Klicken auf die Zurück-Schaltfläche verlassen Sie eine Aktivität.

Question

Ich habe in letzter Zeit dieses Muster in vielen Android-Apps und Spielen bemerkt: Beim Klicken auf die Zurück-Schaltfläche, um die Anwendung zu "beenden", erscheint eine Toast mit einer Nachricht ähnlich wie "Bitte klicken Sie erneut auf ZURÜCK, um zu beenden".

Ich frage mich, da ich es immer öfter sehe, ob das eine eingebaute Funktion ist, auf die man auf irgendeine Weise in einer Aktivität zugreifen kann. Ich habe den Quellcode vieler Klassen durchgesehen, konnte jedoch nichts darüber finden.

Natürlich kann ich mir ein paar Möglichkeiten vorstellen, um die gleiche Funktionalität recht einfach zu erreichen (das einfachste ist wahrscheinlich, einen Boolean in der Aktivität zu halten, der anzeigt, ob der Benutzer bereits einmal geklickt hat...), aber ich frage mich, ob es bereits etwas gibt.

BEARBEITEN: Wie @LAS_VEGAS erwähnt hat, meinte ich mit "beenden" nicht im traditionellen Sinne. (d.h. beendet) Ich meinte "zurück zu dem, was geöffnet war, bevor die Startaktivität der Anwendung gestartet wurde", wenn das Sinn macht :)

Answer 1

Ich denke, das ist das, was du brauchst, wenn wir diesen Toast zeigen wollen, wenn es nur eine Aktivität im Stapel gibt und der Benutzer auf "Zurück" drückt von dieser letzten Aktivität im Stapel.

var exitOpened=false // Globale Deklaration

und im onBackPressed Methode ändere es wie folgt:

override fun onBackPressed() {
        if (isTaskRoot && !exitOpened)
        {
            exitOpened=true
            toast("Bitte drücken Sie erneut auf Zurück, um zu beenden")
            return
        }
        super.onBackPressed()
    }

Hier wird isTaskRoot true zurückgeben, wenn die aktuelle Aktivität die Wurzelaktivität (erste Aktivität) des Stapels ist und false, wenn sie es nicht ist.

Sie können die offizielle Dokumentation hier überprüfen

Answer 2

Die meisten modernen Anwendungen verwenden nur eine Aktivität und mehrere Fragmente. Wenn Sie also die Navigationskomponenten verwenden und diese aus dem Home-Fragment aufrufen müssen, hier ist die Lösung.

override fun onAttach(context: Context) {
    super.onAttach(context)
    val callback: OnBackPressedCallback = object :
    OnBackPressedCallback(true) {
        override fun handleOnBackPressed() {
            if (doubleBackPressed) {
                activity.finishAffinity()
            }
            doubleBackPressed = true
            Toast.makeText(requireActivity(), "Drücken Sie erneut auf ZURÜCK, um zu beenden", Toast.LENGTH_LONG).show()
            Handler(Looper.myLooper()!!).postDelayed(Runnable {doubleBackPressed = false},
                2000)
            }
        }
    requireActivity().onBackPressedDispatcher.addCallback(this, callback)
}

Answer 3

Wenn HomeActivity eine Navigationsleiste und eine doppelte backPressed() Funktion enthält, um die App zu beenden. (Vergessen Sie nicht, die globale Variable boolean doubleBackToExitPressedOnce = false zu initialisieren.) Ein neuer Handler setzt die doubleBackPressedOnce-Variable nach 2 Sekunden auf 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, "Bitte klicken Sie erneut auf ZURÜCK, um zu beenden", Toast.LENGTH_SHORT).show();
            new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    doubleBackToExitPressedOnce = false;
                }
            }, 2000);
        }
    }
}

Answer 4

Ich benutze das

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

}

verwende im Ereignis onBackPressed

@Override
public void onBackPressed() {
   ExitApp.now(this,"Erneut drücken, um zu schließen");
}

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

um Sekunden zu ändern, die benötigt werden, um zu schließen, spezifiziere Millisekunden

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

Answer 5

Hier habe ich den Code für N Tipptastsen generalisiert. Der Code ist ähnlich für die Aktivierung der Entwickleroptionen auf einem Android-Gerät geschrieben. Sie können dies auch verwenden, um Funktionen zu aktivieren, während der Entwickler die App testet.

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

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

 }

Rufen Sie askToExit() bei der Zurück-Taste oder der Logout-Option auf.

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

   mTapCount++;
   validateTapCount();
  }

  /* Überprüfen Sie auf null, um das Erstellen mehrerer Instanzen des Runnables zu vermeiden */
  private void validateTapCount() {
   if (tapRunnable == null) {
    tapRunnable = new Runnable() {
     @Override
     public void run() {
      releaseTapValues();
      /* ========= Exit = FALSE  =========  */
     }
    };
    tapHandler.postDelayed(tapRunnable, milSecDealy);
   }
  }

  private void releaseTapValues() {
   /* Wert freigeben */
   if (tapHandler != null) {
    tapHandler.removeCallbacks(tapRunnable);
    tapRunnable = null; /* Objekt freigeben */
    mTapCount = 0; /* Wert freigeben */
   }
  }

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