Support for core selection based on file type

Author: albertofustinoni

.gitmodules

@@ -48,17 +48,17 @@
 	branch = master
 [submodule "BeetlePCEFast/src"]
 	path = BeetlePCEFast/src
-	url = https://github.com/Aftnet/beetle-pce-fast-libretro.git
+	url = https://github.com/libretro/beetle-pce-fast-libretro.git
 	branch = master
 [submodule "BeetleSaturn/src"]
 	path = BeetleSaturn/src
 	url = https://github.com/libretro/beetle-saturn-libretro.git
 	branch = master
 [submodule "BeetlePCFX/src"]
 	path = BeetlePCFX/src
-	url = https://github.com/Aftnet/beetle-pcfx-libretro.git
+	url = https://github.com/libretro/beetle-pcfx-libretro.git
 	branch = master
 [submodule "FBAlpha/src"]
 	path = FBAlpha/src
-	url = https://github.com/Aftnet/fbalpha.git
+	url = https://github.com/libretro/fbalpha.git
 	branch = master

BeetleNGP/src

@@ -21,6 +21,7 @@ public enum InjectedInputTypes
     };
 
     public delegate void CoresInitializedDelegate(IEmulationService sender);
+    public delegate void GameStoppedDelegate(IEmulationService sender);
     public delegate void GameStartedDelegate(IEmulationService sender);
     public delegate void GameRuntimeExceptionOccurredDelegate(IEmulationService sender, Exception exception);
 
@@ -32,7 +33,7 @@ public interface IEmulationService
 
         string GameID { get; }
 
-        Task<GameSystemVM> SuggestSystemForFileAsync(IFileInfo file);
+        Task<IEnumerable<GameSystemVM>> FilterSystemsForFileAsync(IFileInfo file);
         Task<bool> StartGameAsync(GameSystemVM system, IFileInfo file, IDirectoryInfo rootFolder = null);
 
         Task ResetGameAsync();
@@ -48,6 +49,7 @@ public interface IEmulationService
 
         event CoresInitializedDelegate CoresInitialized;
         event GameStartedDelegate GameStarted;
+        event GameStoppedDelegate GameStopped;
         event GameRuntimeExceptionOccurredDelegate GameRuntimeExceptionOccurred;
     }
 }

BeetlePCEFast/src

@@ -31,7 +31,15 @@ public class GameSystemSelectionVM : ViewModelBase
         private readonly IPlatformService PlatformService;
         private readonly IEmulationService EmulationService;
 
-        public IReadOnlyList<GameSystemVM> GameSystems => EmulationService.Systems;
+        private IFileInfo SelectedGameFile;
+
+        private IReadOnlyList<GameSystemVM> gameSystems;
+        public IReadOnlyList<GameSystemVM> GameSystems
+        {
+            get { return gameSystems; }
+            private set { Set(ref gameSystems, value); }
+        }
+
         public RelayCommand<GameSystemVM> GameSystemSelectedCommand { get; private set; }
 
         public GameSystemSelectionVM(IFileSystem fileSystem, IUserDialogs dialogsService, ILocalizationService localizationService, IPlatformService platformService, IEmulationService emulationService)
@@ -46,36 +54,56 @@ public GameSystemSelectionVM(IFileSystem fileSystem, IUserDialogs dialogsService
 
             EmulationService.CoresInitialized += OnCoresInitialized;
             EmulationService.GameRuntimeExceptionOccurred += OnGameRuntimeExceptionOccurred;
+            EmulationService.GameStopped += d => { ResetSystemsSelection(); };
+
+            ResetSystemsSelection();
         }
 
         public async void GameSystemSelected(GameSystemVM system)
         {
-            var extensions = system.SupportedExtensions.Concat(EmulationService.ArchiveExtensions).ToArray();
-            var file = await FileSystem.PickFileAsync(extensions);
-            if (file == null)
+            if (SelectedGameFile == null)
+            {
+                var extensions = system.SupportedExtensions.Concat(EmulationService.ArchiveExtensions).ToArray();
+                SelectedGameFile = await FileSystem.PickFileAsync(extensions);
+            }
+            if (SelectedGameFile == null)
             {
                 return;
             }
 
-            await StartGameAsync(system, file);
+            await StartGameAsync(system, SelectedGameFile);
         }
 
         public async Task StartGameFromFileAsync(IFileInfo file)
         {
-            var system = await EmulationService.SuggestSystemForFileAsync(file);
-            if (system == null)
+            //Find compatible systems for file extension
+            var compatibleSystems = await EmulationService.FilterSystemsForFileAsync(file);
+
+            //If none, do nothing
+            if (!compatibleSystems.Any())
             {
                 return;
             }
 
-            await StartGameAsync(system, file);
+            //If just one, start game with it
+            if (compatibleSystems.Count() == 1)
+            {
+                await StartGameAsync(compatibleSystems.First(), file);
+                return;
+            }
+
+            //If multiple ones, filter system selection accordingly and have user select a system
+            await EmulationService.StopGameAsync();
+            GameSystems = compatibleSystems.ToArray();
+            SelectedGameFile = file;
         }
 
         private async Task StartGameAsync(GameSystemVM system, IFileInfo file)
         {
             var dependenciesMet = await system.CheckDependenciesMetAsync();
             if (!dependenciesMet)
             {
+                ResetSystemsSelection();
                 await DisplayNotification(SystemUnmetDependenciesAlertTitleKey, SystemUnmetDependenciesAlertMessageKey);
                 return;
             }
@@ -88,11 +116,13 @@ private async Task StartGameAsync(GameSystemVM system, IFileInfo file)
                 folder = await FileSystem.PickDirectoryAsync();
                 if (folder == null)
                 {
+                    ResetSystemsSelection();
                     return;
                 }
 
                 if (!Path.GetDirectoryName(file.FullName).StartsWith(folder.FullName))
                 {
+                    ResetSystemsSelection();
                     await DisplayNotification(SelectFolderInvalidAlertTitleKey, SelectFolderInvalidAlertMessageKey);
                     return;
                 }
@@ -101,20 +131,29 @@ private async Task StartGameAsync(GameSystemVM system, IFileInfo file)
             var startSuccess = await EmulationService.StartGameAsync(system, file, folder);
             if (!startSuccess)
             {
+                ResetSystemsSelection();
                 await DisplayNotification(GameLoadingFailAlertTitleKey, GameLoadingFailAlertMessageKey);
             }
         }
 
         private void OnCoresInitialized(IEmulationService sender)
         {
-            RaisePropertyChanged(nameof(GameSystems));
+            GameSystems = EmulationService.Systems;
         }
 
         private void OnGameRuntimeExceptionOccurred(IEmulationService sender, Exception e)
         {
+            ResetSystemsSelection();
             DisplayNotification(GameRunningFailAlertTitleKey, GameRunningFailAlertMessageKey);
         }
 
+        private void ResetSystemsSelection()
+        {
+            //Reset systems selection
+            GameSystems = EmulationService.Systems;
+            SelectedGameFile = null;
+        }
+
         private Task DisplayNotification(string titleKey, string messageKey)
         {
             var title = LocalizationService.GetLocalizedString(titleKey);

BeetlePCFX/src

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Package xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10" xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest" xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10" IgnorableNamespaces="uap mp">
-  <Identity Name="15612Aftnet.RetriX" Publisher="CN=Alberto Fustinoni, O=AlbertoFustinoni, L=Kawasaki, S=Kanagawa, C=JP" Version="1.9.2.0" />
+  <Identity Name="15612Aftnet.RetriX" Publisher="CN=Alberto Fustinoni, O=AlbertoFustinoni, L=Kawasaki, S=Kanagawa, C=JP" Version="1.9.3.0" />
   <mp:PhoneIdentity PhoneProductId="efc54b08-6566-4c74-810c-e9437145cdf4" PhonePublisherId="00000000-0000-0000-0000-000000000000" />
   <Properties>
     <DisplayName>ms-resource:AppName\Text</DisplayName>
@@ -169,6 +169,16 @@
             </uap:SupportedFileTypes>
           </uap:FileTypeAssociation>
         </uap:Extension>
+        <uap:Extension Category="windows.fileTypeAssociation">
+          <uap:FileTypeAssociation Name="cuefiles">
+            <uap:DisplayName>ms-resource:CueFileDescription\Text</uap:DisplayName>
+            <uap:Logo>Assets\FileIcon.png</uap:Logo>
+            <uap:InfoTip>ms-resource:CueFileDescription\Text</uap:InfoTip>
+            <uap:SupportedFileTypes>
+              <uap:FileType>.cue</uap:FileType>
+            </uap:SupportedFileTypes>
+          </uap:FileTypeAssociation>
+        </uap:Extension>
       </Extensions>
     </Application>
   </Applications>

BeetlePSX/src

@@ -20,6 +20,8 @@ namespace RetriX.UWP.Services
 {
     public class EmulationService : IEmulationService
     {
+        private static readonly Type GamePlayerPageType = typeof(GamePlayerPage);
+
         private const char CoreExtensionDelimiter = '|';
         private static readonly IReadOnlyDictionary<InjectedInputTypes, InputTypes> InjectedInputMapping = new Dictionary<InjectedInputTypes, InputTypes>
         {
@@ -59,6 +61,7 @@ public class EmulationService : IEmulationService
 
         public event CoresInitializedDelegate CoresInitialized;
         public event GameStartedDelegate GameStarted;
+        public event GameStoppedDelegate GameStopped;
         public event GameRuntimeExceptionOccurredDelegate GameRuntimeExceptionOccurred;
 
         public EmulationService(IFileSystem fileSystem, IUserDialogs dialogsService, ILocalizationService localizationService, IPlatformService platformService, ICryptographyService cryptographyService, IInputManager inputManager)
@@ -104,19 +107,19 @@ public EmulationService(IFileSystem fileSystem, IUserDialogs dialogsService, ILo
             }).ContinueWith(d =>
             {
                 InitializationComplete = true;
-                PlatformService.RunOnUIThreadAsync(() => CoresInitialized(this));
+                PlatformService.RunOnUIThreadAsync(() => CoresInitialized?.Invoke(this));
             });
         }
 
-        public async Task<Shared.ViewModels.GameSystemVM> SuggestSystemForFileAsync(IFileInfo file)
+        public async Task<IEnumerable<GameSystemVM>> FilterSystemsForFileAsync(IFileInfo file)
         {
             while (!InitializationComplete)
             {
                 await Task.Delay(100);
             }
 
             var extension = Path.GetExtension(file.Name);
-            return Systems.FirstOrDefault(d => d.SupportedExtensions.Contains(extension));
+            return Systems.Where(d => d.SupportedExtensions.Contains(extension));
         }
 
         public async Task<bool> StartGameAsync(Shared.ViewModels.GameSystemVM system, IFileInfo file, IDirectoryInfo rootFolder = null)
@@ -125,7 +128,7 @@ public async Task<bool> StartGameAsync(Shared.ViewModels.GameSystemVM system, IF
 
             if (CoreRunner == null)
             {
-                RootFrame.Navigate(typeof(GamePlayerPage));
+                RootFrame.Navigate(GamePlayerPageType);
             }
             else
             {
@@ -176,7 +179,7 @@ public async Task<bool> StartGameAsync(Shared.ViewModels.GameSystemVM system, IF
 
             if (loadSuccessful)
             {
-                GameStarted(this);
+                GameStarted?.Invoke(this);
             }
             else
             {
@@ -194,10 +197,13 @@ public Task ResetGameAsync()
 
         public async Task StopGameAsync()
         {
-            await CoreRunner?.UnloadGameAsync();
-            StreamProvider?.Dispose();
-            StreamProvider = null;
-            RootFrame.GoBack();
+            if (CoreRunner != null)
+            {
+                await CoreRunner.UnloadGameAsync();
+            }
+
+            CleanupAndGoBack();
+            GameStopped?.Invoke(this);
         }
 
         public Task PauseGameAsync()
@@ -253,10 +259,8 @@ private void OnCoreExceptionOccurred(ICore core, Exception e)
         {
             var task = PlatformService.RunOnUIThreadAsync(() =>
             {
-                StreamProvider?.Dispose();
-                StreamProvider = null;
-                RootFrame.GoBack();
-                GameRuntimeExceptionOccurred(this, e);
+                CleanupAndGoBack();
+                GameRuntimeExceptionOccurred?.Invoke(this, e);
             });
         }
 
@@ -293,5 +297,18 @@ private void GetStreamProviderAndVirtualPath(ViewModels.GameSystemVM system, IFi
             var combinedProvider = new CombinedStreamProvider(new HashSet<IStreamProvider> { romProvider, systemProvider, saveProvider });
             provider = combinedProvider;
         }
+
+        private void CleanupAndGoBack()
+        {
+            StreamProvider?.Dispose();
+            StreamProvider = null;
+
+            if (RootFrame.CurrentSourcePageType == GamePlayerPageType)
+            {
+                RootFrame.GoBack();
+            }
+
+            PlatformService.ChangeMousePointerVisibility(MousePointerVisibility.Visible);
+        }
     }
 }

BeetleSaturn/src

@@ -356,4 +356,7 @@ Restart RetriX and try again.</value>
   <data name="CHDRomDescription.Text" xml:space="preserve">
     <value>CHD compressed Rom</value>
   </data>
+  <data name="CueFileDescription.Text" xml:space="preserve">
+    <value>Cue sheet</value>
+  </data>
 </root>