BaseViewModel.cs

using System.Reflection;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using CommunityToolkit.Mvvm.Messaging;
using NeuroAccessMaui.Resources.Languages;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.Services.Tag;
 
namespace NeuroAccessMaui.UI.Pages
{
    public abstract partial class BaseViewModel : ObservableObject, ILifeCycleView
    {
        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.DoDisappearing();
        }
 
        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 async Task DoInitialize()
        {
            if (!this.IsInitialized)
            {
                this.IsInitialized = true;
 
                await this.OnInitialize();
            }
        }
 
        protected virtual Task OnInitialize()
        {
            return Task.CompletedTask;  // Do nothing by default.
        }
 
        public async Task DoDispose()
        {
            if (this.IsAppearing)
                await this.DoDisappearing();
 
            if (this.IsInitialized)
            {
                this.IsInitialized = false;
 
                await this.OnDispose();
            }
        }
 
        protected virtual Task OnDispose()
        {
            return Task.CompletedTask;  // Do nothing by default.
        }
 
        public virtual async Task DoAppearing()
        {
            if (!this.IsInitialized)
                await this.DoInitialize();
 
            if (!this.IsAppearing)
            {
                DeviceDisplay.KeepScreenOn = true;
 
                await this.OnAppearing();
 
                foreach (BaseViewModel ChildViewModel in this.childViewModels)
                    await ChildViewModel.DoAppearing();
 
                this.IsAppearing = true;
            }
        }
 
        protected virtual Task OnAppearing()
        {
            return Task.CompletedTask;  // Do nothing by default.
        }
 
        public async Task DoDisappearing()
        {
            if (this.IsAppearing)
            {
                foreach (BaseViewModel ChildViewModel in this.childViewModels)
                    await ChildViewModel.DoDisappearing();
 
                await this.OnDisappearing();
 
                this.IsAppearing = false;
            }
        }
 
        protected virtual Task OnDisappearing()
        {
            return Task.CompletedTask;  // Do nothing by default.
        }
 
        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)]);
        }
 
        [RelayCommand]
        public virtual async Task GoBack()
        {
            await ServiceRef.UiService.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);
        }
 
    }
}