ScanQrCodeViewModel.cs

using System.Collections.ObjectModel;
using System.ComponentModel;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.Services.Localization;
using ZXing.Net.Maui;
 
namespace NeuroAccessMaui.UI.Pages.Main.QR
{
    public partial class ScanQrCodeViewModel : BaseViewModel
    {
        private readonly ScanQrCodeNavigationArgs? navigationArgs;
        private IDispatcherTimer? countDownTimer;
        private bool suppressModeHandler;
 
        public ScanQrCodeViewModel()
        {
            this.navigationArgs = ServiceRef.NavigationService.PopLatestArgs<ScanQrCodeNavigationArgs>();
            // Default: automatic scan => enable detecting
            this.isAutomaticScan = true; // backing field to avoid recursion
            this.isDetecting = true;
            if (this.navigationArgs is not null &&
                this.navigationArgs.AllowedSchemas is not null &&
                this.navigationArgs.AllowedSchemas.Length > 0 &&
                this.Icons.Count == 0)
            {
                foreach (string Schema in this.navigationArgs.AllowedSchemas)
                {
                    switch (Schema)
                    {
                        case Constants.UriSchemes.IotId:
                            this.Icons.Add(new UriSchemaIcon(Geometries.UserIconPath, Geometries.UserColor, this));
                            break;
 
                        case Constants.UriSchemes.IotDisco:
                            this.Icons.Add(new UriSchemaIcon(Geometries.ThingsIconPath, Geometries.ThingsColor, this));
                            break;
 
                        case Constants.UriSchemes.IotSc:
                            this.Icons.Add(new UriSchemaIcon(Geometries.ContractIconPath, Geometries.ContractColor, this));
                            break;
 
                        case Constants.UriSchemes.TagSign:
                            this.Icons.Add(new UriSchemaIcon(Geometries.SignatureIconPath, Geometries.SignatureColor, this));
                            break;
 
                        case Constants.UriSchemes.EDaler:
                            this.Icons.Add(new UriSchemaIcon(Geometries.EDalerIconPath, Geometries.EDalerColor, this));
                            break;
 
                        case Constants.UriSchemes.NeuroFeature:
                            this.Icons.Add(new UriSchemaIcon(Geometries.TokenIconPath, Geometries.TokenColor, this));
                            break;
 
                        case Constants.UriSchemes.Onboarding:
                            this.Icons.Add(new UriSchemaIcon(Geometries.OnboardingIconPath, Geometries.OnboardingColor, this));
                            break;
 
                        case Constants.UriSchemes.Aes256:
                            this.Icons.Add(new UriSchemaIcon(Geometries.Aes256IconPath, Geometries.Aes256Color, this));
                            break;
 
                        case Constants.UriSchemes.Xmpp:
                        default:
                            break;
                    }
                }
 
                if (this.Icons.Count == 0)
                    this.Icons.Add(new UriSchemaIcon(Geometries.SignatureIconPath, Geometries.SignatureColor, this));
            }
        }
 
 
        [RelayCommand]
        private async Task SwitchMode()
        {
            // Toggle IsAutomaticScan; page listens for change to animate & adjust camera
            this.suppressModeHandler = true;
            this.IsAutomaticScan = !this.IsAutomaticScan;
            this.suppressModeHandler = false;
            await Task.CompletedTask;
        }
 
        [RelayCommand]
        private void SwitchCamera()
        {
            this.CameraLocation = this.CameraLocation == CameraLocation.Rear ? CameraLocation.Front : CameraLocation.Rear;
        }
 
        [RelayCommand]
        private void SwitchTorch()
        {
            this.IsTorchOn = !this.IsTorchOn;
        }
 
        private static bool CanPickPhoto() => false; // Disabled for now
 
        [RelayCommand(CanExecute = nameof(CanPickPhoto))]
        private async Task PickPhoto()
        {
#if ANDROID
            // Platform-specific implementation previously in page; keep placeholder for future
            await Task.CompletedTask;
#else
            await Task.CompletedTask;
#endif
        }
 
 
        public override async Task OnInitializeAsync()
        {
            await base.OnInitializeAsync();
 
            LocalizationManager.Current.PropertyChanged += this.LocalizationManagerEventHandler;
 
            if (App.Current is not null)
            {
                this.countDownTimer = App.Current.Dispatcher.CreateTimer();
                this.countDownTimer.Interval = TimeSpan.FromMilliseconds(500);
                this.countDownTimer.Tick += this.CountDownEventHandler;
            }
        }
 
        public override async Task OnDisposeAsync()
        {
            LocalizationManager.Current.PropertyChanged -= this.LocalizationManagerEventHandler;
 
            if (this.countDownTimer is not null)
            {
                this.countDownTimer.Stop();
                this.countDownTimer.Tick -= this.CountDownEventHandler;
                this.countDownTimer = null;
            }
 
            if (this.navigationArgs?.QrCodeScanned is TaskCompletionSource<string> TaskSource)
                TaskSource.TrySetResult(string.Empty);
 
            await base.OnDisposeAsync();
        }
 
        private void CountDownEventHandler(object? sender, EventArgs e)
        {
            this.countDownTimer?.Stop();
            this.OnBackgroundColorChanged();
        }
 
        private void OnBackgroundColorChanged()
        {
            this.OnPropertyChanged(nameof(this.IconBackgroundColor));
 
            foreach (UriSchemaIcon Icon in this.Icons)
                Icon.BackgroundColorChanged();
        }
 
        public void LocalizationManagerEventHandler(object? sender, PropertyChangedEventArgs e)
        {
            this.OnPropertyChanged(nameof(this.LocalizedQrPageTitle));
        }
 
        public Task DoSwitchMode(bool IsAutomaticScan)
        {
            this.IsAutomaticScan = IsAutomaticScan;
            return Task.CompletedTask;
        }
 
        public Task SetScannedText(string? ScannedText)
        {
            this.ScannedText = ScannedText ?? string.Empty;
            this.countDownTimer?.Stop();
            this.OnBackgroundColorChanged();
 
            if (this.CanOpen(ScannedText))
            {
                return this.TrySetResultAndClosePage(ScannedText!.Trim());
            }
            this.countDownTimer?.Start();
            this.OnBackgroundColorChanged();
 
            return Task.CompletedTask;
        }
 
        private async Task TrySetResultAndClosePage(string? Url)
        {
            if (this.navigationArgs?.QrCodeScanned is not null)
            {
                TaskCompletionSource<string?> TaskSource = this.navigationArgs.QrCodeScanned;
                this.navigationArgs.QrCodeScanned = null;
 
                await MainThread.InvokeOnMainThreadAsync(async () =>
                {
                    try
                    {
                        await base.GoBack();
                        TaskSource.TrySetResult(Url);
                    }
                    catch (Exception ex)
                    {
                        ServiceRef.LogService.LogException(ex);
                    }
                });
            }
        }
 
        #region Properties
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(OpenUrlCommand))]
        private string? manualText;
 
        [ObservableProperty]
        private string? scannedText;
 
        [ObservableProperty]
        private bool isAutomaticScan = true;
 
        partial void OnIsAutomaticScanChanged(bool value)
        {
            if (!this.suppressModeHandler)
            {
                // When entering automatic mode, enable detecting; when leaving, disable
                this.IsDetecting = value;
            }
        }
 
        [ObservableProperty]
        private bool isDetecting;
 
        [ObservableProperty]
        private bool isTorchOn;
 
        [ObservableProperty]
        private CameraLocation cameraLocation = CameraLocation.Rear;
 
        public bool HasAllowedSchemas => this.navigationArgs?.AllowedSchemas is not null && this.navigationArgs.AllowedSchemas.Length > 0;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(MultipleIcons))]
        [NotifyPropertyChangedFor(nameof(SingleIcon))]
        private ObservableCollection<UriSchemaIcon> icons = [];
 
        public bool MultipleIcons => this.Icons.Count > 1;
 
        public bool SingleIcon => this.Icons.Count == 1;
 
        public Color IconBackgroundColor
        {
            get
            {
                if (string.IsNullOrEmpty(this.ScannedText))
                    return Colors.White;
 
                string Url = this.ScannedText.Trim();
 
                if ((this.countDownTimer?.IsRunning ?? false) &&
                    (this.navigationArgs?.AllowedSchemas is not null) &&
                    this.navigationArgs.AllowedSchemas.Length > 0)
                {
                    return this.IsPermittedUrl(Url) ? Colors.White : Colors.LightSalmon;
                }
 
                return Colors.White;
            }
        }
 
        private bool IsPermittedUrl(string Url)
        {
            if (this.navigationArgs?.AllowedSchemas is not null &&
                System.Uri.TryCreate(Url, UriKind.Absolute, out Uri? Uri))
            {
                foreach (string Schema in this.navigationArgs.AllowedSchemas)
                {
                    if (string.Equals(Uri.Scheme, Schema, StringComparison.OrdinalIgnoreCase))
                        return true;
                }
            }
 
            return false;
        }
 
        public string LocalizedQrPageTitle
        {
            get
            {
                if (this.navigationArgs?.QrTitle is not null)
                    return ServiceRef.Localizer[this.navigationArgs.QrTitle];
 
                return string.Empty;
            }
        }
 
        private bool CanOpen(string? Text)
        {
            string? Url = Text?.Trim();
            if (string.IsNullOrEmpty(Url))
                return false;
 
            if (this.navigationArgs?.AllowedSchemas is not null && this.navigationArgs.AllowedSchemas.Length > 0)
                return this.IsPermittedUrl(Url);
            else
                return Url.Length > 0;
        }
 
        public bool CanOpenScanned => this.CanOpen(this.ScannedText);
 
        public bool CanOpenManual => this.CanOpen(this.ManualText);
 
        #endregion
 
        [RelayCommand(CanExecute = nameof(CanOpenManual))]
        private Task OpenUrl()
        {
            return this.TrySetResultAndClosePage(this.ManualText!.Trim());
        }
 
        public override Task GoBack()
        {
            return this.TrySetResultAndClosePage(null);
        }
    }
}