wake-up-neo.com

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.

261
Peter A

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

}
380
jax
@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();
}
174
Chanakya Vadla

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

}
32
suraj jain

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

22
Toni Gamez

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

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

}
5

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
}
5
vasiljevski
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();
                }
            }
        }
    }
2
Mohit Hooda

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

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

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

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

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

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.

0
Android Geek