BaseViewModel.cs

using System.Reflection;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using CommunityToolkit.Mvvm.Messaging;
using NeuroAccessMaui;
using NeuroAccessMaui.Resources.Languages;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.Services.Tag;
using NeuroAccessMaui.Services.UI;
 
namespace NeuroAccessMaui.UI.Pages
{
    public abstract partial class BaseViewModel : ObservableObject, ILifeCycleView, IBackButtonHandler
    {
        private readonly List<BaseViewModel> childViewModels = [];
        private bool isOverlayVisible;
        private DateTime overlayLastActivationTime;
 
        public BaseViewModel()
        {
        }
 
        public bool IsInitialized { get; private set; }
 
        public bool IsAppearing { get; private set; }
 
        public IEnumerable<BaseViewModel> Children => this.childViewModels;
 
        public virtual double ViewWidthRequest => (DeviceDisplay.MainDisplayInfo.Width / DeviceDisplay.MainDisplayInfo.Density) * (7.0 / 8.0);
        public virtual double MaximumViewHeightRequest => (DeviceDisplay.MainDisplayInfo.Height / DeviceDisplay.MainDisplayInfo.Density) * (3.0 / 4.0);
 
        public static void GoToRegistrationStep(RegistrationStep NewStep)
        {
            ServiceRef.TagProfile.GoToStep(NewStep);
            WeakReferenceMessenger.Default.Send(new RegistrationPageMessage(ServiceRef.TagProfile.Step));
        }
 
        protected T AddChildViewModel<T>(T ChildViewModel) where T : BaseViewModel
        {
            this.childViewModels.Add(ChildViewModel);
            return ChildViewModel;
        }
 
        protected T RemoveChildViewModel<T>(T ChildViewModel) where T : BaseViewModel
        {
            this.childViewModels.Remove(ChildViewModel);
            return ChildViewModel;
        }
 
        public async Task RestoreState()
        {
            foreach (BaseViewModel ChildViewModel in this.childViewModels)
                await ChildViewModel.DoRestoreState();
 
            await this.DoRestoreState();
        }
 
        public async Task SaveState()
        {
            foreach (BaseViewModel ChildViewModel in this.childViewModels)
                await ChildViewModel.DoSaveState();
 
            await this.DoSaveState();
        }
 
        public async Task Shutdown()
        {
            await this.SaveState();
            await this.OnDisposeAsync();
        }
 
        protected virtual Task DoRestoreState()
        {
            return Task.CompletedTask;
        }
 
        protected virtual Task DoSaveState()
        {
            return Task.CompletedTask;
        }
 
        protected string GetSettingsKey(string PropertyName)
        {
            return this.GetType().FullName + "." + PropertyName;
        }
 
        [ObservableProperty]
        private bool isBusy;
 
        public virtual void SetIsBusy(bool IsBusy)
        {
            this.IsBusy = IsBusy;
        }
 
        public bool IsOverlayVisible
        {
            get => this.isOverlayVisible;
            set
            {
                if (this.isOverlayVisible == value)
                    return;
 
                if (value)
                {
                    this.isOverlayVisible = true;
                    this.overlayLastActivationTime = DateTime.Now;
                    this.OnPropertyChanged();
                }
                else
                {
                    TimeSpan MinimumOverlayTime = TimeSpan.FromMilliseconds(500);
                    TimeSpan ElapsedTime = DateTime.Now.Subtract(this.overlayLastActivationTime);
 
                    if (ElapsedTime >= MinimumOverlayTime)
                    {
                        this.isOverlayVisible = false;
                        this.OnPropertyChanged();
                    }
                    else
                    {
                        // It is important to use the property here, not the field, because last activation time might be updated while we are waiting,
                        // we need to recheck it and possibly reschedule.
                        Task.Delay(MinimumOverlayTime - ElapsedTime).GetAwaiter().OnCompleted(() => this.isOverlayVisible = false);
                    }
                }
            }
        }
 
 
        public static async Task<bool> AreYouSure(string Message)
        {
            return await ServiceRef.UiService.DisplayAlert(
                ServiceRef.Localizer[nameof(AppResources.Confirm)], Message,
                ServiceRef.Localizer[nameof(AppResources.Yes)],
                ServiceRef.Localizer[nameof(AppResources.No)]);
        }
 
        public async Task<bool> OnBackButtonPressedAsync()
        {
            if (this.GoBackCommand.CanExecute(null))
                _ = this.GoBackCommand.ExecuteAsync(null);
 
            return true;
        }
 
        [RelayCommand(AllowConcurrentExecutions = false)]
        public virtual async Task GoBack()
        {
            await ServiceRef.NavigationService.GoBackAsync();
        }
 
        public virtual object? GetValue(string PropertyName)
        {
            PropertyInfo? PI = this.GetType().GetProperty(PropertyName)
                ?? throw new ArgumentException("Property not found: " + PropertyName, nameof(PropertyName));
 
            return PI.GetValue(this);
        }
 
        public virtual void SetValue(string PropertyName, object? Value)
        {
            PropertyInfo? PI = this.GetType().GetProperty(PropertyName)
                ?? throw new ArgumentException("Property not found: " + PropertyName, nameof(PropertyName));
 
            PI.SetValue(this, Value);
        }
 
        public virtual async Task OnInitializeAsync()
        {
            await App.ServicesReady;
 
            foreach (BaseViewModel ChildViewModel in this.childViewModels)
                await ChildViewModel.OnInitializeAsync();
        }
 
        public virtual async Task OnDisposeAsync()
        {
            foreach (BaseViewModel ChildViewModel in this.childViewModels)
                await ChildViewModel.OnDisposeAsync();
        }
 
        public virtual async Task OnAppearingAsync()
        {
            await App.ServicesReady;
 
            foreach (BaseViewModel ChildViewModel in this.childViewModels)
                await ChildViewModel.OnAppearingAsync();
        }
 
        public virtual async Task OnDisappearingAsync()
        {
            foreach (BaseViewModel ChildViewModel in this.childViewModels)
                await ChildViewModel.OnDisappearingAsync();
        }
 
 
    }
}