How can I reuse an AlertDialog for Yes/No on Android?

Question 1

Complete solution Try this

1) Createa Interface

import android.content.DialogInterface;

public interface AlertMagnatic {

    public abstract void PositiveMethod(DialogInterface dialog, int id);
    public abstract void NegativeMethod(DialogInterface dialog, int id);
}

2) Generalize method for confirm dialog.

public static void getConfirmDialog(Context mContext,String title, String msg, String positiveBtnCaption, String negativeBtnCaption, boolean isCancelable, final AlertMagnatic target) {
        AlertDialog.Builder builder = new AlertDialog.Builder(mContext);

        int imageResource = android.R.drawable.ic_dialog_alert;
        Drawable image = mContext.getResources().getDrawable(imageResource);

        builder.setTitle(title).setMessage(msg).setIcon(image).setCancelable(false).setPositiveButton(positiveBtnCaption, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int id) {
                target.PositiveMethod(dialog, id);
            }
        }).setNegativeButton(negativeBtnCaption, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int id) {
                target.NegativeMethod(dialog, id);
            }
        });

        AlertDialog alert = builder.create();
        alert.setCancelable(isCancelable);
        alert.show();
        if (isCancelable) {
            alert.setOnCancelListener(new OnCancelListener() {

                @Override
                public void onCancel(DialogInterface arg0) {
                    target.NegativeMethod(null, 0);
                }
            });
        }
    }

3) How to use

getConfirmDialog(getString(R.string.logout), getString(R.string.logout_message), getString(R.string.yes), getString(R.string.no), false,
                new AlertMagnatic() {

                    @Override
                    public void PositiveMethod(final DialogInterface dialog, final int id) {}

                    @Override
                    public void NegativeMethod(DialogInterface dialog, int id) {

                    }
                });

Question 2

Since this page is the first hit on Google, and it seems like such a common task with so little written about it, I'll share the way I've found to show a reusable DialogFragment.

Using interfaces gets really messy if you want to reuse the same Dialog multiple times from the same class, but perform a different action everytime. This solution is a simple and straight-forward way to get around that issue without introducing any disadvantages.

Edit 2017-02-25: This answer was previously using an Abstract class to implement confirm() and cancel(), however newer versions of Android will crash with the following error if you try to use an anonymous class as a DialogFragment:

java.lang.IllegalStateException: Fragment null must be a public static class to be properly recreated from instance state.

so I've modified the solution to use Runnables, which works really nice in Java8 but is also feasible without it

First, create a class which implements the creation of the Dialog itself:

/**
 * This is a reusable convenience class which makes it easy to show a confirmation dialog as a DialogFragment.
 * Create a new instance, call setArgs(...), setConfirm(), and setCancel() then show it via the fragment manager as usual.
 */
public class ConfirmationDialog extends DialogFragment {
    // Do nothing by default
    private Runnable mConfirm = new Runnable() {
        @Override
        public void run() {
        }
    };
    // Do nothing by default
    private Runnable mCancel = new Runnable() {
        @Override
        public void run() {
        }
    };

    public void setArgs(String message) {
        setArgs("" , message);
    }

    public void setArgs(String title, String message) {
        Bundle args = new Bundle();
        args.putString("message", message);
        args.putString("title", title);
        setArguments(args);
    }

    public void setConfirm(Runnable confirm) {
        mConfirm = confirm;
    }

    public void setCancel(Runnable cancel) {
        mCancel = cancel;
    }

    @Override
    public MaterialDialog onCreateDialog(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Resources res = getActivity().getResources();
        String title = getArguments().getString("title");
        return new MaterialDialog.Builder(getActivity())
                .title(title.equals("") ? res.getString(R.string.app_name) : title)
                .content(getArguments().getString("message"))
                .positiveText(res.getString(R.string.dialog_ok))
                .negativeText(res.getString(R.string.dialog_cancel))
                .callback(new MaterialDialog.ButtonCallback() {
                    @Override
                    public void onPositive(MaterialDialog dialog) {
                        mConfirm.run();
                    }

                    @Override
                    public void onNegative(MaterialDialog dialog) {
                        mCancel.run();
                    }
                })
                .show();
    }
}

Secondly, you should make a common method in your Activity which shows a DialogFragment using the fragment manager:

/**
 * Global method to show dialog fragment
 * @param newFragment  the DialogFragment you want to show
 */
public void showDialogFragment(DialogFragment newFragment) {
    // DialogFragment.show() will take care of adding the fragment
    // in a transaction. We also want to remove any currently showing
    // dialog, so make our own transaction and take care of that here.
    FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
    Fragment prev = getSupportFragmentManager().findFragmentByTag("dialog");
    if (prev != null) {
        ft.remove(prev);
    }
    // save transaction to the back stack
    ft.addToBackStack("dialog");
    newFragment.show(ft, "dialog");
}

Then you can show a confirmation dialog from anywhere in your Activity like this:

ConfirmationDialog dialog = new ConfirmationDialog ();
dialog.setArgs(stringDialogTitle, stringDialogMessage);
Runnable confirm = new Runnable() {
    @Override
    public void run() {
        doStuff();
    }
};
dialog.setConfirm(confirm);
showDialogFragment(dialog);

If you have Java8 you can use lambdas for the functions which will make the code much less verbose. See here for an example.