ShowQRViewModel.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using NeuroAccessMaui.Resources.Languages;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.UI.Pages;
 
namespace NeuroAccessMaui.UI.Popups.QR
{
    public partial class ShowQRViewModel : BasePopupViewModel
    {
        #region Private Properties
 
        private byte[] qrCodeBin = [];
        private readonly IDispatcherTimer? timer;
        private int timerSeconds = 60;
 
        [ObservableProperty]
        private string title;
 
        [ObservableProperty]
        private string? legalId;
 
        [ObservableProperty]
        private ImageSource? qrCode;
 
        [ObservableProperty]
        private string? qrCodeUri;
 
        [ObservableProperty]
        private int qrCodeWidth;
 
        [ObservableProperty]
        private int qrCodeHeight;
 
        [ObservableProperty]
        private int qrResolutionScale;
 
        [ObservableProperty]
        private string? qrCodeContentType;
 
        #endregion
        #region Public Properties
 
        public byte[] QrCodeBin
        {
            get => this.qrCodeBin;
            set
            {
                if (value == this.qrCodeBin) return;
                this.qrCodeBin = value;
                this.OnPropertyChanged();
            }
        }
 
        public static double CameraIconBackgroundSize => 120.0;
 
        public static double CameraIconBackgroundCornerRadius => CameraIconBackgroundSize / 2;
 
        public static double CameraIconSize => 60.0;
 
        #endregion
 
        public ShowQRViewModel(byte[] QrCodeBin, string? QrCodeUri) : this(QrCodeBin, QrCodeUri, "QR Code")
        {
        }
 
        public ShowQRViewModel(byte[] QrCodeBin, string? QrCodeUri, string Title)
        {
            this.Title = Title;
 
            this.QrCodeBin = QrCodeBin;
            this.QrCodeUri = QrCodeUri;
            this.LegalId = ServiceRef.TagProfile.LegalIdentity?.Id;
 
            if (this.QrCodeWidth == 0 || this.QrCodeHeight == 0)
            {
                this.QrCodeWidth = Constants.QrCode.DefaultImageWidth;
                this.QrCodeHeight = Constants.QrCode.DefaultImageHeight;
            }
 
            if (this.QrResolutionScale == 0)
                this.QrResolutionScale = Constants.QrCode.DefaultResolutionScale;
 
            this.QrCode = ImageSource.FromStream(() => new MemoryStream(QrCodeBin));
 
            this.timerSeconds = Convert.ToInt32(Constants.Timeouts.IdentityAllowedWatch.TotalSeconds);
 
            this.timer = Application.Current?.Dispatcher.CreateTimer();
            if (this.timer is null)
                return;
            this.timer.Interval = TimeSpan.FromSeconds(1);
            this.timer.Tick += this.OnTimerTick;
            this.timer.Start();
 
        }
 
        #region Commands
 
        [RelayCommand]
        private async Task Close()
        {
            this.timer?.Stop();
            await ServiceRef.PopupService.PopAsync();
        }
 
        [RelayCommand]
        private async Task ShareQR()
        {
            if (this.QrCodeBin is null)
                return;
 
            try
            {
                // Generate a random filename with a suitable extension (e.g., ".tmp", ".dat")
                string FileName = $"{Guid.NewGuid()}.png";
 
                // Define the path to save the file in the cache directory
                string FilePath = Path.Combine(FileSystem.CacheDirectory, FileName);
 
                // Save the byte array as a file
                await File.WriteAllBytesAsync(FilePath, this.QrCodeBin);
 
                // Share the file
                await Share.Default.RequestAsync(new ShareFileRequest
                {
                    Title = this.Title ?? "QR Code",
                    File = new ShareFile(FilePath, "image/png")
                });
 
            }
            catch (Exception ex)
            {
                // Handle exceptions
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        [RelayCommand]
        private async Task Copy()
        {
            try
            {
                this.SetIsBusy(true);
 
                await Clipboard.SetTextAsync(this.QrCodeUri);
                await ServiceRef.UiService.DisplayAlert(
                    ServiceRef.Localizer[nameof(AppResources.SuccessTitle)],
                    ServiceRef.Localizer[nameof(AppResources.SuccessfullyCopiedToClipboard)]);
            }
            catch (Exception Ex)
            {
                ServiceRef.LogService.LogException(Ex);
                await ServiceRef.UiService.DisplayException(Ex);
            }
            finally
            {
                this.SetIsBusy(false);
            }
        }
 
        private void OnTimerTick(object? sender, EventArgs e)
        {
            MainThread.BeginInvokeOnMainThread(async () =>
            {
                if (this.timerSeconds > 0)
                {
                    this.timerSeconds--;
                }
                else
                {
                    try
                    {
                        this.timer?.Stop();
                        await this.CloseCommand.ExecuteAsync(null);
                    }
                    catch (Exception Ex)
                    {
                        ServiceRef.LogService.LogException(Ex);
                    }
                }
            });
        }
 
        protected override Task OnPopAsync()
        {
            this.timer?.Stop();
            return base.OnPopAsync();
        }
 
        #endregion
    }
}