对话框/ AlertDialogs：如何在对话框启动时“阻止执行”（.NET样式）

来自.NET环境，我现在想了解Dialogs如何在Android中工作。

在.NET中，调用时MessageBox.Show(...)会创建并显示一个弹出对话框。在对Show的调用中，我可以指定在弹出窗口中应该使用哪些按钮，例如：

DialogResult myDialogResult = MessageBox.Show("My text here", "My caption here", MessageBoxButtons.YesNoCancel);

如您所见，当在弹出窗口中按下按钮时，对Show的调用将返回DialogResult，通知我单击了哪个按钮。请注意，在.NET中，执行将在Show(...)对它进行调用的行处暂停，因此在按下按钮时它可以返回值。

如果我在上面的示例中按“否”，则myDialogResult将等于

myDialogResult == DialogResult.No

由于我发现使用/创建弹出窗口的.NET方法非常简单直观，因此我也希望在Android中使用这种创建弹出窗口的方法。

因此，问题是，是否有人知道如何像一样“暂停执行” MessageBox.Show，然后每当按下Button（然后对话框消失）时返回一个值？

编辑1

要更清楚一点：

我需要暂停执行并等待，直到用户选择了一个按钮以单击弹出窗口。调用后显示对话框的代码取决于在对话框中单击的按钮。

这就是为什么我不能使用Erich和Alex的建议的原因，因为按照下面的建议在onClick方法中编写代码是行不通的。原因是我无法继续执行“正常执行”。让我举个例子：

让我举个例子：

int nextStep = 0; // this variable will not be reached from within the onClick-methods

AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setMessage("Hello!")
       .setPositiveButton("Ok", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int id) {
                nextStep = 1; // *** COMPILER ERROR!! ***
            }
        })
        .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int id) {
                nextStep = 2; // *** COMPILER ERROR!! ***
            }
        })
        .create().show();

if (nextStep == 1)
{
    // then do some damage
}
else if (nextStep == 2
    // dont do damage

如果我希望执行依赖于弹出窗口中的选择，那么我将不得不以某种方式使nextSteponClick方法中的“正常执行”（在本例中为）中的所有变量可用，这对我来说听起来像是“地狱”。

编辑2

另一个明显的示例是弹出窗口，询问“您是否要继续”，并带有选项“是”和“否”。

如果用户按下“是”，则应中止整个方法，否则应继续执行。您如何很好地解决呢？

泰德（Ted），您实际上并不想这样做：)最大的原因是，如果在显示Dialog时阻塞UI线程，则会阻塞负责绘制和处理Dialog事件的线程。这意味着您的对话框将无响应。如果用户花费超过几秒钟的时间单击对话框，您还将导致ANR。

Erich的答案正是您所需要的。我知道这不是您想要的，但这没关系。我们设计Android的目的是防止开发人员编写同步对话框，因此您实际上没有太多选择。

在Android中，结构与.NET不同：

AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setMessage("Hello!")
       .setPositiveButton("Ok", new DialogInterface.OnClickListener() {
           public void onClick(DialogInterface dialog, int id) {
               // Handle Ok
           }
       })
       .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
           public void onClick(DialogInterface dialog, int id) {
               // Handle Cancel
           }
       })
       .create();

将为您提供带有两个按钮的对话框，并通过回调处理按钮单击。您可能可以编写一些代码来使语法更类似于.NET，但是对话框的生命周期与缠绕在一起Activity，因此，最后，麻烦可能超过其价值。其他对话框参考在这里。

丹尼尔答案的简化版。此功能在警报对话框中从用户获得是或否，但可以轻松修改以获取其他输入。

private boolean mResult;
public boolean getYesNoWithExecutionStop(String title, String message, Context context) {
    // make a handler that throws a runtime exception when a message is received
    final Handler handler = new Handler() {
        @Override
        public void handleMessage(Message mesg) {
            throw new RuntimeException();
        } 
    };

    // make a text input dialog and show it
    AlertDialog.Builder alert = new AlertDialog.Builder(context);
    alert.setTitle(title);
    alert.setMessage(message);
    alert.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int whichButton) {
            mResult = true;
            handler.sendMessage(handler.obtainMessage());
        }
    });
    alert.setNegativeButton("No", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int whichButton) {
            mResult = false;
            handler.sendMessage(handler.obtainMessage());
        }
    });
    alert.show();

    // loop till a runtime exception is triggered.
    try { Looper.loop(); }
    catch(RuntimeException e2) {}

    return mResult;
}

在Android中，对话框是异步的，因此您将不得不对代码进行一些不同的构造。

因此，在C＃中，您的逻辑在伪代码中运行了以下内容：

void doSomeStuff() {
    int result = showDialog("Pick Yes or No");

    if (result == YES) {
        //do stuff for yes
    }
    else if (result == NO) {
        //do stuff for no
    }

    //finish off here
}

对于Android，它将必须不那么整洁。这样想吧。您将拥有一个OnClickListener这样的：

public void onClick(DialogInterface dialog, int whichButton) {
   if (whichButton == BUTTON_POSITIVE) {
      doOptionYes();
   }
   else if (whichButton == BUTTON_NEGATIVE) {
      doOptionNo();
   }
}

然后由以下方法支持：

void doOptionYes() {
    //do stuff for yes
    endThings();
}

void doOptionNo() {
    //do stuff for no
    endThings();
}

void endThings() {
    //clean up here
}

所以现在一种方法是四种。它可能看起来不那么整洁，但是恐怕就是这样。

PasswordDialog dlg = new PasswordDialog(this);

if(dlg.showDialog() == DialogResult.OK)

{

    //blabla, anything your self

}


public class PasswordDialog extends Dialog
{
    int dialogResult;
    Handler mHandler ;

    public PasswordDialog(Activity context, String mailName, boolean retry)
    {

        super(context);
        setOwnerActivity(context);
        onCreate();
        TextView promptLbl = (TextView) findViewById(R.id.promptLbl);
        promptLbl.setText("Input password/n" + mailName);
    }
    public int getDialogResult()
    {
        return dialogResult;
    }
    public void setDialogResult(int dialogResult)
    {
        this.dialogResult = dialogResult;
    }
    /** Called when the activity is first created. */

    public void onCreate() {
        setContentView(R.layout.password_dialog);
        findViewById(R.id.cancelBtn).setOnClickListener(new android.view.View.OnClickListener() {

            @Override
            public void onClick(View paramView)
            {
                endDialog(DialogResult.CANCEL);
            }
            });
        findViewById(R.id.okBtn).setOnClickListener(new android.view.View.OnClickListener() {

            @Override
            public void onClick(View paramView)
            {
                endDialog(DialogResult.OK);
            }
            });
        }

    public void endDialog(int result)
    {
        dismiss();
        setDialogResult(result);
        Message m = mHandler.obtainMessage();
        mHandler.sendMessage(m);
    }

    public int showDialog()
    {
        mHandler = new Handler() {
            @Override
              public void handleMessage(Message mesg) {
                  // process incoming messages here
                //super.handleMessage(msg);
                throw new RuntimeException();
              }
          };
        super.show();
        try {
            Looper.getMainLooper().loop();
        }
        catch(RuntimeException e2)
        {
        }
        return dialogResult;
    }

}

为了优化内存和性能，Android中的对话框是异步的（因此也要对其进行管理）。来自Windows世界，您习惯于模式对话框。Android对话是模态的，但执行时更像是非模态的。显示对话框后执行不会停止。

我所见过的关于Dialogs的最佳描述是在“ Pro Android”中http://www.apress.com/book/view/1430215968

这不是一个完美的解释，但是它应该可以帮助您围绕Windows和Android中的Dialogs之间的差异进行思考。在Windows中，您想执行A，向对话框提问，然后执行B或C。在android设计A中，对话框的OnClickListener的onClick（）中包含B和C所需的所有代码。然后执行A并启动对话框。您已经完成A！当用户单击按钮B或C将被执行。

Windows
-------
A code
launch dialog
user picks B or C
B or C code
done!

Android
-------
OnClick for B code (does not get executed yet)
OnClick for C code (does not get executed yet)
A code
launch dialog
done!
user picks B or C

不幸的是，Android和iOS的开发人员认为它们足够强大和聪明，可以拒绝“模态对话框”的概念（该模型已经在市场上销售了很多年，之前从未有人打扰过）。我相信可以解决Android问题-因为您可以使用Runnable类从非UI线程显示对话框，所以应该有一种方法可以在该线程（非UI）中等待对话框完成。

编辑：这是我的解决方案，效果很好：

    int pressedButtonID;
    private final Semaphore dialogSemaphore = new Semaphore(0, true);
    final Runnable mMyDialog = new Runnable()
    {
        public void run()
        {
            AlertDialog errorDialog = new AlertDialog.Builder( [your activity object here] ).create();
            errorDialog.setMessage("My dialog!");
            errorDialog.setButton("My Button1", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    pressedButtonID = MY_BUTTON_ID1;
                    dialogSemaphore.release();
                    }
                });
            errorDialog.setButton2("My Button2", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    pressedButtonID = MY_BUTTON_ID2;
                    dialogSemaphore.release();
                    }
                });
            errorDialog.setCancelable(false);
            errorDialog.show();
        }
    };

    public int ShowMyModalDialog()  //should be called from non-UI thread
    {
        pressedButtonID = MY_BUTTON_INVALID_ID;
        runOnUiThread(mMyDialog);
        try
        {
            dialogSemaphore.acquire();
        }
        catch (InterruptedException e)
        {
        }
        return pressedButtonID;
    }

泰德（Ted），您可能已经发现，很不幸，您无法在Android上做到这一点。对话框是模态的，但是是异步的，它肯定会破坏您要尝试建立的顺序，就像在.NET（或Windows）上一样。您将不得不扭曲您的代码并破坏一些逻辑，这些逻辑根据您的示例将非常容易遵循。

另一个非常简单的示例是将数据保存在文件中，只是发现该文件已经存在并且要求覆盖它。无需显示对话框并让if语句对结果起作用（是/否），您将必须使用回调（在Java中称为侦听器）并将逻辑拆分为多个函数。

在Windows上，当显示对话框时，消息泵将在后台继续（仅当前正在处理的消息处于保留状态），并且工作正常。例如，这使用户可以在显示对话框时移动您的应用程序并重新绘制。WinMo支持同步模式对话框，BlackBerry也支持，但Android不支持。

最干净，最简单的解决方案是使用您自己的侦听器界面，以便当用户单击ok按钮时，将使用返回值调用侦听器。此方法没有花哨或复杂的操作，并且遵守android原则。

定义您的侦听器接口，如下所示：

public interface EditListener
/* Used to get an integer return value from a dialog
 * 
 */
{
 void returnValue(int value); 
}

对于我的应用程序，我创建了一个EditValue类，该类使用AlertDialog并在我想编辑整数值时调用。注意如何将EditListener接口作为参数传递给此代码。当用户单击“确定”按钮时，该值将通过EditListener方法返回到您的调用代码：

public final class EditValue
/* Used to edit a value using an alert dialog
 * The edited value is returned via the returnValue method of the supplied EditListener             interface
 * Could be modified with different constructors to edit double/float etc
 */
{
 public EditValue(final Activity parent, int value, String title, String message,
                  final EditListener editListener)
 {AlertDialog.Builder alert= new AlertDialog.Builder(parent);
  if(title==null) title= message;
  else if(message==null) message= title;
  if(title!=null) alert.setTitle(title);
  if(message!=null) alert.setMessage(message);

  // Set an EditText view to get user input 
  final EditText input = new EditText(parent);
  input.setText(String.valueOf(value));
  input.setInputType(InputType.TYPE_CLASS_NUMBER);
  alert.setView(input);

  alert.setPositiveButton("OK",new DialogInterface.OnClickListener()
  {public void onClick(DialogInterface dialog, int which)
   {try
    {int newValue= Integer.valueOf(input.getText().toString());
     editListener.returnValue(newValue);
     dialog.dismiss();
    }catch(NumberFormatException err) { }
   }
  });

  alert.setNegativeButton("Cancel", new DialogInterface.OnClickListener()
  {public void onClick(DialogInterface dialog, int which)
   {dialog.dismiss();
    }
  });

  alert.show();
 }
}

最后，当您使用EditValue时，需要声明您的EditListener，现在您可以访问返回值并执行您想做的事情：

 new EditValue(main,AnchorManager.anchorageLimit,
               main.res.getString(R.string.config_anchorage_limit),null,
               new EditListener()
 {public void returnValue(int value) {AnchorManager.anchorageLimit= value;}
  }
 );

使用android.app.Dialog.setOnDismissListener（OnDismissListener监听器）。

我是Android / Java世界的新手，很惊讶地在这里发现模式对话框不起作用（除非我不明白我所读的内容）。由于目前出于某些非常晦涩的原因，我得到了一个带有ok按钮的“ ShowMessage”等效项，该按钮可以以非常模块化的方式在平板电脑上使用。

在我的TDialogs.java模块中：

class DialogMes 
{

  AlertDialog alertDialog ;
  private final Message NO_HANDLER = null;
  public DialogMes(Activity parent,String aTitle, String mes)
  {
    alertDialog = new AlertDialog.Builder(parent).create();
    alertDialog.setTitle(aTitle);    
    alertDialog.setMessage(mes) ;  
    alertDialog.setButton("OK",NO_HANDLER) ;    
    alertDialog.show() ; 
  } 
}

这是测试代码的一部分：

public class TestDialogsActivity extends Activity implements DlgConfirmEvent
{

   @Override
  public void onCreate(Bundle savedInstanceState)
  {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    Button btShowMessage = (Button) findViewById(R.id.btShowMessage);
    btShowMessage.setOnClickListener(new View.OnClickListener() {
      public void onClick(View view) 
      {
        DialogMes dlgMes = new DialogMes( TestDialogsActivity.this,"Message","life is good") ;                
      }  
    }); 

按照上面JohnnyBeGood建议的界面方法，我还实现了一个模态的“是/否”对话框，它也很好用。

更正：

我的答案与我误解的问题无关。由于某种原因，我将罗曼·盖伊（M. Romain Guy）的“您不想这样做”解释为对模态对话框的否定。我应该读过：“您不想这样做……”。

我道歉。

改写：

移动和桌面环境之间以及数年前和今天的应用程序开发方式之间存在根本差异：

a）移动设备需要节约能源。他们提供的部分价值。因此，您需要节省资源。线程是一种昂贵的资源。暂停线程的进度是对这种资源的不可接受的浪费。

b）如今，用户要求更高。为了帮助他们，我们认为应该拥有完整的工作CPU和尽可能少的能源消耗。它的应用程序并不仅仅存在于设备上，同时还有数量不详的其他应用程序正在运行，您的应用程序不一定是最紧迫的。

c）不能选择系统级锁定：移动设备在后台处理许多事件和服务，并且不正确，因为任何事件和服务都可以被应用程序锁定。

考虑一下您的“系统锁定”正在工作时用户接听电话的情况...

基于以上事实，对所提问题的答案为：

• 有一种可行的方法来建立一个对话框，该对话框阻止主线程，直到用户做出响应为止？

不能。解决方法会使用户体验变得更糟，并且可能会犯错归咎于系统本身。这是不公平的，并会惩罚平台及其所有开发人员。

• 有没有办法通过对话阻止整个系统？

否。平台上严禁这样做。任何应用程序都不会干扰系统或其他应用程序的运行。

• 我需要重构我的应用程序，或者重新考虑我的编程方式以适合我在Android移动系统架构上的需求。

是。包括这方面。

您可以将onclick侦听器设置为按钮。对话对话框，然后执行您的操作。不需要停止任何事情

protected Dialog onCreateDialog(int id) {
  return new AlertDialog.Builder(this).setTitle(R.string.no_connection).setIcon(android.R.drawable.ic_dialog_alert).setView(textEntryView).setPositiveButton(R.string.exit, new DialogInterface.OnClickListener() 
{

   public void onClick(DialogInterface dialog, int whichButton) {

  // Here goes what you want to do
  }

})
}

致电-​​例如-showDialog（DIALOG_ERROR_PREF）;

更多 http://developer.android.com/guide/topics/ui/dialogs.html

只是回答您的问题...对不起，我迟到了9个月：D ...有一种“解决方法” 4这种问题。即

new AlertDialog.Builder(some_class.this).setTitle("bla").setMessage("bla bla").show();
wait();

只需添加等待（）;

然后他们在OnClickListener中使用notify（）再次启动此类

@Override
    public void onClick(DialogInterface dialog, int item) {
        Toast.makeText(getApplicationContext(), "test", Toast.LENGTH_LONG).show();
        **notify**();
        dialog.cancel();
    }

相同的解决方法在Android中进行了4次Toast和其他异步调用

在线程（而不是UI线程）中尝试以下操作：

final CountDownLatch latch = new CountDownLatch(1);
handler.post(new Runnable() {
  @Override
  public void run() {
    OnClickListener okListener = new OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
      dialog.dismiss();
      latch.countDown();
    }
  };

  AlertDialog dialog = new AlertDialog.Builder(context).setTitle(title)
    .setMessage(msg).setPositiveButton("OK", okListener).create();
  dialog.show();
}
});
try {
  latch.await();
} catch (InterruptedException e) {
  e.printStackTrace();
}

UserSelect =null

AlertDialog.Builder builder = new Builder(ImonaAndroidApp.LoginScreen);
            builder.setMessage("you message");
            builder.setPositiveButton("OK", new OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int which) {
                    UserSelect = true ;

                }
            });

            builder.setNegativeButton("Cancel", new OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int which) {
                    UserSelect = false ;

                }
            });
           // in UI thread
        builder.show();             
        // wait until the user select
            while(UserSelect ==null);

我正在使用Xamarin.Android（MonoDroid），并且我有开发UI阻止确认框的要求。我不会与客户争执，因为我可以看到他们为什么要这样做的充分理由（此处有详细信息），因此我需要实现这一点。我在上面尝试了@Daniel和@MindSpiker，但是它们在MonoForAndroid上不起作用，当消息在线程之间发送时，应用程序崩溃了。我认为这与Xamarin映射有关。

我最终从UI线程创建了一个单独的线程，然后阻止该线程并等待用户响应，如下所示：

// (since the controllers code is shared cross-platforms)
protected void RunConfirmAction(Action runnableAction)
{
    if (runnableAction != null)
    {
        if (Core.Platform.IsAndroid)
        {
            var confirmThread = new Thread(() => runnableAction());
            confirmThread.Start();
        }
        else
        {
            runnableAction();
        }
    }
}

// The call to the logout method has now changed like this:
RunConfirmAction(Logout);

// the implemtation of the MessageBox waiting is like this:
public DialogResult MessageBoxShow(string message, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, MessageBoxDefaultButton defaultButton)
{
    if (_CurrentContext != null && _CurrentContext.Screen != null && MainForm.MainActivity != null)
    {
        Action<bool> callback = OnConfirmCallBack;
        _IsCurrentlyInConfirmProcess = true;
        Action messageBoxDelegate = () => MessageBox.Show(((Activity)MainForm.MainActivity), callback, message, caption, buttons);
        RunOnMainUiThread(messageBoxDelegate);
        while (_IsCurrentlyInConfirmProcess)
        {
            Thread.Sleep(1000);
        }               
    }
    else
    {
        LogHandler.LogError("Trying to display a Message box with no activity in the CurrentContext. Message was: " + message);
    }
    return _ConfirmBoxResult ? DialogResult.OK : DialogResult.No;

}

private void OnConfirmCallBack(bool confirmResult)
{
    _ConfirmBoxResult = confirmResult;
    _IsCurrentlyInConfirmProcess = false;
}

private bool _ConfirmBoxResult = false;
private bool _IsCurrentlyInConfirmProcess = false;

有关如何执行此操作的完整详细信息，请参见我的博客文章。

让我向StackOverflow社区表示感谢，并与您分享一些美好的东西，在该示例中，我在Android代码中将上述示例用于HTTP调用，该示例现在变为MODAL，而不是通常的额外线程以及使用合并线程的复杂性有点奇怪的线程。（目前正在我们的应用程序中运行-2020年10月15日）

public JSONArray genericHttpModal(Context context, final String url, final JSONObject request) {

    this.url = url;    
    genericHttpRequestQueue = Volley.newRequestQueue(context);      
    class MyJsonReturn {
        JSONArray returnJsonArray;

        public void set(JSONArray i) {
            returnJsonArray = i;
        }

        public void set(String i) {
            try {
                returnJsonArray.put(0, i);
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }

        public JSONArray get() {
            return returnJsonArray;
        }
    }

    final MyJsonReturn mymy = new MyJsonReturn();

    // Positive Response / HTTP OK.
    final Handler handler = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            throw new RuntimeException();
        }
    };

    final Response.Listener responseListener = new Response.Listener<String>() {
        @Override
        public void onResponse(String response) {
            try {
                mymy.set(new JSONArray(response));
            } catch (JSONException e) {
                mymy.set("[{\"JSONException:\"" + e.getMessage() + "\"}]");
            }
            handler.sendMessage(handler.obtainMessage());
        }
    };

    // Negative Response / HTTP NOT OK
    final Response.ErrorListener errorListener = new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            result = "fail";

            try {
                mymy.set(new JSONArray("[{\"JSONException:\"" + result + "\"}]"));
            } catch (JSONException e) {
                mymy.set("[{\"JSONException:\"" + e.getMessage() + "\"}]");
            }
            handler.sendMessage(handler.obtainMessage());
        }
    };


    final StringRequest httpRequest = new StringRequest(Request.Method.POST, URL_POINTER + url,
            responseListener,
            errorListener) {

        // Here the mRequestQueue handler will get the parameters for this request here.
        // Ref: /programming/33573803/how-to-send-a-post-request-using-volley-with-string-body#33578202
        // Ref: Multi Threaded solution 14 Oct 2020 (David Svarrer) : /programming/2028697/dialogs-alertdialogs-how-to-block-execution-while-dialog-is-up-net-style (This stackoverflow here)
        @Override
        protected java.util.Map<String, String> getParams() throws AuthFailureError {
            return jsonObjectToMap(request);
        }
    };
    httpRequest.setShouldCache(false); // Elijah: Could work on dropping the cache !!!
    genericHttpRequestQueue.add(httpRequest);    

    try {
        Looper.loop();
    } catch (RuntimeException re) {
    }
    return mymy.get();
}

这是最简单的方法：

new AlertDialog.Builder(this).setTitle("title").setMessage("message").create().show();