Tôi làm cách nào để có thể sử dụng lại AlertDialog cho Có/Không trên Android?

Question

Tôi đang cố gắng tìm cách sử dụng lại Hộp thoại hiển thị tiêu đề tùy chỉnh, sau đó gửi Có/Không nhấp vào chức năng đã khởi chạy Hộp thoại.

Tôi có hai phần phụ, Lưu và Loại bỏ, và cả hai đều gọi một Có/Không Dialog, một hiển thị "Bạn có muốn lưu" và "Loại bỏ thay đổi" không?

Tôi nghĩ quy trình của tôi rất "bẩn" nhưng tôi đoán nó có thể hoạt động, nhưng vấn đề của tôi là biến "Chế độ xem chế độ xem", tôi không biết cách chuyển nó từ Hoạt động sang Hộp thoại, vì vậy tôi có thể sử dụng nó để gọi lại hàm đã khởi chạy Hộp thoại.

Cảm ơn trước, HerniHdez

java hoạt động của tôi (mảnh vỡ của nó)

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 của Dialog của tôi (hoàn thành)

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

Giải pháp hoàn thành Hãy thử điều này

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) Khái quát phương pháp cho hộp thoại xác nhận.

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) Làm thế nào để sử dụng

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

Từ trang này là hit đầu tiên trên Google, và nó có vẻ như một nhiệm vụ chung như vậy với rất ít viết về nó, tôi sẽ chia sẻ cách tôi đã tìm thấy để có thể sử dụng lại DialogFragment.

Sử dụng giao diện sẽ thực sự lộn xộn nếu bạn muốn sử dụng lại cùng một Hộp thoại nhiều lần từ cùng một lớp, nhưng thực hiện một hành động khác nhau mọi lúc. Giải pháp này là một cách đơn giản và thẳng tiến để giải quyết vấn đề đó mà không đưa ra bất kỳ nhược điểm nào.

Sửa 2017/02/25: Câu trả lời này trước đây được sử dụng một lớp trừu tượng để thực hiện xác nhận() và hủy bỏ(), phiên bản tuy nhiên mới của Android sẽ sụp đổ với các lỗi sau đây nếu bạn cố gắng sử dụng một lớp vô danh như một DialogFragment:

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

vì vậy tôi đã sửa đổi các giải pháp để sử dụng Runnables, mà làm việc thật sự tốt đẹp trong Java8 mà còn là khả thi mà không có nó

Đầu tiên, tạo một lớp mà thực hiện việc tạo ra các Dialog bản thân:

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

Thứ hai, bạn nên thực hiện một phương pháp phổ biến trong Activity của bạn trong đó cho thấy một DialogFragment bằng trình quản lý đoạn:

/** 
* 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"); 
} 

Sau đó, bạn có thể hiển thị hộp thoại xác nhận từ bất kỳ đâu trong số Activity như sau:

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

Nếu bạn có Java8, bạn có thể sử dụng lambdas cho các chức năng mà sẽ làm cho mã ít tiết hơn. Xem here để biết ví dụ.