(Library Part 3) Loading state with Picker Label

public partial class LabelBase
{
    // ...

    public static readonly BindableProperty ShowLoaderProperty = 
        BindableProperty.Create("ShowLoader", typeof(bool), typeof(LabelBase), 
        defaultValue: false, propertyChanged: ShowLoaderChanged);

    public bool ShowLoader
    {
        get => (bool)GetValue(ShowLoaderProperty);
        set => SetValue(ShowLoaderProperty, value);
    }

    // ...

    private static void ShowLoaderChanged
        (BindableObject bindable, object oldValue, object newValue) => 
            ((LabelBase)bindable).UpdateShowLoaderView();

    private void UpdateShowLoaderView()
    {
        LoaderActivityIndicator.IsVisible = ShowLoader;
    }

    // ...
}

public partial class PickerLabel
{
    public PickerLabel()
    {
        InitializeComponent();
        
        Element.SetVisualElementBinding();
        Element.SetBinding(Picker.ItemsSourceProperty, nameof(ItemsSource));
        Element.SetBinding(Picker.SelectedItemProperty, nameof(SelectedItem));
        Element.BindingContext = this;
    }
    
    public static readonly BindableProperty ItemsSourceProperty =
        BindableProperty.Create(nameof(ItemsSource), typeof(IList), typeof(PickerLabel), 
        propertyChanged: OnItemsSourceChanged);

    public IList ItemsSource
    {
        get => (IList)GetValue(ItemsSourceProperty);
        set => SetValue(ItemsSourceProperty, value);
    }

    public static readonly BindableProperty SelectedItemProperty =
        BindableProperty.Create(nameof(SelectedItem), typeof(object), typeof(PickerLabel), 
        null, BindingMode.TwoWay, propertyChanged: OnSelectedItemChanged);

    public object SelectedItem
    {
        get => GetValue(SelectedItemProperty);
        set => SetValue(SelectedItemProperty, value);
    }
    
    public static readonly BindableProperty ItemDisplayBindingProperty = 
        BindableProperty.Create(nameof(ItemDisplayBinding), typeof(string), 
        typeof(PickerLabel), propertyChanged: OnItemDisplayBindingChanged, 
        defaultBindingMode: BindingMode.OneWay);

    public string ItemDisplayBinding
    {
        get => (string)GetValue(ItemDisplayBindingProperty);
        set => SetValue(ItemDisplayBindingProperty, value);
    }
    
    public static readonly BindableProperty TapCommandProperty = 
        BindableProperty.Create(nameof(TapCommand), typeof(ICommand), 
        typeof(PickerLabel));

    public ICommand? TapCommand
    {
        get => (ICommand?)GetValue(TapCommandProperty);
        set => SetValue(TapCommandProperty, value);
    }
    
    private static void OnItemsSourceChanged
        (BindableObject bindable, object oldValue, object newValue) => 
            ((PickerLabel)bindable).OnItemsSourceChanged();
    private static void OnSelectedItemChanged
        (BindableObject bindable, object oldValue, object newValue) => 
            ((PickerLabel)bindable).OnSelectedItemChanged();
    private static void OnItemDisplayBindingChanged
        (BindableObject bindable, object oldValue, object newValue) => 
            ((PickerLabel)bindable).OnItemDisplayBindingChanged();

    private void OnItemsSourceChanged()
    {
        Element.ItemsSource = ItemsSource;
    }

    private void OnSelectedItemChanged()
    {
        Element.SelectedItem = SelectedItem;
        TapCommand?.Execute(null);
    }

    private void OnItemDisplayBindingChanged()
    {
        Element.ItemDisplayBinding = new Binding(ItemDisplayBinding);
    }
}

private static void ApplyStyleCustomization()
{
    // Remove the underline from the Entry ...

    PickerHandler.Mapper.AppendToMapping("NoUnderline", (handler, _) =>
    {
#if ANDROID
    // Remove the underline from the Spinner (Picker)
    handler.PlatformView.Background = null;
#endif
    });

    PickerHandler.Mapper.AppendToMapping("SetUpPicker", (handler, _) =>
    {
#if ANDROID
    // Set the background to transparent
    handler.PlatformView.Background = null;
#elif IOS || MACCATALYST
    // Remove border for the UITextField (Picker)
    if (handler.PlatformView is UIKit.UITextField textField)
    {
        textField.BorderStyle = UIKit.UITextBorderStyle.None;
    }
#elif WINDOWS

#endif
    });
}

public partial class PickerPageViewModel : ViewModelBase
{
    private readonly ILogger<PickerPageViewModel> _logger;
    private readonly ICityService _cityService;
    private readonly ICountryService _countryService;
    
    // The selected Country from the Picker.
    [ObservableProperty]
    private CountryVm? _country;
    
    // The selected City from the Picker.
    [ObservableProperty]
    private CityVm? _city;
    
    public static string CountryDisplayProperty => nameof(CountryVm.Name);
    public static string CityDisplayProperty => nameof(CityVm.Name);

    public TaskLoaderNotifier<IReadOnlyCollection<CountryVm>> CountriesLoader 
        { get; } = new();
    public TaskLoaderNotifier<IReadOnlyCollection<CityVm>> CitiesLoader 
        { get; } = new();

    public PickerPageViewModel(
        ILogger<PickerPageViewModel> logger,
        ICityService cityService,
        ICountryService countryService)
    {
        _logger = logger;
        _cityService = cityService;
        _countryService = countryService;
        
        _logger.LogInformation("Building LabelPageViewModel");
    }
    
    public override void ApplyQueryAttributes(IDictionary<string, object> query)
    {
        _logger.LogInformation("ApplyQueryAttributes( query: {Query} )", query);
        
        base.ApplyQueryAttributes(query);
    }

    public override void OnAppearing()
    {
        _logger.LogInformation("OnAppearing()");

        if (CountriesLoader.IsNotStarted)
        {
            // We just navigate to the page, we load the data.
            CountriesLoader.Load(_ => LoadCountriesAsync());
        }
        
        base.OnAppearing();
    }

    public override void OnDisappearing()
    {
        _logger.LogInformation("OnDisappearing()");
        
        base.OnDisappearing();
    }
    
    private async Task<IReadOnlyCollection<CountryVm>> LoadCountriesAsync(
        CancellationToken cancellationToken = default)
    {
        _logger.LogInformation("LoadCountriesAsync()");

        var domainResult = await _countryService.GetAllCountriesAsync(cancellationToken);
        _logger.LogInformation("Items loaded: {Count}", domainResult.Count);

        return domainResult;
    }

    private async Task<IReadOnlyCollection<CityVm>> LoadCitiesByCountry(
        CancellationToken cancellationToken = default)
    {
        _logger.LogInformation("LoadCitiesByCountry()");

        if (Country is null)
        {
            // Add a toast to enhance the user experience.
            return Array.Empty<CityVm>();
        }
        
        var domainResult = await _cityService
            .GetCitiesAsync(Country.Id, cancellationToken);
        _logger.LogInformation("Items loaded: {Count}", domainResult.Count);
        
        return domainResult;
    }

    [RelayCommand]
    private Task CountrySelected()
    {
        _logger.LogInformation("CountrySelected()");

        City = null;
        // Reset clean the data contained in CitiesLoader.Result.
        // The IsNotStarted return to true. 
        CitiesLoader.Reset();
        CitiesLoader.Load(_ => LoadCitiesByCountry());
        
        return Task.CompletedTask;
    }
}

public partial class PickerLabel
{
    public PickerLabel()
    {
        InitializeComponent();
        
        Element.SetVisualElementBinding();
        Element.SetBinding(Picker.ItemsSourceProperty, nameof(ItemsSource));
        Element.SetBinding(Picker.SelectedItemProperty, nameof(SelectedItem));
        Element.BindingContext = this;
    }
    
    private void OnPickerTapped(object sender, EventArgs e)
    {
        if (Element.ItemsSource == null || !Element.ItemsSource.Cast<object>().Any())
        {
            // The Picker has no items, so we don't want to show an empty Picker dialog.
            return;
        }

        Element.Unfocus();
        Element.Focus();
    }

    // Bindable properties ...
}