Wie zeige ich einen Dialog an, um zu bestätigen, dass der Benutzer eine Android-Aktivität beenden möchte?
Ich habe versucht zu zeigen, ob Sie den Vorgang beenden möchten. Art des Dialogs, wenn der Benutzer versucht, eine Aktivität zu beenden.
Ich kann jedoch nicht die entsprechenden API-Hooks finden. Activity.onUserLeaveHint() sah anfangs vielversprechend aus, aber ich kann keinen Weg finden, die Aktivität am Ende zu hindern.
In Android 2.0 oder höher würde dies folgendermaßen aussehen:
@Override
public void onBackPressed() {
new AlertDialog.Builder(this)
.setIcon(Android.R.drawable.ic_dialog_alert)
.setTitle("Closing Activity")
.setMessage("Are you sure you want to close this activity?")
.setPositiveButton("Yes", new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dialog, int which) {
finish();
}
})
.setNegativeButton("No", null)
.show();
}
In früheren Versionen würde es so aussehen:
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
//Handle the back button
if(keyCode == KeyEvent.KEYCODE_BACK) {
//Ask the user if they want to quit
new AlertDialog.Builder(this)
.setIcon(Android.R.drawable.ic_dialog_alert)
.setTitle(R.string.quit)
.setMessage(R.string.really_quit)
.setPositiveButton(R.string.yes, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
//Stop the activity
YourClass.this.finish();
}
})
.setNegativeButton(R.string.no, null)
.show();
return true;
}
else {
return super.onKeyDown(keyCode, event);
}
}
@Override
public void onBackPressed() {
new AlertDialog.Builder(this)
.setMessage("Are you sure you want to exit?")
.setCancelable(false)
.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
ExampleActivity.super.onBackPressed();
}
})
.setNegativeButton("No", null)
.show();
}
Haben Sie den @ user919216-Code geändert und ihn mit WebView kompatibel gemacht
@Override
public void onBackPressed() {
if (webview.canGoBack()) {
webview.goBack();
}
else
{
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setMessage("Are you sure you want to exit?")
.setCancelable(false)
.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
finish();
}
})
.setNegativeButton("No", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
dialog.cancel();
}
});
AlertDialog alert = builder.create();
alert.show();
}
}
Ich würde es vorziehen, mit einem Doppelklick auf die Zurück-Taste zu beenden, als mit einem Exit-Dialog.
Bei dieser Lösung wird ein Toast angezeigt, wenn Sie zum ersten Mal zurückgehen. Sie wird darauf hingewiesen, dass die App durch erneutes Drücken der Taste zurück geschlossen wird. In diesem Beispiel weniger als 4 Sekunden.
private Toast toast;
private long lastBackPressTime = 0;
@Override
public void onBackPressed() {
if (this.lastBackPressTime < System.currentTimeMillis() - 4000) {
toast = Toast.makeText(this, "Press back again to close this app", 4000);
toast.show();
this.lastBackPressTime = System.currentTimeMillis();
} else {
if (toast != null) {
toast.cancel();
}
super.onBackPressed();
}
}
Token von: http://www.androiduipatterns.com/2011/03/back-button-verhalten.html
Wenn Sie nicht sicher sind, ob der Aufruf von "Zurück" die App beendet oder der Benutzer zu einer anderen Aktivität führt, können Sie die obigen Antworten in eine Prüfung einbetten, isTaskRoot (). Dies kann passieren, wenn Ihre Hauptaktivität mehrmals zum Back-Stack hinzugefügt werden kann oder wenn Sie den Back-Stack-Verlauf bearbeiten.
if(isTaskRoot()) {
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setMessage("Are you sure you want to exit?")
.setCancelable(false)
.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
YourActivity.super.onBackPressed;
}
})
.setNegativeButton("No", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
dialog.cancel();
}
});
AlertDialog alert = builder.create();
alert.show();
} else {
super.onBackPressed();
}
in China bestätigen die meisten Apps das Beenden mit "zweimal klicken":
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);
}
Entfernen Sie zuerst super.onBackPressed(); aus der onbackPressed()-Methode als folgenden Code
@Override
public void onBackPressed() {
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setMessage("Are you sure you want to exit?")
.setCancelable(false)
.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
MyActivity.this.finish();
}
})
.setNegativeButton("No", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
dialog.cancel();
}
});
AlertDialog alert = builder.create();
alert.show();
}
Lambda verwenden:
new AlertDialog.Builder(this).setMessage(getString(R.string.exit_msg))
.setTitle(getString(R.string.info))
.setPositiveButton(getString(R.string.yes), (arg0, arg1) -> {
moveTaskToBack(true);
finish();
})
.setNegativeButton(getString(R.string.no), (arg0, arg1) -> {
})
.show();
Sie müssen außerdem die Spracheinstellung für die Unterstützung von Java 8 in gradle.build festlegen:
compileOptions {
targetCompatibility 1.8
sourceCompatibility 1.8
}
Just put this code in your first activity
@Override
public void onBackPressed() {
if (drawerLayout.isDrawerOpen(GravityCompat.END)) {
drawerLayout.closeDrawer(GravityCompat.END);
}
else {
// if your using fragment then you can do this way
int fragments = getSupportFragmentManager().getBackStackEntryCount();
if (fragments == 1) {
new AlertDialog.Builder(this)
.setMessage("Are you sure you want to exit?")
.setCancelable(false)
.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
finish();
}
})
.setNegativeButton("No", null)
.show();
} else {
if (getFragmentManager().getBackStackEntryCount() > 1) {
getFragmentManager().popBackStack();
} else {
super.onBackPressed();
}
}
}
}
Ich mag einen @ GLee-Ansatz und verwende ihn mit Fragment wie unten.
@Override
public void onBackPressed() {
if(isTaskRoot()) {
new ExitDialogFragment().show(getSupportFragmentManager(), null);
} else {
super.onBackPressed();
}
}
Dialog mit Fragment:
public class ExitDialogFragment extends DialogFragment {
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
return new AlertDialog.Builder(getActivity())
.setTitle(R.string.exit_question)
.setPositiveButton(Android.R.string.yes, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
getActivity().finish();
}
})
.setNegativeButton(Android.R.string.no, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
getDialog().cancel();
}
})
.create();
}
}
das funktioniert gut
@Override
public void onBackPressed() {
if (mExitOnBackPress) finish();
else {
Toast.makeText(this, R.string.msg_confirm_exit, Toast.LENGTH_SHORT).show();
mExitOnBackPress = true;
new Android.os.Handler().postDelayed(new Runnable() {
@Override
public void run() {
mExitOnBackPress = false;
}
}, 2000);
}
}
Eine andere Alternative wäre, show a Toast/Snackbar beim ersten Zurückdrücken mit der Aufforderung, erneut auf Exit zu drücken, was viel weniger aufdringlich ist als das Anzeigen eines AlertDialog, um zu bestätigen, ob der Benutzer die App beenden möchte.
Sie können den DoubleBackPress Android Library verwenden, um dies mit wenigen Codezeilen zu erreichen. Beispiel GIF zeigt ein ähnliches Verhalten.
Fügen Sie Ihrer Anwendung zunächst die Abhängigkeit hinzu:
dependencies {
implementation 'com.github.kaushikthedeveloper:double-back-press:0.0.1'
}
Implementieren Sie anschließend in Ihrer Aktivität das erforderliche Verhalten.
// set the Toast to be shown on FirstBackPress (ToastDisplay - builtin template)
// can be replaced by custom action (new FirstBackPressAction{...})
FirstBackPressAction firstBackPressAction = new ToastDisplay().standard(this);
// set the Action on DoubleBackPress
DoubleBackPressAction doubleBackPressAction = new DoubleBackPressAction() {
@Override
public void actionCall() {
// TODO : Exit the application
finish();
System.exit(0);
}
};
// setup DoubleBackPress behaviour : close the current Activity
DoubleBackPress doubleBackPress = new DoubleBackPress()
.withDoublePressDuration(3000) // msec - wait for second back press
.withFirstBackPressAction(firstBackPressAction)
.withDoubleBackPressAction(doubleBackPressAction);
Zum Schluss legen Sie dies als Verhalten beim Zurückdrücken fest.
@Override
public void onBackPressed() {
doubleBackPress.onBackPressed();
}
Wenn Sie Fragment anstelle von Aktivität verwenden, setzen Sie diesen Code in Ihre Hauptaktivität
private Toast toast;
private long lastBackPressTime = 0;
@SuppressLint("WrongConstant")
@Override
public void onBackPressed() {
int fragments = getFragmentManager().getBackStackEntryCount();
if (fragments == 0) {
// make layout invisible since last fragment will be removed
if (this.lastBackPressTime < System.currentTimeMillis() - 3000) {
toast = Toast.makeText(this, "Press back again to close this app", 3000);
toast.show();
this.lastBackPressTime = System.currentTimeMillis();
}else{
if (toast != null) {
toast.cancel();
}
super.onBackPressed();
}
}else{
if (toast != null) {
toast.cancel();
}
super.onBackPressed();
}
}
Wenn Sie Fragment in Ihrer App verwenden ... Hier ist die Lösung
@Override
public void onBackPressed() {
int count = getSupportFragmentManager().getBackStackEntryCount();//User that use Android library should use getFragmentManager()
if (count == 0) {
new AlertDialog.Builder(this)
.setTitle(getString(R.string.closing_app))
.setMessage(getString(R.string.closing_app_msg))
.setPositiveButton(getString(R.string.yes), new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
finish();
}
})
.setNegativeButton(getString(R.string.no), null)
.show();
}
else {
super.onBackPressed();
}
}
Anzeigen des Dialogfelds zur Bestätigung, dass der Benutzer eine Aktivität von Android beenden möchte.
Fügen Sie der onBackPressed-Überschreibungsmethode den folgenden Code hinzu.
@Override
public void onBackPressed() {
hideViews();
getSupportActionBar().setDisplayHomeAsUpEnabled(false);
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setMessage("Are you sure you want to exit the activity?")
.setCancelable(false)
.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
finishAffinity();
}
}
})
.setNegativeButton("No", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
dialog.cancel();
}
});
AlertDialog alert = builder.create();
alert.show();
}
Ich hoffe es hilft dir.