Regresion Popup service?

[yperezpp]

Calling a modal and closing it causes the method OnAppearing And ApplyQueryAttributes to be executed on the page that called it.

[bijington]

It's not a regression but a behavioral change. Your page that shows the popup will appear again when the popup closes. In fact I'd argue if it didn't do it before that was a bug.

[darrenf89]

I'm curious about this because, in my app, I've often (perhaps rightly or wrongly!) shown and then dismissed a popup with a loading message during OnAppearing or OnNavigatedTo. I know some might debate the UX merits of that approach, but it worked. Now, though, this results in an infinite loop—my page appears, opens the modal, which closes and re-triggers the page appearance, repeating the cycle endlessly.

I understand your point: it does make logical sense that the Appearing event would fire again, since technically the page is reappearing. But previously, it felt more flexible—if I used a popup in the more typical way, I could just reload the necessary page data in response to the popup's result.

I’ve tried working around this to regain the behavior I had with the v2 system, but I’m not sure it’s feasible with how things work now. Unless someone has a clever solution?

[bijington]

You most certainly can workaround it as I just explained with #2750 however it will increase some level of complexity.

Essentially you 'just' need to know that you have displayed your Popup already and not do it a second time in OnAppearing. Quite often a nice way to achieve this is through managing your own internal state machine. But if you just need to know whether it has displayed before a simple bool would suffice.

If you need to do this in multiple places then you could consider wrapping it inside a class like (it needs a better name but that is the difficult part):

public class SingleUsePopupService
{
    private bool hasDisplayedPopup;
    private readonly IPopupService popupService;

    public SingleUsePopupService(IPopupService popupService)
    {
        this.popupService = popupService;
    }

    public Task ShowPopupAsync<TPopup>(PopupOptions popupOptions) where TPopup : Vew
    {
        if (hasDisplayedPopup)
        {
            return Task.CompletedTask;
        }

        return this.popupService.ShowPopupAsync<TPopup>(popupOptions);
    }
}

P.S. I have only written this in the browser so it may not even compile.

[darrenf89]

Thanks for the quick reply and the advice.

I will have a play around with this, ironically I was doing something very similar with V1 popup but I was using it to open a modal on one page and after navigating to another page check if it was opened close it from another (Again just a wait message in most cases). I don't think this is possible anymore given the behavioral change of V2, when I debug it looks like the popup is lost when I navigate but also changes the navigation stack. I haven't looked to much more into it as I am not convinced I even get any benefit from doing it this way.

I think the above will still call the OnAppearing event twice, once the first time I try to load the page and then again when I close the Popup? Just trying to think that through in my head so my understanding is correct? I guess when hasDisplayedPopup is true I can just skip all the "work" being done in the OnAppearing method.

Hope those comments didn't come across as negative, so far think the popup V2! And as always appreciate the work you all do.

[bijington]

Don't worry it didn't come across as negative :). Thank you for the compliment!

[darrenf89]

Just if you are interested or if you have any input I ended up implementing a ModalService layer

using CommunityToolkit.Maui;
using CommunityToolkit.Maui.Extensions;
using CommunityToolkit.Maui.Views;

namespace MyProject.Services;

public class ModalPopupService : IModalPopupService
{
    public Popup? CurrentPopup { get; private set; }
    public Type? CurrentPopupType => CurrentPopup?.GetType();

    private readonly IPopupService _ps;
    public IPopupService PopupService => _ps;

    public ModalPopupService(IPopupService ps)
    {
        _ps = ps;
    }

    public bool IsPopupShown<TPopup>() where TPopup : Popup =>
        CurrentPopupType == (typeof(TPopup));

    public async Task ShowAsync<TPopup>(Func<TPopup> popupFactory, PopupOptions? options = null) where TPopup : Popup
    {
        if (CurrentPopupType == typeof(TPopup))
        {
            return;
        }

        if(CurrentPopup is not null)
        {
            await CurrentPopup.CloseAsync();
        }

        var popup = popupFactory();

        options ??= new PopupOptions
        {
            CanBeDismissedByTappingOutsideOfPopup = false,
            PageOverlayColor = Color.FromArgb("#80000000")
        };

        _ = Shell.Current.ShowPopupAsync(popup, options);

        CurrentPopup = popup;
        return;
    }

    public async Task CloseAsync<TPopup>() where TPopup : Popup
    {
        if (CurrentPopupType != typeof(TPopup))
        {
            return;
        }

        await CurrentPopup.CloseAsync();

        CurrentPopup = null;

        return;
    }

    public void Clear() => CurrentPopup = null;

}

and then to stop the second appear from firing I am just adding

async protected override void OnAppearing()
{
        if(_ps.CurrentPopup is not null)
            return;

        await _ps.ShowAsync<PopUpPage>(() => new PopUpPage());
        base.OnAppearing();
        await _ps.CloseAsync<PopUpPage>();
}

I am sure there are better ways but it does seem to have worked a treat.