ServiceRef.cs

using System.Diagnostics;
using System.Dynamic;
using System.Globalization;
using System.Reflection;
using Microsoft.Extensions.Localization;
using NeuroAccessMaui.Resources.Languages;
using NeuroAccessMaui.Services.AttachmentCache;
using NeuroAccessMaui.Services.Contracts;
using NeuroAccessMaui.Services.Crypto;
using NeuroAccessMaui.Services.EventLog;
using NeuroAccessMaui.Services.Localization;
using NeuroAccessMaui.Services.Network;
using NeuroAccessMaui.Services.Nfc;
using NeuroAccessMaui.Services.Notification;
using NeuroAccessMaui.Services.Push;
using NeuroAccessMaui.Services.Settings;
using NeuroAccessMaui.Services.Storage;
using NeuroAccessMaui.Services.Tag;
using NeuroAccessMaui.Services.ThingRegistries;
using NeuroAccessMaui.Services.UI;
using NeuroAccessMaui.Services.Wallet;
using NeuroAccessMaui.Services.Xmpp;
using ZXing;
 
namespace NeuroAccessMaui.Services
{
    public static class ServiceRef
    {
        private static IXmppService? xmppService;
        private static IUiService? uiService;
        private static ITagProfile? tagProfile;
        private static ILogService? logService;
        private static INetworkService? networkService;
        private static IContractOrchestratorService? contractOrchestratorService;
        private static IThingRegistryOrchestratorService? thingRegistryOrchestratorService;
        private static INeuroWalletOrchestratorService? neuroWalletOrchestratorService;
        private static IAttachmentCacheService? attachmentCacheService;
        private static ICryptoService? cryptoService;
        private static ISettingsService? settingsService;
        private static IStorageService? storageService;
        private static INfcService? nfcService;
        private static INotificationService? notificationService;
        private static IPushNotificationService? pushNotificationService;
        private static IStringLocalizer? localizer;
        private static IPlatformSpecific? platformSpecific;
        private static IBarcodeReader? barcodeReader;
 
        public static IUiService UiService
        {
            get
            {
                uiService ??= App.Instantiate<IUiService>();
                return uiService;
            }
        }
 
        public static IXmppService XmppService
        {
            get
            {
                xmppService ??= App.Instantiate<IXmppService>();
                return xmppService;
            }
        }
 
        public static ITagProfile TagProfile
        {
            get
            {
                tagProfile ??= App.Instantiate<ITagProfile>();
                return tagProfile;
            }
        }
 
        public static ILogService LogService
        {
            get
            {
                logService ??= App.Instantiate<ILogService>();
                return logService;
            }
        }
 
        public static INetworkService NetworkService
        {
            get
            {
                networkService ??= App.Instantiate<INetworkService>();
                return networkService;
            }
        }
 
        public static IContractOrchestratorService ContractOrchestratorService
        {
            get
            {
                contractOrchestratorService ??= App.Instantiate<IContractOrchestratorService>();
                return contractOrchestratorService;
            }
        }
 
        public static IThingRegistryOrchestratorService ThingRegistryOrchestratorService
        {
            get
            {
                thingRegistryOrchestratorService ??= App.Instantiate<IThingRegistryOrchestratorService>();
                return thingRegistryOrchestratorService;
            }
        }
 
        public static INeuroWalletOrchestratorService NeuroWalletOrchestratorService
        {
            get
            {
                neuroWalletOrchestratorService ??= App.Instantiate<INeuroWalletOrchestratorService>();
                return neuroWalletOrchestratorService;
            }
        }
 
        public static IAttachmentCacheService AttachmentCacheService
        {
            get
            {
                attachmentCacheService ??= App.Instantiate<IAttachmentCacheService>();
                return attachmentCacheService;
            }
        }
 
        public static ICryptoService CryptoService
        {
            get
            {
                cryptoService ??= App.Instantiate<ICryptoService>();
                return cryptoService;
            }
        }
 
        public static ISettingsService SettingsService
        {
            get
            {
                settingsService ??= App.Instantiate<ISettingsService>();
                return settingsService;
            }
        }
 
        public static IStorageService StorageService
        {
            get
            {
                storageService ??= App.Instantiate<IStorageService>();
                return storageService;
            }
        }
 
        public static INfcService NfcService
        {
            get
            {
                nfcService ??= App.Instantiate<INfcService>();
                return nfcService;
            }
        }
 
        public static INotificationService NotificationService
        {
            get
            {
                notificationService ??= App.Instantiate<INotificationService>();
                return notificationService;
            }
        }
 
        public static IPushNotificationService PushNotificationService
        {
            get
            {
                pushNotificationService ??= App.Instantiate<IPushNotificationService>();
                return pushNotificationService;
            }
        }
 
        public static IStringLocalizer Localizer
        {
            get
            {
                localizer ??= new LocalizerReportingMissingStrings(LocalizationManager.GetStringLocalizer<AppResources>());
                return localizer;
            }
        }
 
        private class LocalizerReportingMissingStrings(IStringLocalizer Localizer) : IStringLocalizer
        {
            private readonly IStringLocalizer localizer = Localizer;
 
            public LocalizedString this[string Name]
            {
                get
                {
                    LocalizedString Result = this.localizer[Name];
                    if (Result is not null && !Result.ResourceNotFound)
                        return Result;
 
                    StackTrace Trace = new();
                    Type Caller = typeof(ServiceRef);
                    int i, c = Trace.FrameCount;
                    Assembly ThisAssembly = typeof(App).Assembly;
 
                    for (i = 1; i < c; i++)
                    {
                        Type? T = Trace.GetFrame(i)?.GetMethod()?.DeclaringType;
                        if (T is null)
                            continue;
 
                        if (T.Assembly.FullName == ThisAssembly.FullName)
                        {
                            if (T == typeof(LocalizerReportingMissingStrings))
                                continue;
 
                            if (T.IsConstructedGenericType)
                                T = T.GetGenericTypeDefinition();
 
                            Caller = T;
                            break;
                        }
                    }
 
                    LocalizeExtension.ReportMissingString(Name, Caller);
 
                    return new LocalizedString(Name, Name, true);
                }
            }
 
            public LocalizedString this[string Name, params object[] Arguments]
            {
                get
                {
                    LocalizedString Result = this[Name];
                    if (Result.ResourceNotFound)
                        return Result;
 
                    return new LocalizedString(Name, string.Format(CultureInfo.CurrentCulture, Result.Value, Arguments));
                }
            }
 
            public IEnumerable<LocalizedString> GetAllStrings(bool includeParentCultures)
            {
                return this.localizer.GetAllStrings(includeParentCultures);
            }
        }
 
        public static IPlatformSpecific PlatformSpecific
        {
            get
            {
                platformSpecific ??= ServiceHelper.GetService<IPlatformSpecific>();
                return platformSpecific;
            }
        }
 
 
        public static IBarcodeReader BarcodeReader
        {
            get
            {
                barcodeReader ??= ServiceHelper.GetService<IBarcodeReader>();
                return barcodeReader;
            }
        }
    }
}