Question

这些天我正在研究在Android中模拟模态对话框。我已经搜索了很多，有很多讨论，但遗憾的是没有太多的选择来获得模态。这是一些背景，
Dialogs, Modal Dialogs and Blockin
Dialogs / AlertDialogs: How to "block execution" while dialog is up (.NET-style)

没有直接的方式来获得模态行为，然后我提出了3种可能的解决方案，
1.使用对话主题活动，如thread所述，但我仍然无法使主要活动真正等待对话活动返回。主要活动转为停止状态，然后重新启动。
2.构建一个工作线程，并使用线程同步。但是，这对我的应用程序来说是一个巨大的重构工作，现在我在主UI线程中有一个主要活动和服务。
3.当存在模态对话框时，在循环内接管事件处理，并在对话框关闭时退出循环。实际上，这是构建一个真正的模态对话框的方式，就像它在Windows中的确切做法一样。我还没有这样的原型。

我还是想用一个以对话为主题的活动来模拟它，
1.通过startActivityForResult（）开始对话活动 2.从onActivityResult（）获得结果这是一些来源

public class MainActivity extends Activity {

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    MyView v = new MyView(this);
    setContentView(v);
}

private final int RESULT_CODE_ALERT = 1;
private boolean mAlertResult = false;
public boolean startAlertDialog() {
    Intent it = new Intent(this, DialogActivity.class);
    it.putExtra("AlertInfo", "This is an alert");
    startActivityForResult(it, RESULT_CODE_ALERT);

    // I want to wait right here
    return mAlertResult;
}

@Override
protected void onActivityResult (int requestCode, int resultCode, Intent data) {
    switch (requestCode) {
    case RESULT_CODE_ALERT:
        Bundle ret = data.getExtras();
        mAlertResult = ret.getBoolean("AlertResult");
        break;
    }
}
}

startAlertDialog的调用者将阻止执行并期望返回结果。但是当然，startAlertDialog立即返回，当DialogActivity启动时，主要活动进入STOP状态。

所以问题是，如何使主要活动真正等待结果？感谢。

Answer 1

使用时我得到了一个模态对话框：

setCancelable(false);

DialogFragment上的

（不在DialogBuilder上）。

Answer 2

你计划的方式是不可能的。首先，不允许您阻止UI线程。您的申请将被终止。其次，需要处理在使用startActivity启动另一个活动时调用的生命周期方法（在其他活动运行时，您的原始活动将暂停）。第三，您可能通过使用startAlertDialog()而不是来自UI线程，使用线程同步（如Object.wait()）和一些AlertDialog来以某种方式破解它。但是，我强烈鼓励您不要这样做。它很丑陋，肯定会破坏，而事实并非如此。

重新设计您的方法以捕获这些事件的异步性质。如果你想要一些对话框要求用户进行决定（如是否接受ToS）并根据该决定做特殊操作，请创建一个如下对话框：

AlertDialog dialog = new AlertDialog.Builder(context).setMessage(R.string.someText)
                .setPositiveButton(android.R.string.ok, new OnClickListener() {

                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.dismiss();
                        // Do stuff if user accepts
                    }
                }).setNegativeButton(android.R.string.cancel, new OnClickListener() {

                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.dismiss();
                        // Do stuff when user neglects.
                    }
                }).setOnCancelListener(new OnCancelListener() {

                    @Override
                    public void onCancel(DialogInterface dialog) {
                        dialog.dismiss();
                        // Do stuff when cancelled
                    }
                }).create();
dialog.show();

然后有两种方法相应地处理正面或负面反馈（即进行一些操作或完成活动或任何有意义的事情）。

Answer 3

Android和iOS的开发人员认为他们强大而聪明，足以拒绝Modal Dialog概念（这已经在市场上存在很多年了，之前并没有打扰过任何人），不幸的是我们。

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

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

Answer 4

这对我有用：创建一个Activity作为对话框。然后，

将此添加到活动的清单中：

机器人：主题= “@机器人：风格/ Theme.Dialog”
将此添加到活动的onCreate

setFinishOnTouchOutside（false）;
在您的活动中覆盖onBackPressed：

@覆盖 public void onBackPressed（） { //阻止“退回”离开此活动 }

第一个给对话框看的活动。后两者使其表现得像一个模态对话框。

Answer 5

最后，我得到了一个非常直接和简单的解决方案。

熟悉Win32编程的人可能知道如何实现模态对话框。通常，当存在模式对话框时，它会运行嵌套的消息循环（通过GetMessage / PostMessage）。所以，我尝试以这种传统方式实现我自己的模态对话框。

首先，android没有提供接口来注入ui线程消息循环，或者我没有找到一个。当我查看源代码，Looper.loop（）时，我发现它正是我想要的。但是，MessageQueue / Message还没有提供公共接口。幸运的是，我们在java中有反射。基本上，我只是复制了Looper.loop（）所做的，它阻止了工作流程并且仍然正确处理了事件。我没有测试过嵌套的模态对话框，但理论上它可以工作。

这是我的源代码，

public class ModalDialog {

private boolean mChoice = false;        
private boolean mQuitModal = false;     

private Method mMsgQueueNextMethod = null;
private Field mMsgTargetFiled = null;

public ModalDialog() {
}

public void showAlertDialog(Context context, String info) {
    if (!prepareModal()) {
        return;
    }

    // build alert dialog
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setMessage(info);
    builder.setCancelable(false);
    builder.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int id) {
            ModalDialog.this.mQuitModal = true;
            dialog.dismiss();
        }
    });

    AlertDialog alert = builder.create();
    alert.show();

    // run in modal mode
    doModal();
}

public boolean showConfirmDialog(Context context, String info) {
    if (!prepareModal()) {
        return false;
    }

    // reset choice
    mChoice = false;

    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setMessage(info);
    builder.setCancelable(false);
    builder.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int id) {
            ModalDialog.this.mQuitModal = true;
            ModalDialog.this.mChoice = true;
            dialog.dismiss();
        }
    });

    builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int id) {
            ModalDialog.this.mQuitModal = true;
            ModalDialog.this.mChoice = false;
            dialog.cancel();
        }
    });

    AlertDialog alert = builder.create();
    alert.show();

    doModal();
    return mChoice;
}

private boolean prepareModal() {
    Class<?> clsMsgQueue = null;
    Class<?> clsMessage = null;

    try {
        clsMsgQueue = Class.forName("android.os.MessageQueue");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
        return false;
    }

    try {
        clsMessage = Class.forName("android.os.Message");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
        return false;
    }

    try {
        mMsgQueueNextMethod = clsMsgQueue.getDeclaredMethod("next", new Class[]{});
    } catch (SecurityException e) {
        e.printStackTrace();
        return false;
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
        return false;
    }

    mMsgQueueNextMethod.setAccessible(true);

    try {
        mMsgTargetFiled = clsMessage.getDeclaredField("target");
    } catch (SecurityException e) {
        e.printStackTrace();
        return false;
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
        return false;
    }

    mMsgTargetFiled.setAccessible(true);
    return true;
}

private void doModal() {
    mQuitModal = false;

    // get message queue associated with main UI thread
    MessageQueue queue = Looper.myQueue();
    while (!mQuitModal) {
        // call queue.next(), might block
        Message msg = null;
        try {
            msg = (Message)mMsgQueueNextMethod.invoke(queue, new Object[]{});
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        if (null != msg) {
            Handler target = null;
            try {
                target = (Handler)mMsgTargetFiled.get(msg);
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

            if (target == null) {
                // No target is a magic identifier for the quit message.
                mQuitModal = true;
            }

            target.dispatchMessage(msg);
            msg.recycle();
        }
    }
}
}

希望这会有所帮助。

Answer 6

这并不困难。

假设您的活动恢复时，您的所有者活动（名为waiting_for_result）会有一个标记：

public void onResume(){
    if (waiting_for_result) {
        // Start the dialog Activity
    }
}

这保证了所有者活动，除非模态对话框被解除，每当它尝试获得焦点时都会传递给模态对话框活动。

Answer 7

一个解决方案是：

将每个所选按钮的所有代码放入每个按钮的监听器中。
alert.show();必须是调用Alert的函数中的最后一个代码行。此行之后的任何代码都不会等待关闭警报，但会立即执行。

希望帮助！

Answer 8

正如hackbod和其他人所指出的那样，Android故意不提供执行嵌套事件循环的方法。我理解这个的原因，但有些情况需要它们。在我们的例子中，我们有自己的虚拟机在各种平台上运行，我们希望将其移植到Android。在内部有许多需要嵌套事件循环的地方，并且仅仅为Android重写整个事情是不可行的。无论如何，这是一个解决方案（基本上取自How can I do non-blocking events processing on Android?，但我添加了一个超时）：

private class IdleHandler implements MessageQueue.IdleHandler
{
    private Looper _looper;
    private int _timeout;
    protected IdleHandler(Looper looper, int timeout)
    {
        _looper = looper;
        _timeout = timeout;
    }

    public boolean queueIdle()
    {
        _uiEventsHandler = new Handler(_looper);
        if (_timeout > 0)
        {
            _uiEventsHandler.postDelayed(_uiEventsTask, _timeout);
        }
        else
        {
            _uiEventsHandler.post(_uiEventsTask);
        }
        return(false);
    }
};

private boolean _processingEventsf = false;
private Handler _uiEventsHandler = null;

private Runnable _uiEventsTask = new Runnable()
{
    public void run() {
    Looper looper = Looper.myLooper();
    looper.quit();
    _uiEventsHandler.removeCallbacks(this);
    _uiEventsHandler = null;
    }
};

public void processEvents(int timeout)
{
    if (!_processingEventsf)
    {
        Looper looper = Looper.myLooper();
        looper.myQueue().addIdleHandler(new IdleHandler(looper, timeout));
        _processingEventsf = true;
        try
        {
            looper.loop();
        } catch (RuntimeException re)
        {
            // We get an exception when we try to quit the loop.
        }
        _processingEventsf = false;
     }
}

Answer 9

我有一个像fifth这样的类似解决方案，但它有一点点更简单，不需要反思。我的想法是，为什么不呢使用异常退出循环器。所以我的定制looper 内容如下：

1）引发的异常：

final class KillException extends RuntimeException {
}

2）定制活套：

public final class KillLooper implements Runnable {
    private final static KillLooper DEFAULT = new KillLooper();

    private KillLooper() {
    }

    public static void loop() {
        try {
            Looper.loop();
        } catch (KillException x) {
            /* */
        }
    }

    public static void quit(View v) {
        v.post(KillLooper.DEFAULT);
    }

    public void run() {
        throw new KillException();
    }

}

定制活套的使用非常简单。假设你有一个对话框foo，然后只需执行以下操作你想以模态方式调用对话框foo：

a）调用foo时：

foo.show();
KillLooper.loop();

在对话框foo中，当你想要退出时，你就是这么简单调用自定义循环器的退出方法。这看起来如下：

b）退出foo时：

dismiss();
KillLooper.quit(getContentView());

我最近看到5.1.1 Android的一些问题，不要从主菜单调用模态对话框，而是发布调用模态对话框的事件。没有张贴主菜单会停止，我见过Looper :: pollInner（）我的应用程序中的SIGSEGV。

Answer 10

我不确定这是否是100％模态，因为你可以点击其他组件来关闭对话框，但我对循环结构感到困惑，所以我提供了另一种可能性。它对我很有用，所以我想分享这个想法。您可以在一个方法中创建并打开对话框，然后在回调方法中将其关闭，程序将在执行回调方法之前等待对话框回复。如果然后在新线程中运行其余的回调方法，则在执行其余代码之前，对话框也将首先关闭。您唯一需要做的就是拥有一个全局对话框变量，以便不同的方法可以使用它。所以类似下面这样的东西可以工作：

public class MyActivity extends ...
{
    /** Global dialog reference */
    private AlertDialog okDialog;

    /** Show the dialog box */
    public void showDialog(View view) 
    {
        // prepare the alert box
        AlertDialog.Builder alertBox = new AlertDialog.Builder(...);

        ...

        // set a negative/no button and create a listener
        alertBox.setNegativeButton("No", new DialogInterface.OnClickListener() {
            // do something when the button is clicked
            public void onClick(DialogInterface arg0, int arg1) {
                //no reply or do nothing;
            }
        });

        // set a positive/yes button and create a listener
        alertBox.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
            // do something when the button is clicked
            public void onClick(DialogInterface arg0, int arg1) {
                callbackMethod(params);
            }
        });

        //show the dialog
        okDialog = alertBox.create();
        okDialog.show();
    }


    /** The yes reply method */
    private void callbackMethod(params)
    {
        //first statement closes the dialog box
        okDialog.dismiss();

        //the other statements run in a new thread
        new Thread() {
            public void run() {
                try {
                    //statements or even a runOnUiThread
                }
                catch (Exception ex) {
                    ...
                }
            }
        }.start();
    }
}

Answer 11

使用BroadcastReceiver来调用活动中所需的下一个方法。

在dialogFragment.show（fragmentTransaction，TAG）处终止活动代码；并继续在onReceive（）中使用-我不是100％积极，但我会为startActivityForResult（）存钱。正是基于这个概念。

在从接收方调用该方法之前，代码将处于等待用户交互且没有ANR的状态。

DialogFragment的onCreateView方法

private static final String ACTION_CONTINUE = "com.package.name.action_continue";

@Nullable
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, Bundle savedInstanceState) {
    View v = inflater.inflate(R.layout.fragment_dialog, container, false);
        Button ok_button = v.findViewById(R.id.dialog_ok_button);
        ok_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent i = new Intent();
                i.setAction(ACTION_CONTINUE);
                getActivity().getApplicationContext().sendBroadcast(i);
                dismiss();
            }
        });


    return v;
}

此方法取决于构建DialogFrament扩展类并通过活动调用该类的实例。

但是...

简单，清晰，简单而真正的模态。

Android：如何获得模态对话框或类似的模态行为？

11 个答案: