App.xaml.cs

//
// Copyright Fela Ameghino & Contributors 2015-2025
//
// Distributed under the GNU General Public License v3.0. (See accompanying
// file LICENSE or copy at https://www.gnu.org/licenses/gpl-3.0.txt)
//
using System;
using System.Linq;
using System.Threading.Tasks;
using Telegram.Common;
using Telegram.Navigation;
using Telegram.Navigation.Services;
using Telegram.Services;
using Telegram.Services.Updates;
using Telegram.ViewModels;
using Telegram.ViewModels.Authorization;
using Telegram.ViewModels.Business;
using Telegram.ViewModels.Chats;
using Telegram.ViewModels.Create;
using Telegram.ViewModels.Delegates;
using Telegram.ViewModels.Folders;
using Telegram.ViewModels.Payments;
using Telegram.ViewModels.Premium;
using Telegram.ViewModels.Settings;
using Telegram.ViewModels.Settings.Privacy;
using Telegram.ViewModels.Stars;
using Telegram.ViewModels.Supergroups;
using Telegram.ViewModels.Users;
using Telegram.Views;
using Telegram.Views.Authorization;
using Telegram.Views.Business;
using Telegram.Views.Chats;
using Telegram.Views.Create;
using Telegram.Views.Folders;
using Telegram.Views.Folders.Popups;
using Telegram.Views.Host;
using Telegram.Views.Payments;
using Telegram.Views.Popups;
using Telegram.Views.Premium.Popups;
using Telegram.Views.Settings;
using Telegram.Views.Settings.Popups;
using Telegram.Views.Settings.Privacy;
using Telegram.Views.Stars;
using Telegram.Views.Stars.Popups;
using Telegram.Views.Stories.Popups;
using Telegram.Views.Supergroups;
using Telegram.Views.Supergroups.Popups;
using Telegram.Views.Users;
using Windows.ApplicationModel;
using Windows.ApplicationModel.Activation;
using Windows.ApplicationModel.AppService;
using Windows.ApplicationModel.DataTransfer;
using Windows.ApplicationModel.DataTransfer.ShareTarget;
using Windows.ApplicationModel.ExtendedExecution;
using Windows.UI.Notifications;
using Windows.UI.ViewManagement;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;

namespace Telegram
{
    sealed partial class App : BootStrapper
    {
        public static ShareOperation ShareOperation { get; set; }

        public static DataPackageView DataPackage { get; set; }

        private static ExtendedExecutionSession _extendedSession;

        /// <summary>
        /// Initializes a new instance of the <see cref="App"/> class.
        /// Initializes the singleton application object.  This is the first line of authored code
        /// executed, and as such is the logical equivalent of main() or WinMain().
        /// </summary>
        public App()
        {
            TypeCrosserGenerator.Generate();

            if (SettingsService.Current.Diagnostics.LastUpdateVersion < Constants.BuildNumber)
            {
                SettingsService.Current.Diagnostics.LastUpdateVersion = Constants.BuildNumber;
                SettingsService.Current.Diagnostics.UpdateCount++;
            }

            WatchDog.Initialize();
            TypeResolver.Current.Configure();

            RequestedTheme = SettingsService.Current.Appearance.GetCalculatedApplicationTheme();
            InitializeComponent();
        }

        protected override void OnWindowActivated(Window window, bool active)
        {
            SettingsService.Current.Appearance.UpdateTimer();

            var navigation = WindowContext.GetNavigationService(window);
            if (navigation != null)
            {
                var aggregator = TypeResolver.Current.Resolve<IEventAggregator>(navigation.SessionId);
                aggregator?.Publish(new UpdateWindowActivated(active));

                var clientService = TypeResolver.Current.Resolve<IClientService>(navigation.SessionId);
                if (clientService != null)
                {
                    clientService.Options.Online = active;
                }
            }
        }

        protected override async void OnBackgroundActivated(BackgroundActivatedEventArgs args)
        {
            base.OnBackgroundActivated(args);

            if (args.TaskInstance.TriggerDetails is AppServiceTriggerDetails appService && string.Equals(appService.CallerPackageFamilyName, Package.Current.Id.FamilyName))
            {
                NotifyIcon.Connect(appService.AppServiceConnection, args.TaskInstance);
            }
            else
            {
                var deferral = args.TaskInstance.GetDeferral();

                if (args.TaskInstance.TriggerDetails is ToastNotificationActionTriggerDetail triggerDetail)
                {
                    var data = Toast.GetData(triggerDetail);
                    if (data == null)
                    {
                        deferral.Complete();
                        return;
                    }

                    var session = TypeResolver.Current.Lifetime.ActiveItem.Id;
                    if (data.TryGetValue("session", out string value) && int.TryParse(value, out int result))
                    {
                        session = result;
                    }

                    if (TypeResolver.Current.TryResolve(session, out INotificationsService service))
                    {
                        await service.ProcessAsync(data);
                    }
                }

                deferral.Complete();
            }
        }

        public override void OnInitialize(IActivatedEventArgs args)
        {
            //Locator.Configure();
            //UnigramContainer.Current.ResolveType<IGenerationService>();

            if (TypeResolver.Current.Passcode.IsEnabled)
            {
                TypeResolver.Current.Passcode.Lock(true);
                InactivityHelper.Initialize(TypeResolver.Current.Passcode.AutolockTimeout);
            }
        }

        public override async void OnStart(StartKind startKind, IActivatedEventArgs args)
        {
#if DEBUG
            DebugSettings.EnableFrameRateCounter = false;
#endif

            if (startKind == StartKind.Activate)
            {
                var lifetime = TypeResolver.Current.Lifetime;
                var sessionId = lifetime.ActiveItem.Id;

                var id = Toast.GetSession(args);
                if (id != null)
                {
                    lifetime.ActiveItem = lifetime.Items.FirstOrDefault(x => x.Id == id.Value) ?? lifetime.ActiveItem;
                }

                if (sessionId != TypeResolver.Current.Lifetime.ActiveItem.Id)
                {
                    var root = Window.Current.Content as RootPage;
                    root?.Switch(lifetime.ActiveItem);
                }
            }

            var navigation = WindowContext.Current.NavigationServices.GetByFrameId($"{TypeResolver.Current.Lifetime.ActiveItem.Id}");

            var update = TypeResolver.Current.Resolve<ICloudUpdateService>();
            var service = TypeResolver.Current.Resolve<IClientService>();

            var state = await service.GetAuthorizationStateAsync();

            if (args is not ShareTargetActivatedEventArgs share)
            {
                WindowContext.Current.Activate(args, navigation, state);

                _ = Task.Run(() => OnStartSync(startKind, navigation, update));

                if (startKind != StartKind.Launch && WindowContext.Current.IsInMainView)
                {
                    var view = ApplicationView.GetForCurrentView();
                    await ApplicationViewSwitcher.TryShowAsStandaloneAsync(view.Id);
                    //view.TryResizeView(WindowContext.Current.Bounds.ToSize());
                }
            }
            else if (WindowContext.Current.Content is SharePage sharePage)
            {
                sharePage.Activate(share, navigation, state);
            }
        }

        public override UIElement CreateRootElement(IActivatedEventArgs e, WindowContext window)
        {
            var id = Toast.GetSession(e);
            if (id != null)
            {
                TypeResolver.Current.Lifetime.ActiveItem = TypeResolver.Current.Lifetime.Items.FirstOrDefault(x => x.Id == id.Value) ?? TypeResolver.Current.Lifetime.ActiveItem;
            }

            var sessionId = TypeResolver.Current.Lifetime.ActiveItem.Id;

            var navigationFrame = new Frame();
            var navigationService = NavigationServiceFactory(window, BackButton.Ignore, navigationFrame, sessionId, $"{sessionId}", true) as NavigationService;

            if (e is ShareTargetActivatedEventArgs)
            {
                return new SharePage(window, sessionId)
                {
                    FlowDirection = LocaleService.Current.FlowDirection
                };
            }

            return new RootPage(window, navigationService)
            {
                FlowDirection = LocaleService.Current.FlowDirection
            };
        }

        public override UIElement CreateRootElement(INavigationService navigationService)
        {
            return new StandalonePage(navigationService)
            {
                FlowDirection = LocaleService.Current.FlowDirection
            };
        }

        protected override INavigationService CreateNavigationService(WindowContext window, Frame frame, int session, string id, bool root)
        {
            if (root)
            {
                return new TLRootNavigationService(TypeResolver.Current.Resolve<ISessionService>(session), window, frame, session, id);
            }

            return new TLNavigationService(TypeResolver.Current.Resolve<IClientService>(session), TypeResolver.Current.Resolve<IViewService>(session), window, frame, id);
        }

        private async void OnStartSync(StartKind startKind, INavigationService navigation, ICloudUpdateService updateService = null)
        {
            await RequestExtendedExecutionSessionAsync();
            await Toast.RegisterBackgroundTasks();

            try
            {
                TileUpdateManager.CreateTileUpdaterForApplication("App").Clear();
            }
            catch { }

            try
            {
                ToastNotificationManager.History.Clear("App");
            }
            catch { }

            if (Constants.RELEASE && startKind == StartKind.Launch)
            {
                if (await CloudUpdateService.LaunchAsync(navigation, true))
                {
                    return;
                }
            }

            if (SettingsService.Current.IsTrayVisible)
            {
                await NotifyIcon.LaunchAsync();
            }

            Windows.ApplicationModel.Core.CoreApplication.EnablePrelaunch(true);

            if (updateService != null)
            {
                await updateService.UpdateAsync(false);
            }
        }

        private async Task RequestExtendedExecutionSessionAsync()
        {
            if (_extendedSession == null && ApiInfo.IsDesktop)
            {
                var session = new ExtendedExecutionSession();
                session.Reason = ExtendedExecutionReason.Unspecified;
                session.Revoked += ExtendedExecutionSession_Revoked;

                var result = await session.RequestExtensionAsync();
                if (result == ExtendedExecutionResult.Allowed)
                {
                    _extendedSession = session;

                    Logger.Info("ExtendedExecutionResult.Allowed");
                }
                else
                {
                    session.Revoked -= ExtendedExecutionSession_Revoked;
                    session.Dispose();

                    Logger.Warning("ExtendedExecutionResult.Denied");
                }
            }
        }

        private void ExtendedExecutionSession_Revoked(object sender, ExtendedExecutionRevokedEventArgs args)
        {
            Logger.Warning(args.Reason);

            if (_extendedSession != null)
            {
                _extendedSession.Dispose();
                _extendedSession = null;
            }
        }

        public override void OnResuming(object s, object e, AppExecutionState previousExecutionState)
        {
            Logger.Info("OnResuming");

            // #1225: Will this work? No one knows.
            foreach (var network in TypeResolver.Current.ResolveAll<INetworkService>())
            {
                network.Reconnect();
            }

            //foreach (var client in TLContainer.Current.ResolveAll<IClientService>())
            //{
            //    client.TryInitialize();
            //}

            // #2034: Will this work? No one knows.
            SettingsService.Current.Appearance.UpdateNightMode(null);

            OnStartSync(StartKind.Activate, WindowContext.Current.GetNavigationService());
        }

        public override Task OnSuspendingAsync(object s, SuspendingEventArgs e)
        {
            Logger.Info("OnSuspendingAsync");

            TypeResolver.Current.Passcode.CloseTime = DateTime.UtcNow;

            //return Task.WhenAll(TypeResolver.Current.ResolveAll<IVoipService>().Select(x => x.DiscardAsync()));
            //await Task.WhenAll(TLContainer.Current.ResolveAll<IClientService>().Select(x => x.CloseAsync()));
            return Task.CompletedTask;
        }

        public override ViewModelBase ViewModelForPage(UIElement page, int sessionId)
        {
            return page switch
            {
                DiagnosticsPage => TypeResolver.Current.Resolve<DiagnosticsViewModel>(sessionId),
                LogOutPopup => TypeResolver.Current.Resolve<LogOutViewModel>(sessionId),
                ProfilePage profile => TypeResolver.Current.Resolve<ProfileViewModel, IProfileDelegate>(profile, sessionId),
                InstantPage => TypeResolver.Current.Resolve<InstantViewModel>(sessionId),
                //
                SettingsPage settings => TypeResolver.Current.Resolve<SettingsViewModel, ISettingsDelegate>(settings, sessionId),
                NewContactPopup => TypeResolver.Current.Resolve<NewContactViewModel>(sessionId),
                NewChannelPopup => TypeResolver.Current.Resolve<NewChannelViewModel>(sessionId),
                NewGroupPopup => TypeResolver.Current.Resolve<NewGroupViewModel>(sessionId),
                UserEditPage userEdit => TypeResolver.Current.Resolve<UserEditViewModel, IUserDelegate>(userEdit, sessionId),
                UserAffiliatePage => TypeResolver.Current.Resolve<UserAffiliateViewModel>(sessionId),
                //
                SupergroupChooseMemberPopup => TypeResolver.Current.Resolve<SupergroupChooseMemberViewModel>(sessionId),
                SupergroupAdministratorsPage supergroupAdministrators => TypeResolver.Current.Resolve<SupergroupAdministratorsViewModel, ISupergroupDelegate>(supergroupAdministrators, sessionId),
                SupergroupBannedPage supergroupBanned => TypeResolver.Current.Resolve<SupergroupBannedViewModel, ISupergroupDelegate>(supergroupBanned, sessionId),
                SupergroupEditAdministratorPopup supergroupEditAdministrator => TypeResolver.Current.Resolve<SupergroupEditAdministratorViewModel, IMemberPopupDelegate>(supergroupEditAdministrator, sessionId),
                SupergroupEditLinkedChatPage supergroupEditLinkedChat => TypeResolver.Current.Resolve<SupergroupEditLinkedChatViewModel, ISupergroupDelegate>(supergroupEditLinkedChat, sessionId),
                SupergroupEditRestrictedPopup supergroupEditRestricted => TypeResolver.Current.Resolve<SupergroupEditRestrictedViewModel, IMemberPopupDelegate>(supergroupEditRestricted, sessionId),
                SupergroupEditStickerSetPopup => TypeResolver.Current.Resolve<SupergroupEditStickerSetViewModel>(sessionId),
                SupergroupEditTypePage supergroupEditType => TypeResolver.Current.Resolve<SupergroupEditTypeViewModel, ISupergroupEditDelegate>(supergroupEditType, sessionId),
                SupergroupEditPage supergroupEdit => TypeResolver.Current.Resolve<SupergroupEditViewModel, ISupergroupEditDelegate>(supergroupEdit, sessionId),
                SupergroupMembersPage supergroupMembers => TypeResolver.Current.Resolve<SupergroupMembersViewModel, ISupergroupDelegate>(supergroupMembers, sessionId),
                SupergroupPermissionsPage supergroupPermissions => TypeResolver.Current.Resolve<SupergroupPermissionsViewModel, ISupergroupDelegate>(supergroupPermissions, sessionId),
                SupergroupReactionsPopup => TypeResolver.Current.Resolve<SupergroupReactionsViewModel>(sessionId),
                SupergroupProfileColorPage => TypeResolver.Current.Resolve<SupergroupProfileColorViewModel>(sessionId),
                ChatBoostsPage => TypeResolver.Current.Resolve<ChatBoostsViewModel>(sessionId),
                ChatAffiliatePage => TypeResolver.Current.Resolve<ChatAffiliateViewModel>(sessionId),
                //
                AuthorizationRecoveryPage => TypeResolver.Current.Resolve<AuthorizationRecoveryViewModel>(sessionId),
                AuthorizationRegistrationPage => TypeResolver.Current.Resolve<AuthorizationRegistrationViewModel>(sessionId),
                AuthorizationPasswordPage => TypeResolver.Current.Resolve<AuthorizationPasswordViewModel>(sessionId),
                AuthorizationCodePage => TypeResolver.Current.Resolve<AuthorizationCodeViewModel>(sessionId),
                AuthorizationEmailAddressPage => TypeResolver.Current.Resolve<AuthorizationEmailAddressViewModel>(sessionId),
                AuthorizationEmailCodePage => TypeResolver.Current.Resolve<AuthorizationEmailCodeViewModel>(sessionId),
                AuthorizationPage signIn => TypeResolver.Current.Resolve<AuthorizationViewModel, ISignInDelegate>(signIn, sessionId),
                //
                FoldersPage => TypeResolver.Current.Resolve<FoldersViewModel>(sessionId),
                FolderPage => TypeResolver.Current.Resolve<FolderViewModel>(sessionId),
                ShareFolderPopup => TypeResolver.Current.Resolve<ShareFolderViewModel>(sessionId),
                AddFolderPopup => TypeResolver.Current.Resolve<AddFolderViewModel>(sessionId),
                RemoveFolderPopup => TypeResolver.Current.Resolve<RemoveFolderViewModel>(sessionId),
                //
                SettingsBlockedChatsPage => TypeResolver.Current.Resolve<SettingsBlockedChatsViewModel>(sessionId),
                SettingsStickersPage => TypeResolver.Current.Resolve<SettingsStickersViewModel>(sessionId),
                //
                SettingsThemePage => TypeResolver.Current.Resolve<SettingsThemeViewModel>(sessionId),
                //
                SettingsAdvancedPage => TypeResolver.Current.Resolve<SettingsAdvancedViewModel>(sessionId),
                SettingsAppearancePage => TypeResolver.Current.Resolve<SettingsAppearanceViewModel>(sessionId),
                SettingsAutoDeletePage => TypeResolver.Current.Resolve<SettingsAutoDeleteViewModel>(sessionId),
                SettingsBackgroundsPage => TypeResolver.Current.Resolve<SettingsBackgroundsViewModel>(sessionId),
                SettingsDataAndStoragePage => TypeResolver.Current.Resolve<SettingsDataAndStorageViewModel>(sessionId),
                SettingsLanguagePage => TypeResolver.Current.Resolve<SettingsLanguageViewModel>(sessionId),
                SettingsNetworkPage => TypeResolver.Current.Resolve<SettingsNetworkViewModel>(sessionId),
                SettingsNightModePage => TypeResolver.Current.Resolve<SettingsNightModeViewModel>(sessionId),
                SettingsNotificationsExceptionsPage => TypeResolver.Current.Resolve<SettingsNotificationsExceptionsViewModel>(sessionId),
                SettingsPasscodePage => TypeResolver.Current.Resolve<SettingsPasscodeViewModel>(sessionId),
                SettingsPasswordPage => TypeResolver.Current.Resolve<SettingsPasswordViewModel>(sessionId),
                SettingsPrivacyAndSecurityPage => TypeResolver.Current.Resolve<SettingsPrivacyAndSecurityViewModel>(sessionId),
                SettingsProxyPage => TypeResolver.Current.Resolve<SettingsProxyViewModel>(sessionId),
                SettingsProxyPopup => TypeResolver.Current.Resolve<SettingsProxyViewModel>(sessionId),
                SettingsShortcutsPage => TypeResolver.Current.Resolve<SettingsShortcutsViewModel>(sessionId),
                SettingsThemesPage => TypeResolver.Current.Resolve<SettingsThemesViewModel>(sessionId),
                SettingsWebSessionsPage => TypeResolver.Current.Resolve<SettingsWebSessionsViewModel>(sessionId),
                SettingsNotificationsPage => TypeResolver.Current.Resolve<SettingsNotificationsViewModel>(sessionId),
                SettingsSessionsPage => TypeResolver.Current.Resolve<SettingsSessionsViewModel>(sessionId),
                SettingsStoragePage => TypeResolver.Current.Resolve<SettingsStorageViewModel>(sessionId),
                SettingsProfilePage settingsProfilePage => TypeResolver.Current.Resolve<SettingsProfileViewModel, IUserDelegate>(settingsProfilePage, sessionId),
                SettingsProfileColorPage => TypeResolver.Current.Resolve<SettingsProfileColorViewModel>(sessionId),
                SettingsPowerSavingPage => TypeResolver.Current.Resolve<SettingsPowerSavingViewModel>(sessionId),
                SettingsPrivacyAllowCallsPage => TypeResolver.Current.Resolve<SettingsPrivacyAllowCallsViewModel>(sessionId),
                SettingsPrivacyAllowChatInvitesPage => TypeResolver.Current.Resolve<SettingsPrivacyAllowChatInvitesViewModel>(sessionId),
                SettingsPrivacyAllowP2PCallsPage => TypeResolver.Current.Resolve<SettingsPrivacyAllowP2PCallsViewModel>(sessionId),
                SettingsPrivacyAllowPrivateVoiceAndVideoNoteMessagesPage => TypeResolver.Current.Resolve<SettingsPrivacyAllowPrivateVoiceAndVideoNoteMessagesViewModel>(sessionId),
                SettingsPrivacyShowForwardedPage => TypeResolver.Current.Resolve<SettingsPrivacyShowForwardedViewModel>(sessionId),
                SettingsPrivacyPhonePage => TypeResolver.Current.Resolve<SettingsPrivacyPhoneViewModel>(sessionId),
                SettingsPrivacyShowPhotoPage privacyShowPhotoPage => TypeResolver.Current.Resolve<SettingsPrivacyShowPhotoViewModel, IUserDelegate>(privacyShowPhotoPage, sessionId),
                SettingsPrivacyShowStatusPage => TypeResolver.Current.Resolve<SettingsPrivacyShowStatusViewModel>(sessionId),
                SettingsPrivacyShowBioPage => TypeResolver.Current.Resolve<SettingsPrivacyShowBioViewModel>(sessionId),
                SettingsPrivacyShowBirthdatePage => TypeResolver.Current.Resolve<SettingsPrivacyShowBirthdateViewModel>(sessionId),
                SettingsPrivacyNewChatPage => TypeResolver.Current.Resolve<SettingsPrivacyNewChatViewModel>(sessionId),
                SettingsPrivacyAutosaveGiftsPage => TypeResolver.Current.Resolve<SettingsPrivacyAutosaveGiftsViewModel>(sessionId),

                BusinessPage => TypeResolver.Current.Resolve<BusinessViewModel>(sessionId),
                BusinessLocationPage => TypeResolver.Current.Resolve<BusinessLocationViewModel>(sessionId),
                BusinessHoursPage => TypeResolver.Current.Resolve<BusinessHoursViewModel>(sessionId),
                BusinessRepliesPage businessRepliesPage => TypeResolver.Current.Resolve<BusinessRepliesViewModel, IBusinessRepliesDelegate>(businessRepliesPage, sessionId),
                BusinessGreetPage => TypeResolver.Current.Resolve<BusinessGreetViewModel>(sessionId),
                BusinessAwayPage => TypeResolver.Current.Resolve<BusinessAwayViewModel>(sessionId),
                BusinessBotsPage => TypeResolver.Current.Resolve<BusinessBotsViewModel>(sessionId),
                BusinessIntroPage => TypeResolver.Current.Resolve<BusinessIntroViewModel>(sessionId),
                BusinessChatLinksPage businessChatLinksPage => TypeResolver.Current.Resolve<BusinessChatLinksViewModel, IBusinessChatLinksDelegate>(businessChatLinksPage, sessionId),

                RevenuePage => TypeResolver.Current.Resolve<RevenueViewModel>(sessionId),

                PaymentFormPage => TypeResolver.Current.Resolve<PaymentFormViewModel>(sessionId),
                MessageStatisticsPage => TypeResolver.Current.Resolve<MessageStatisticsViewModel>(sessionId),
                ChatInviteLinksPage => TypeResolver.Current.Resolve<ChatInviteLinksViewModel>(sessionId),
                ChatStatisticsPage => TypeResolver.Current.Resolve<ChatStatisticsViewModel>(sessionId),
                ChatRevenuePage => TypeResolver.Current.Resolve<ChatRevenueViewModel>(sessionId),
                ChatStarsPage => TypeResolver.Current.Resolve<ChatStarsViewModel>(sessionId),
                ChatStoriesPage => TypeResolver.Current.Resolve<ChatStoriesViewModel>(sessionId),

                // Popups
                ContactsPopup => TypeResolver.Current.Resolve<ContactsViewModel>(sessionId),
                CallsPopup => TypeResolver.Current.Resolve<CallsViewModel>(sessionId),
                DownloadsPopup => TypeResolver.Current.Resolve<DownloadsViewModel>(sessionId),
                SettingsUsernamePopup => TypeResolver.Current.Resolve<SettingsUsernameViewModel>(sessionId),
                SettingsDataAutoPopup => TypeResolver.Current.Resolve<SettingsDataAutoViewModel>(sessionId),
                ChooseChatsPopup => TypeResolver.Current.Resolve<ChooseChatsViewModel>(sessionId),
                ChooseSoundPopup => TypeResolver.Current.Resolve<ChooseSoundViewModel>(sessionId),
                ChatNotificationsPopup => TypeResolver.Current.Resolve<ChatNotificationsViewModel>(sessionId),
                CreateChatPhotoPopup => TypeResolver.Current.Resolve<CreateChatPhotoViewModel>(sessionId),
                PromoPopup => TypeResolver.Current.Resolve<PromoViewModel>(sessionId),
                StarsPage => TypeResolver.Current.Resolve<StarsViewModel>(sessionId),
                BuyPopup => TypeResolver.Current.Resolve<BuyViewModel>(sessionId),
                PayPopup => TypeResolver.Current.Resolve<PayViewModel>(sessionId),
                StoryInteractionsPopup => TypeResolver.Current.Resolve<StoryInteractionsViewModel>(sessionId),
                BackgroundsPopup => TypeResolver.Current.Resolve<SettingsBackgroundsViewModel>(sessionId),
                BackgroundPopup backgroundPopup => TypeResolver.Current.Resolve<BackgroundViewModel, IBackgroundDelegate>(backgroundPopup, sessionId),
                _ => null
            };
        }
    }
}