PlatformSpecific.cs

using Foundation;
using LocalAuthentication;
using NeuroAccessMaui.Services.Push;
using ObjCRuntime;
using System.Diagnostics.CodeAnalysis;
using UIKit;
using Waher.Events;
using Waher.Networking.XMPP.Push;
using Security;
using System.Text;
using CommunityToolkit.Mvvm.Messaging;
using Plugin.Firebase.CloudMessaging;
using UserNotifications;
 
namespace NeuroAccessMaui.Services
{
    public class PlatformSpecific : IPlatformSpecific
    {
        private LAContext? localAuthenticationContext;
        private bool isDisposed;
 
        public PlatformSpecific()
        {
            NSNotificationCenter.DefaultCenter.AddObserver(UIKeyboard.WillShowNotification, this.OnKeyboardWillShow);
            NSNotificationCenter.DefaultCenter.AddObserver(UIKeyboard.WillHideNotification, this.OnKeyboardWillHide);
        }
 
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }
 
        protected virtual void Dispose(bool Disposing)
        {
            if (this.isDisposed)
                return;
 
            NSNotificationCenter.DefaultCenter.RemoveObserver(UIKeyboard.WillShowNotification);
            NSNotificationCenter.DefaultCenter.RemoveObserver(UIKeyboard.WillHideNotification);
 
            if (Disposing)
                this.DisposeLocalAuthenticationContext();
 
            this.isDisposed = true;
        }
 
        public bool CanProhibitScreenCapture => false;
 
        public bool ProhibitScreenCapture // iOS doesn't support screen protection
        {
            get => false;
            set => _ = value; // ignore the value
        }
 
        public string? GetDeviceId()
        {
            try
            {
                string ServiceName = AppInfo.PackageName;
                const string AccountName = "DeviceIdentifier"; //Basically the key
 
                // Define the search criteria for the SecRecord
                SecRecord searchRecord = new(SecKind.GenericPassword)
                {
                    Service = ServiceName,
                    Account = AccountName
                };
 
                // Try to retrieve the existing device identifier from the Keychain
                SecRecord? existingRecord = SecKeyChain.QueryAsRecord(searchRecord, out SecStatusCode resultCode);
                if (resultCode == SecStatusCode.Success && existingRecord is not null && existingRecord?.ValueData is not null)
                {
                    // If the record exists, return the identifier
                    return existingRecord.ValueData.ToString(NSStringEncoding.UTF8);
                }
                else if (resultCode == SecStatusCode.ItemNotFound)
                {
                    // No existing record found, create a new device identifier
                    string identifier = UIDevice.CurrentDevice.IdentifierForVendor.ToString();
 
                    // Define the SecRecord for storing the new identifier
                    SecRecord newRecord = new(SecKind.GenericPassword)
                    {
                        Service = ServiceName,
                        Account = AccountName,
                        Label = "Persistent Device Identifier for Vendor",
                        ValueData = NSData.FromString(identifier),
                        Accessible = SecAccessible.WhenUnlockedThisDeviceOnly,
                        Synchronizable = false
                    };
 
                    // Sanity check: Remove any existing record, which should not exist
                    SecKeyChain.Remove(newRecord);
 
                    // Add the new item to the Keychain
                    SecStatusCode addResult = SecKeyChain.Add(newRecord);
                    if (addResult == SecStatusCode.Success)
                        return identifier; // Return the newly stored identifier
 
                    throw new Exception($"Unable to store device identifier in Keychain - Code: {addResult} - Description: {SecStatusCodeExtensions.GetStatusDescription(addResult)}");
                }
                else
                    throw new Exception($"Unable to retrieve device identifier from Keychain - Code: {resultCode} - Description: {SecStatusCodeExtensions.GetStatusDescription(resultCode)}");
            }
            catch (Exception ex)
            {
                try
                {
 
                    StringBuilder msg = new();
 
                    msg.Append(ex.Message);
                    msg.AppendLine("\n\n");
                    msg.AppendLine("```");
                    msg.AppendLine(ex.StackTrace);
                    msg.AppendLine("```");
 
                    App.SendAlertAsync(msg.ToString(), "text/plain").Wait();
                    this.CloseApplication().Wait();
                }
                catch (Exception)
                {
                    Environment.Exit(0);
                }
            }
            return null;
        }
 
        public Task CloseApplication()
        {
            if (this.localAuthenticationContext is not null)
            {
                if (this.localAuthenticationContext.RespondsToSelector(new Selector("invalidate")))
                    this.localAuthenticationContext.Invalidate();
 
                this.localAuthenticationContext.Dispose();
                this.localAuthenticationContext = null;
            }
 
            Environment.Exit(0);
            return Task.CompletedTask;
        }
 
        public void ShareImage(byte[] PngFile, string Message, string Title, string FileName)
        {
            UIImage? ImageObject = UIImage.LoadFromData(NSData.FromArray(PngFile));
            UIWindow? KeyWindow = UIApplication.SharedApplication?.KeyWindow;
 
            if ((ImageObject is null) || (KeyWindow is null))
                return;
 
            NSString MessageObject = new(Message);
            NSObject[] Items = [MessageObject, ImageObject];
            UIActivityViewController activityController = new(Items, null);
 
            UIViewController? topController = KeyWindow.RootViewController;
 
            if (topController is not null)
            {
                while (topController.PresentedViewController is not null)
                    topController = topController.PresentedViewController;
 
                topController.PresentViewController(activityController, true, () => { });
            }
        }
 
        /*
        public Task<byte[]> CaptureScreen(int blurRadius = 25)
        {
            blurRadius = Math.Min(25, Math.Max(blurRadius, 0));
            UIImage? capture;
 
            using UIBlurEffect blurEffect = UIBlurEffect.FromStyle(UIBlurEffectStyle.Regular);
            using UIVisualEffectView blurWindow = new(blurEffect);
 
            blurWindow.Frame = UIScreen.MainScreen.Bounds;
            blurWindow.Alpha = Math.Min(1.0f, (1.0f / 25.0f) * blurRadius);
 
            UIView? subview = UIScreen.MainScreen.SnapshotView(true);
            //capture = UIScreen.MainScreen.Capture();
            //var subview = new UIImageView(capture);
            subview?.AddSubview(blurWindow);
            capture = subview?.Capture(true);
            blurWindow.RemoveFromSuperview();
            subview?.Dispose();
 
            return Task.FromResult(Array.Empty<byte>());
        }
        */
        public bool SupportsFingerprintAuthentication
        {
            get
            {
                if (!this.HasLocalAuthenticationContext)
                    return false;
 
                try
                {
                    if (!this.localAuthenticationContext.CanEvaluatePolicy(LAPolicy.DeviceOwnerAuthenticationWithBiometrics, out _))
                        return false;
 
                    return true;
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                    return false;
                }
            }
        }
 
        public BiometricMethod GetBiometricMethod()
        {
            if (!this.HasLocalAuthenticationContext)
                return BiometricMethod.None;
 
            try
            {
                if (!this.localAuthenticationContext.CanEvaluatePolicy(LAPolicy.DeviceOwnerAuthenticationWithBiometrics, out _))
                    return BiometricMethod.None;
 
                return this.localAuthenticationContext.BiometryType switch
                {
                    LABiometryType.FaceId => BiometricMethod.FaceId,
                    LABiometryType.TouchId => BiometricMethod.TouchId,
                    _ => BiometricMethod.Unknown
                };
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                return BiometricMethod.Unknown;
            }
        }
 
        [MemberNotNullWhen(true, nameof(localAuthenticationContext))]
        private bool HasLocalAuthenticationContext
        {
            get
            {
                try
                {
                    if (this.localAuthenticationContext is null)
                    {
                        NSProcessInfo ProcessInfo = new();
                        NSOperatingSystemVersion MinVersion = new(10, 12, 0);
                        if (!ProcessInfo.IsOperatingSystemAtLeastVersion(MinVersion))
                            return false;
 
                        if (!UIDevice.CurrentDevice.CheckSystemVersion(8, 0))
                            return false;
 
                        if (Class.GetHandle(typeof(LAContext)) == IntPtr.Zero)
                            return false;
 
                        this.localAuthenticationContext = new LAContext();
                    }
 
                    return true;
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                    return false;
                }
            }
        }
 
        private void DisposeLocalAuthenticationContext()
        {
            if (this.localAuthenticationContext is not null)
            {
                if (this.localAuthenticationContext.RespondsToSelector(new Selector("invalidate")))
                    this.localAuthenticationContext.Invalidate();
 
                this.localAuthenticationContext.Dispose();
                this.localAuthenticationContext = null;
            }
        }
 
        public async Task<bool> AuthenticateUserFingerprint(string Title, string? Subtitle, string Description, string Cancel,
            CancellationToken? CancellationToken)
        {
            if (!this.HasLocalAuthenticationContext)
                return false;
 
            CancellationTokenRegistration? Registration = null;
 
            try
            {
                if (this.localAuthenticationContext.RespondsToSelector(new Selector("localizedFallbackTitle")))
                    this.localAuthenticationContext.LocalizedFallbackTitle = Title;
 
                if (this.localAuthenticationContext.RespondsToSelector(new Selector("localizedCancelTitle")))
                    this.localAuthenticationContext.LocalizedCancelTitle = Cancel;
 
                Registration = CancellationToken?.Register(this.DisposeLocalAuthenticationContext);
 
                (bool Success, NSError _) = await this.localAuthenticationContext.EvaluatePolicyAsync(LAPolicy.DeviceOwnerAuthenticationWithBiometrics, Description);
 
                this.DisposeLocalAuthenticationContext();
 
                return Success;
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                return false;
            }
            finally
            {
                if (Registration.HasValue)
                    Registration.Value.Dispose();
            }
        }
 
        public async Task<TokenInformation> GetPushNotificationToken()
        {
            string Token = string.Empty;
 
            try
            {
                await CrossFirebaseCloudMessaging.Current.CheckIfValidAsync();
                Token = await CrossFirebaseCloudMessaging.Current.GetTokenAsync();
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
 
            TokenInformation TokenInformation = new()
            {
                Token = Token,
                ClientType = ClientType.iOS,
                Service = PushMessagingService.Firebase
            };
 
            return TokenInformation;
        }
 
        #region Keyboard
        public event EventHandler<KeyboardSizeMessage>? KeyboardShown;
        public event EventHandler<KeyboardSizeMessage>? KeyboardHidden;
        public event EventHandler<KeyboardSizeMessage>? KeyboardSizeChanged;
 
 
        public void HideKeyboard()
        {
            AppDelegate.GetKeyWindow()?.EndEditing(true);
        }
 
        private void OnKeyboardWillShow(NSNotification notification)
        {
            CoreGraphics.CGRect keyboardFrame = UIKeyboard.FrameEndFromNotification(notification);
            float keyboardHeight = (float)keyboardFrame.Height;
            KeyboardShown.Raise(this, new KeyboardSizeMessage(keyboardHeight));
            KeyboardSizeChanged.Raise(this, new KeyboardSizeMessage(keyboardHeight));
            WeakReferenceMessenger.Default.Send(new KeyboardSizeMessage(keyboardHeight));
        }
 
        private void OnKeyboardWillHide(NSNotification notification)
        {
            float keyboardHeight = 0;
            KeyboardHidden.Raise(this, new KeyboardSizeMessage(keyboardHeight));
            KeyboardSizeChanged.Raise(this, new KeyboardSizeMessage(keyboardHeight));
            WeakReferenceMessenger.Default.Send(new KeyboardSizeMessage(keyboardHeight));
        }
 
 
        #endregion
 
        #region Notifications
        private async void ShowLocalNotification(string title, string body, IDictionary<string, string> data)
        {
            try
            {
                // Check current notification settings without prompting the user
                UNNotificationSettings Settings = await UNUserNotificationCenter.Current.GetNotificationSettingsAsync();
                if (Settings.AuthorizationStatus != UNAuthorizationStatus.Authorized)
                    return;
 
                // Create the notification content
                UNMutableNotificationContent Content = new UNMutableNotificationContent
                {
                    Title = title,
                    Body = body,
                    Sound = UNNotificationSound.Default
                };
 
                // Add any additional data as UserInfo
                if (data is not null)
                {
                    NSMutableDictionary UserInfo = new();
                    foreach (KeyValuePair<string, string> Pair in data)
                    {
                        UserInfo.SetValueForKey(new NSString(Pair.Value), new NSString(Pair.Key));
                    }
                    Content.UserInfo = UserInfo;
                }
 
                // Schedule the notification after a short delay
                UNTimeIntervalNotificationTrigger Trigger = UNTimeIntervalNotificationTrigger.CreateTrigger(1, false);
                UNNotificationRequest Request = UNNotificationRequest.FromIdentifier(Guid.NewGuid().ToString(), Content, Trigger);
                UNUserNotificationCenter.Current.AddNotificationRequest(Request, error =>
                {
                    if (error is not null)
                    {
                        ServiceRef.LogService.LogWarning($"Error scheduling notification: {error.LocalizedDescription}");
                    }
                });
 
            }
            catch (Exception ex)
            {
                return;
            }
        }
 
        // The following methods use the helper above.
        public void ShowMessageNotification(string Title, string MessageBody, IDictionary<string, string> Data)
        {
            this.ShowLocalNotification(Title, MessageBody, Data);
        }
 
        public void ShowIdentitiesNotification(string Title, string MessageBody, IDictionary<string, string> Data)
        {
            this.ShowLocalNotification(Title, MessageBody, Data);
        }
 
        public void ShowPetitionNotification(string Title, string MessageBody, IDictionary<string, string> Data)
        {
            this.ShowLocalNotification(Title, MessageBody, Data);
        }
 
        public void ShowContractsNotification(string Title, string MessageBody, IDictionary<string, string> Data)
        {
            this.ShowLocalNotification(Title, MessageBody, Data);
        }
 
        public void ShowEDalerNotification(string Title, string MessageBody, IDictionary<string, string> Data)
        {
            this.ShowLocalNotification(Title, MessageBody, Data);
        }
 
        public void ShowTokenNotification(string Title, string MessageBody, IDictionary<string, string> Data)
        {
            this.ShowLocalNotification(Title, MessageBody, Data);
        }
 
        public void ShowProvisioningNotification(string Title, string MessageBody, IDictionary<string, string> Data)
        {
            this.ShowLocalNotification(Title, MessageBody, Data);
        }
        #endregion
 
        public Thickness GetInsets()
        {
            // Try to get the current UIWindow.
            UIWindow? Window = AppDelegate.GetKeyWindow();
            if (Window is null)
                return new Thickness(0);
 
            // Prefer using the root view's SafeAreaLayoutGuide to compute insets.
            UIView? RootView = Window.RootViewController?.View;
            if (RootView is not null)
            {
                CoreGraphics.CGRect Bounds = RootView.Bounds;
                CoreGraphics.CGRect LayoutFrame = RootView.SafeAreaLayoutGuide.LayoutFrame;
 
                double Left = LayoutFrame.Left - Bounds.Left;
                double Top = LayoutFrame.Top - Bounds.Top;
                double Right = Bounds.Right - LayoutFrame.Right;
                double Bottom = Bounds.Bottom - LayoutFrame.Bottom;
 
                // Validate non-negative before returning.
                if (Left >= 0 && Top >= 0 && Right >= 0 && Bottom >= 0)
                    return new Thickness(Left, Top, Right, Bottom);
            }
 
            // Fallback to window safe area insets.
            UIEdgeInsets Insets = Window.SafeAreaInsets;
            return new Thickness(
                (double)Insets.Left,
                (double)Insets.Top,
                (double)Insets.Right,
                (double)Insets.Bottom);
        }
    }
}