CODEWITHSUNDEEP
c#iphoneipadxamarin.ios
Scarlaxx
Scarlaxx

Reputation: 835

Messagebox.Show and DialogResult equivalent in MonoTouch

I have a Yes/No dialog from UIAlertView with two buttons. I would like in my method to implement the logic similar to this:

if(messagebox.Show() == DialogResult.OK)

The thing is if I call UIAlertView.Show() the process continues. But I need to wait for the result of user interaction and return true or false depanding on clicking the second button. Is this possible in MonoTouch?

Upvotes: 16

Views: 11239

Answers (6)

Ales Suchac
Ales Suchac

Reputation: 1

Here is another update, based on contributions by Miguel, Ales, danmister and Patrick.

Since the release of iOS 11, particularly version 11.1.2 (I first noticed it on this one), the original solution as posted by me (Ales) became unreliable, started to freeze randomly. This one utilizes explicitly invoked NSRunLoop.Current.RunUntil().

So I updated my original class to actually offer both sync and async methods and did a few other changes in order to free up the memory immediately after any button is clicked, also added code which aligns the text to the left if Windows CRLF line breaks are detected.

Namespaces:

using System;
using CoreGraphics;
using UIKit;
using Foundation;
using System.Collections.Generic;
using System.Threading.Tasks;

Code:

public enum MessageBoxResult
{
    None = 0,
    OK,
    Cancel,
    Yes,
    No
}

public enum MessageBoxButton
{
    OK = 0,
    OKCancel,
    YesNo,
    YesNoCancel
}

public static class MessageBox
{
    /* This class emulates Windows style modal boxes. Unfortunately, the original code doesn't work reliably since cca iOS 11.1.2 so 
     * you have to use the asynchronous methods provided here.
     * 
     * The code was a bit restructured utilising class MessageBoxNonstatic to make sure that on repeated use, it doesn't allocate momere memory.
     * Note that event handlers are explicitly removed and at the end I explicitly call garbage collector.
     * 
     * The code is a bit verbose to make it easier to understand and open it to tweaks.
     * 
    */


    // Synchronous methods - don't work well since iOS 11.1.2, often freeze because something has changed in the event loop and
    // NSRunLoop.Current.RunUntil() is not reliable to use anymore
    public static MessageBoxResult Show(string messageBoxText, string caption, MessageBoxButton buttonType)
    {
        MessageBoxNonstatic box = new MessageBoxNonstatic();
        return box.Show(messageBoxText, caption, buttonType);
    }

    public static MessageBoxResult Show(string messageBoxText)
    {
        return Show(messageBoxText, "", MessageBoxButton.OK);
    }

    public static MessageBoxResult Show(string messageBoxText, string caption)
    {
        return Show(messageBoxText, caption, MessageBoxButton.OK);
    }

    // Asynchronous methods - use with await keyword. Restructure the calling code tho accomodate async calling patterns
    // See https://learn.microsoft.com/en-us/dotnet/csharp/async
    /*
     async void DecideOnQuestion()
     {
         if (await MessageBox.ShowAsync("Proceed?", "DECIDE!", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
         {
             // Do something
         }
     }
     */
    public static Task<MessageBoxResult> ShowAsync(string messageBoxText, string caption, MessageBoxButton buttonType)
    {
        MessageBoxNonstatic box = new MessageBoxNonstatic();
        return box.ShowAsync(messageBoxText, caption, buttonType);
    }

    public static Task<MessageBoxResult> ShowAsync(string messageBoxText)
    {
        return ShowAsync(messageBoxText, "", MessageBoxButton.OK);
    }

    public static Task<MessageBoxResult> ShowAsync(string messageBoxText, string caption)
    {
        return ShowAsync(messageBoxText, caption, MessageBoxButton.OK);
    }
}

public class MessageBoxNonstatic
{
    private bool IsDisplayed = false;
    private int buttonClicked = -1;
    private UIAlertView alert = null;

    private string messageBoxText = "";
    private string caption = "";
    private MessageBoxButton button = MessageBoxButton.OK;

    public bool IsAsync = false;
    TaskCompletionSource<MessageBoxResult> tsc = null;

    public MessageBoxNonstatic()
    {
        // Do nothing
    }

    public MessageBoxResult Show(string sMessageBoxText, string sCaption, MessageBoxButton eButtonType)
    {
        messageBoxText = sMessageBoxText;
        caption = sCaption;
        button = eButtonType;
        IsAsync = false;

        ShowAlertBox();
        WaitInLoopWhileDisplayed();
        return GetResult();
    }

    public Task<MessageBoxResult> ShowAsync(string sMessageBoxText, string sCaption, MessageBoxButton eButtonType)
    {
        messageBoxText = sMessageBoxText;
        caption = sCaption;
        button = eButtonType;
        IsAsync = true;

        tsc = new TaskCompletionSource<MessageBoxResult>();
        ShowAlertBox();
        return tsc.Task;
    }

    private void ShowAlertBox()
    {
        IsDisplayed = false;
        buttonClicked = -1;
        alert = null;

        string cancelButton = "Cancel";
        string[] otherButtons = null;

        switch (button)
        {
            case MessageBoxButton.OK:
                cancelButton = "";
                otherButtons = new string[1];
                otherButtons[0] = "OK";
                break;

            case MessageBoxButton.OKCancel:
                otherButtons = new string[1];
                otherButtons[0] = "OK";
                break;

            case MessageBoxButton.YesNo:
                cancelButton = "";
                otherButtons = new string[2];
                otherButtons[0] = "Yes";
                otherButtons[1] = "No";
                break;

            case MessageBoxButton.YesNoCancel:
                otherButtons = new string[2];
                otherButtons[0] = "Yes";
                otherButtons[1] = "No";
                break;
        }

        IUIAlertViewDelegate d = null;
        if (cancelButton.Length > 0)
            alert = new UIAlertView(caption, messageBoxText, d, cancelButton, otherButtons);
        else
            alert = new UIAlertView(caption, messageBoxText, d, null, otherButtons);

        if (messageBoxText.Contains("\r\n"))
        {
            foreach (UIView v in alert.Subviews)
            {
                try
                {
                    UILabel l = (UILabel)v;
                    if (l.Text == messageBoxText)
                    {
                        l.TextAlignment = UITextAlignment.Left;
                    }
                }
                catch
                {
                    // Do nothing
                }
            }
        }

        alert.BackgroundColor = UIColor.FromWhiteAlpha(0f, 0.8f);
        alert.Canceled += Canceled_Click;
        alert.Clicked += Clicked_Click;
        alert.Dismissed += Dismissed_Click;

        alert.Show();

        IsDisplayed = true;
    }

    // ======================================================================= Private methods ==========================================================================

    private void WaitInLoopWhileDisplayed()
    {
        while (IsDisplayed)
        {
            NSRunLoop.Current.RunUntil(NSDate.FromTimeIntervalSinceNow(0.2));
        }
    }

    private void Canceled_Click(object sender, EventArgs e)
    {
        buttonClicked = 0;
        IsDisplayed = false;
        DisposeAlert();
    }

    private void Clicked_Click(object sender, UIButtonEventArgs e)
    {
        buttonClicked = (int)e.ButtonIndex;
        IsDisplayed = false;
        DisposeAlert();
    }

    private void Dismissed_Click(object sender, UIButtonEventArgs e)
    {
        if (IsDisplayed)
        {
            buttonClicked = (int)e.ButtonIndex;
            IsDisplayed = false;
            DisposeAlert();
        }
    }

    private void DisposeAlert()
    {
        alert.Canceled -= Canceled_Click;
        alert.Clicked -= Clicked_Click;
        alert.Dismissed -= Dismissed_Click;
        alert.Dispose();
        alert = null;
        GC.Collect();

        if (IsAsync)
            GetResult();
    }

    private MessageBoxResult GetResult()
    {
        MessageBoxResult res = MessageBoxResult.Cancel;

        switch (button)
        {
            case MessageBoxButton.OK:
                res = MessageBoxResult.OK;
                break;

            case MessageBoxButton.OKCancel:
                if (buttonClicked == 1)
                    res = MessageBoxResult.OK;
                break;

            case MessageBoxButton.YesNo:
                if (buttonClicked == 0)
                    res = MessageBoxResult.Yes;
                else
                    res = MessageBoxResult.No;
                break;

            case MessageBoxButton.YesNoCancel:
                if (buttonClicked == 1)
                    res = MessageBoxResult.Yes;
                else if (buttonClicked == 2)
                    res = MessageBoxResult.No;
                break;
        }

        if (IsAsync)
            tsc.TrySetResult(res);

        return res;
    }
}

Upvotes: 0

Patrick Xiong
Patrick Xiong

Reputation: 1

Combined danmiser and Ales' answers

            using System;
            using System.Drawing;
            using MonoTouch.UIKit;
            using MonoTouch.Foundation;
            using System.Collections.Generic;
            using System.Threading.Tasks;

            namespace yournamespace
            {

                public enum MessageBoxResult
                {
                    None = 0,
                    OK,
                    Cancel,
                    Yes,
                    No
                }

                public enum MessageBoxButton
                {
                    OK = 0,
                    OKCancel,
                    YesNo,
                    YesNoCancel
                }

                public static class MessageBox
                {
                    public static Task<MessageBoxResult> ShowAsync(string messageBoxText, string caption, MessageBoxButton buttonType)
                    {
                        MessageBoxResult res = MessageBoxResult.Cancel;
                        bool IsDisplayed = false;
                        int buttonClicked = -1;
                        MessageBoxButton button = buttonType;
                        UIAlertView alert = null;

                        string cancelButton = "Cancel";
                        string[] otherButtons = null;

                        switch (button)
                        {
                        case MessageBoxButton.OK:
                            cancelButton = "";
                            otherButtons = new string[1];
                            otherButtons[0] = "OK";
                            break;

                        case MessageBoxButton.OKCancel:
                            otherButtons = new string[1];
                            otherButtons[0] = "OK";
                            break;

                        case MessageBoxButton.YesNo:
                            cancelButton = "";
                            otherButtons = new string[2];
                            otherButtons[0] = "Yes";
                            otherButtons[1] = "No";
                            break;

                        case MessageBoxButton.YesNoCancel:
                            otherButtons = new string[2];
                            otherButtons[0] = "Yes";
                            otherButtons[1] = "No";
                            break;
                        }

                        var tsc = new TaskCompletionSource<MessageBoxResult> ();

                        if (cancelButton.Length > 0)
                            alert = new UIAlertView(caption, messageBoxText, null, cancelButton, otherButtons);
                        else
                            alert = new UIAlertView(caption, messageBoxText, null, null, otherButtons);

                        alert.BackgroundColor = UIColor.FromWhiteAlpha(0f, 0.8f);
                        alert.Canceled += (sender, e) => {
                            tsc.TrySetResult( MessageBoxResult.Cancel);
                        };

                        alert.Clicked += (sender, e) => {
                            buttonClicked = e.ButtonIndex;
                            switch (button)
                            {
                            case MessageBoxButton.OK:
                                res = MessageBoxResult.OK;
                                break;

                            case MessageBoxButton.OKCancel:
                                if (buttonClicked == 1)
                                    res = MessageBoxResult.OK;
                                break;

                            case MessageBoxButton.YesNo:
                                if (buttonClicked == 0)
                                    res = MessageBoxResult.Yes;
                                else
                                    res = MessageBoxResult.No;
                                break;

                            case MessageBoxButton.YesNoCancel:
                                if (buttonClicked == 1)
                                    res = MessageBoxResult.Yes;
                                else if (buttonClicked == 2)
                                    res = MessageBoxResult.No;
                                break;
                            }
                            tsc.TrySetResult( res);
                        };

                        alert.Show();

                        return tsc.Task;
                    }

                    public static Task<MessageBoxResult> ShowAsync(string messageBoxText)
                    {
                        return ShowAsync(messageBoxText, "", MessageBoxButton.OK);
                    }

                    public static Task<MessageBoxResult> ShowAsync(string messageBoxText, string caption)
                    {
                        return ShowAsync(messageBoxText, caption, MessageBoxButton.OK);
                    }
                }
            }

Upvotes: 0

danmiser
danmiser

Reputation: 1083

I think this approach using async/await is much better, and doesn't suffer from freezing the app when rotating the device, or when the autoscrolling interferes and leaves you stuck in the RunUntil loop forever without the ability to click a button (at least these problems are easy to reproduce on iOS7).

Modal UIAlertView

Task<int> ShowModalAletViewAsync (string title, string message, params string[] buttons)
{
    var alertView = new UIAlertView (title, message,  null, null, buttons);
    alertView.Show ();
    var tsc = new TaskCompletionSource<int> ();

    alertView.Clicked += (sender, buttonArgs) => {
        Console.WriteLine ("User clicked on {0}", buttonArgs.ButtonIndex);      
        tsc.TrySetResult(buttonArgs.ButtonIndex);
    };    
    return tsc.Task;
}

Upvotes: 1

Ales Suchac
Ales Suchac

Reputation: 171

Based on the Miguel's coded, here is a convenient replacement of standard MessageBox:

using System;
using System.Drawing;
using MonoTouch.UIKit;
using MonoTouch.Foundation;
using System.Collections.Generic;

namespace YourNameSpace
{

    public enum MessageBoxResult
    {
        None = 0,
        OK,
        Cancel,
        Yes,
        No
    }

    public enum MessageBoxButton
    {
        OK = 0,
        OKCancel,
        YesNo,
        YesNoCancel
    }

    public static class MessageBox
    {
        public static MessageBoxResult Show(string messageBoxText, string caption, MessageBoxButton buttonType)
        {
            MessageBoxResult res = MessageBoxResult.Cancel;
            bool IsDisplayed = false;
            int buttonClicked = -1;
            MessageBoxButton button = buttonType;
            UIAlertView alert = null;

            string cancelButton = "Cancel";
            string[] otherButtons = null;

            switch (button)
            {
                case MessageBoxButton.OK:
                    cancelButton = "";
                    otherButtons = new string[1];
                    otherButtons[0] = "OK";
                    break;

                case MessageBoxButton.OKCancel:
                    otherButtons = new string[1];
                    otherButtons[0] = "OK";
                    break;

                case MessageBoxButton.YesNo:
                    cancelButton = "";
                    otherButtons = new string[2];
                    otherButtons[0] = "Yes";
                    otherButtons[1] = "No";
                    break;

                case MessageBoxButton.YesNoCancel:
                    otherButtons = new string[2];
                    otherButtons[0] = "Yes";
                    otherButtons[1] = "No";
                    break;
            }

            if (cancelButton.Length > 0)
                alert = new UIAlertView(caption, messageBoxText, null, cancelButton, otherButtons);
            else
                alert = new UIAlertView(caption, messageBoxText, null, null, otherButtons);

            alert.BackgroundColor = UIColor.FromWhiteAlpha(0f, 0.8f);
            alert.Canceled += (sender, e) => {
                buttonClicked = 0;
                IsDisplayed = false;
            };

            alert.Clicked += (sender, e) => {
                buttonClicked = e.ButtonIndex;
                IsDisplayed = false;
            };

            alert.Dismissed += (sender, e) => {
                if (IsDisplayed)
                {
                    buttonClicked = e.ButtonIndex;
                    IsDisplayed = false;
                }
            };

            alert.Show();

            IsDisplayed = true;

            while (IsDisplayed)
            {
                NSRunLoop.Current.RunUntil (NSDate.FromTimeIntervalSinceNow (0.2));
            }

            switch (button)
            {
                case MessageBoxButton.OK:
                    res = MessageBoxResult.OK;
                    break;

                case MessageBoxButton.OKCancel:
                    if (buttonClicked == 1)
                        res = MessageBoxResult.OK;
                    break;

                case MessageBoxButton.YesNo:
                    if (buttonClicked == 0)
                        res = MessageBoxResult.Yes;
                    else
                        res = MessageBoxResult.No;
                    break;

                case MessageBoxButton.YesNoCancel:
                    if (buttonClicked == 1)
                        res = MessageBoxResult.Yes;
                    else if (buttonClicked == 2)
                        res = MessageBoxResult.No;
                    break;
            }

            return res;
        }

        public static MessageBoxResult Show(string messageBoxText)
        {
            return Show(messageBoxText, "", MessageBoxButton.OK);
        }

        public static MessageBoxResult Show(string messageBoxText, string caption)
        {
            return Show(messageBoxText, caption, MessageBoxButton.OK);
        }
    }
}

Upvotes: 17

miguel.de.icaza
miguel.de.icaza

Reputation: 32694

To do this, what you can do is to run the mainloop manually. I have not managed to stop the mainloop directly, so I instead run the mainloop for 0.5 seconds and wait until the user responds.

The following function shows how you could implement a modal query with the above approach:

int WaitForClick ()
{
    int clicked = -1;
    var x = new UIAlertView ("Title", "Message",  null, "Cancel", "OK", "Perhaps");
    x.Show ();
    bool done = false;
    x.Clicked += (sender, buttonArgs) => {
        Console.WriteLine ("User clicked on {0}", buttonArgs.ButtonIndex);
    clicked = buttonArgs.ButtonIndex;
    };    
    while (clicked == -1){
        NSRunLoop.Current.RunUntil (NSDate.FromTimeIntervalSinceNow (0.5));
        Console.WriteLine ("Waiting for another 0.5 seconds");
    }

    Console.WriteLine ("The user clicked {0}", clicked);
    return clicked;
}

Upvotes: 18

Akash Kava
Akash Kava

Reputation: 39956

MonoTouch (iOS) does not have Modal dialogs, the reason is Modal dialogs (waiting) can cause deadlocks so frameworks like Silverlight, Flex/Flash, iOS do not allow such dialogs.

The only way you can work with it is, you have to pass a delegate to UIAlertView which will be called when it was successful. I dont know the exact syntax of UIAlertView but you should see documentation about UIAlertView, there must be a way to pass a class implementing UIAlertViewDelegate protocol/interface. That will have a method which will be called on completion of dialog box.

Upvotes: 0

Related Questions