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

Question

I'm trying to find the way to reuse a Dialog that shows customized titles, then send the Yes/No click to the function that has launched the Dialog.

I have two buttoms, Save and Dismiss, and both call a Yes/No Dialog, one showing "Do you want to save" and the other "Dismiss changes?".

I think my procedure is very "dirty" but I guess it can work, but my problem is the "View view" variable, I don't know how to pass it from the Activity to the Dialog, so I can use it to recall the function that launched the Dialog.

Thanks in advance, HerniHdez

.java of my activity (fragment of it)

public void open_HH_Fragment_YesNo(View view, String aux_title, String aux_function)
{
    Bundle bundle=new Bundle();
    bundle.putString("setMessage", aux_title);
    bundle.putString("callingFunction", aux_function);

    DialogFragment newFragment = new HH_Fragment_YesNo();
    newFragment.setArguments(bundle);
    newFragment.show(getSupportFragmentManager(), "HH_Fragment_YesNo");
}

public void SaveChanges(View view, String aux_YesNo)
{
    if (aux_YesNo == "")
    {
        Toast.makeText(this, "Save changes?", Toast.LENGTH_SHORT).show();
        open_HH_Fragment_YesNo(view, "Save changes?", "SaveChanges");
    }
    else if (aux_YesNo == "Yes")
    {
        Toast.makeText(this, "Saving changes", Toast.LENGTH_SHORT).show();
    }
    else if (aux_YesNo == "No")
    {
        Toast.makeText(this, "Save Cancelled", Toast.LENGTH_SHORT).show();
    }
}

public void DismissChanges(View view, String aux_YesNo)
{
    if (aux_YesNo == "")
    {
        Toast.makeText(this, "Dismiss changes?", Toast.LENGTH_SHORT).show();
        open_HH_Fragment_YesNo(view, "Dismiss changes?", "DismissChanges");
    }
    else if (aux_YesNo == "Yes")
    {
        Toast.makeText(this, "Dismiss OK", Toast.LENGTH_SHORT).show();
        Close(view);
    }
    else if (aux_YesNo == "No")
    {
        Toast.makeText(this, "Dismiss Cancelled", Toast.LENGTH_SHORT).show();
    }
}

// The dialog fragment receives a reference to this Activity through the
// Fragment.onAttach() callback, which it uses to call the following methods
// defined by the HH_Fragment_YesNo.YesNoDialogListener interface
@Override
public void onDialogPositiveClick(DialogFragment dialog, View view, String aux_function)
{
    // User touched the dialog's positive button
    Toast.makeText(this, "User clicked on Yes", Toast.LENGTH_SHORT).show();

    if (aux_function == "SaveChanges")
    {
        SaveChanges(view, "Yes");
    }
    else if (aux_function == "DismissChanges")
    {
        DismissChanges(view, "Yes");
    }
}

@Override
public void onDialogNegativeClick(DialogFragment dialog, View view, String aux_function)
{
    Toast.makeText(this, "User clicked on NO", Toast.LENGTH_SHORT).show();

    if (aux_function == "SaveChanges")
    {
        SaveChanges(view, "No");
    }
    else if (aux_function == "DismissChanges")
    {
        DismissChanges(view, "No");
    }
}

.java of my Dialog (complete)

public class HH_Fragment_YesNo extends DialogFragment
{
    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState)
    {
    // Use the Builder class for convenient dialog construction
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    String setMessage = getArguments().getString("setMessage");
    final String callingFunction = getArguments().getString("callingFuntion");

    builder
        .setMessage(setMessage)                                             // R.string.dialog_fire_missiles
        .setPositiveButton("Sí", new DialogInterface.OnClickListener()      // R.string.fire
        {
            public void onClick(DialogInterface dialog, int id)
            {
                // Exit without saving
                mListener.onDialogPositiveClick(HH_Fragment_YesNo.this, view, callingFunction);
            }
        })
        .setNegativeButton("No", new DialogInterface.OnClickListener()      // R.string.cancel
        {
            public void onClick(DialogInterface dialog, int id)
            {
                // User cancelled the dialog
                mListener.onDialogNegativeClick(HH_Fragment_YesNo.this, view, callingFunction);
            }
        });

    // Create the AlertDialog object and return it
    return builder.create();
}


/* The activity that creates an instance of this dialog fragment must
 * implement this interface in order to receive event callbacks.
 * Each method passes the DialogFragment in case the host needs to query it. */
public interface YesNoDialogListener
{
    public void onDialogPositiveClick(DialogFragment dialog, View view, String aux_Function);
    public void onDialogNegativeClick(DialogFragment dialog, View view, String aux_Function);
}


// Use this instance of the interface to deliver action events
YesNoDialogListener mListener;


// Override the Fragment.onAttach() method to instantiate the NoticeDialogListener
@Override
public void onAttach(Activity activity)
{
    super.onAttach(activity);
    // Verify that the host activity implements the callback interface
    try
    {
        // Instantiate the NoticeDialogListener so we can send events to the host
        mListener = (YesNoDialogListener) activity;
    }
    catch (ClassCastException e)
    {
        // The activity doesn't implement the interface, throw exception
        throw new ClassCastException(activity.toString() + " must implement NoticeDialogListener");
    }
}
}

Answer 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) {

                    }
                });

Answer 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.